lai/gk-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)

Browse Source
This commit is contained in:
lai
2026-09-06 03:52:57 +08:00
commit b1928b41c0
21813 changed files with 4413081 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sample/common/Makefile
Executable
+33
View File
@@ -0,0 +1,33 @@
ifeq ($(CFG_XMEDIA_EXPORT_FLAG),)
SDK_DIR := $(shell cd $(CURDIR)/../.. && /bin/pwd)
endif
include $(SDK_DIR)/build/base.mk
include $(SAMPLE_DIR)/sample_base.mk
LIB_NAME := libsample_common
SDK_USR_CFLAGS += $(SAMPLE_CFLAGS) $(SAMPLE_LIBS) $(SAMPLE_INCLUDES)
#SRCS := sample_comm_vdec.c
SRCS += sample_comm_vo.c
SRCS += sample_comm_sys.c
SRCS += sample_comm_vi.c
SRCS += sample_comm_vpss.c
#SRCS += sample_comm_mcf.c
SRCS += sample_comm_venc.c
SRCS += sample_comm_isp.c
SRCS += sample_comm_vgs.c
SRCS += sample_comm_audio.c
SRCS += sample_comm_ircut.c
SRCS += loadbmp.c
SRCS += sample_comm_region.c
SRCS += sample_comm_livestream.c
SRCS += sample_comm_periph.c
SRCS += sample_comm_aov.c
SRCS += sample_comm_pq_bin.c
SRCS += sample_comm_thrd_pool.c
SRCS += sample_comm_tp.c
SRCS += sample_comm_tp_i2c.c
include $(SDK_DIR)/build/sdk_lib_rules.mk
sample/common/loadbmp.c
Executable
+697
View File
@@ -0,0 +1,697 @@
/*
Copyright (c), 2001-2021, Shenshu Tech. Co., Ltd.
*/
#include "loadbmp.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#define BITS_NUM_PER_BYTE 8
#define BYTE_PER_PIX_1555 2
#define BYTE_PER_PIX_8888 4
#define PIX_PER_BYTE_CLUT2 4
#define PIX_PER_BYTE_CLUT4 2
#define STRIDE_ALIGN 4
#define MAX_BIT_COUNT 32
#define MAX_OFF_BITS 118
#define MAX_WIDTH 16384
#define MAX_HEIGHT 8192
#ifndef align_up
#define align_up(x, a) ((((x) + ((a) - 1)) / (a)) * (a))
#endif
#ifndef EOK
#define EOK 0
#endif
osd_component_info g_osd_comp_info[OSD_COLOR_FORMAT_BUTT] = {
{ 0, 4, 4, 4 }, /* RGB444 */
{ 4, 4, 4, 4 }, /* ARGB4444 */
{ 0, 5, 5, 5 }, /* RGB555 */
{ 0, 5, 6, 5 }, /* RGB565 */
{ 1, 5, 5, 5 }, /* ARGB1555 */
{ 0, 0, 0, 0 }, /* RESERVED */
{ 0, 8, 8, 8 }, /* RGB888 */
{ 8, 8, 8, 8 } /* ARGB8888 */
};
xmedia_u16 osd_make_color_u16(xmedia_u8 r, xmedia_u8 g, xmedia_u8 b, osd_component_info comp_info)
{
xmedia_u8 r1, g1, b1;
xmedia_u16 pixel = 0;
xmedia_u32 tmp = 15; /* 15bit color data */
r1 = r >> (BITS_NUM_PER_BYTE - comp_info.r_len);
g1 = g >> (BITS_NUM_PER_BYTE - comp_info.g_len);
b1 = b >> (BITS_NUM_PER_BYTE - comp_info.b_len);
while (comp_info.a_len) {
pixel |= (1 << tmp);
tmp--;
comp_info.a_len--;
}
pixel |= (r1 | (g1 << comp_info.b_len) | (b1 << (comp_info.b_len + comp_info.g_len)));
return pixel;
}
xmedia_s32 get_bmp_info(const xmedia_char *filename, osd_bit_map_file_header *bmp_file_header, osd_bit_map_info *bmp_info)
{
FILE *file = XMEDIA_NULL;
xmedia_u16 bf_type;
xmedia_char *path = XMEDIA_NULL;
if (filename == XMEDIA_NULL) {
printf("osd_get_bmp: filename=XMEDIA_NULL\n");
return XMEDIA_FAILURE;
}
if (strlen(filename) > PATH_MAX - 1) {
printf("file name Extra long\n");
return XMEDIA_FAILURE;
}
path = realpath(filename, XMEDIA_NULL);
if (path == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
file = fopen(path, "rb");
if (file == XMEDIA_NULL) {
printf("Open file failed:%s!\n", filename);
goto read_bmp_failed;
}
(xmedia_void)fread(&bf_type, 1, sizeof(bf_type), file);
if (bf_type != 0x4d42) { /* BM */
printf("not bitmap file\n");
fclose(file);
goto read_bmp_failed;
}
(xmedia_void)fread(bmp_file_header, 1, sizeof(osd_bit_map_file_header), file);
(xmedia_void)fread(bmp_info, 1, sizeof(osd_bit_map_info), file);
fclose(file);
free(path);
return XMEDIA_SUCCESS;
read_bmp_failed:
free(path);
return XMEDIA_FAILURE;
}
static xmedia_bool is_support_bmp_file(const osd_bit_map_info *bmp_info, xmedia_u16 bpp_threshold)
{
xmedia_u16 bpp;
bpp = bmp_info->bmp_header.bi_bit_count / BITS_NUM_PER_BYTE;
if (bpp_threshold != 0 && bpp < bpp_threshold) {
printf("bitmap format not supported!\n");
return XMEDIA_FALSE;
}
if (bmp_info->bmp_header.bi_compression != 0) {
printf("not support compressed bitmap file!\n");
return XMEDIA_FALSE;
}
if (bmp_info->bmp_header.bi_height < 0) {
printf("bmp_info.bmp_header.bi_height < 0\n");
return XMEDIA_FALSE;
}
return XMEDIA_TRUE;
}
static xmedia_s32 read_bmp_data(const osd_bit_map_file_header *bmp_file_header, const osd_bit_map_info *bmp_info,
FILE *file, osd_logo *video_logo)
{
xmedia_u8 *rgb_buf = video_logo->rgb_buf;
xmedia_u8 *orig_bmp_buf = NULL;
xmedia_u32 bmp_data_stride;
xmedia_u32 bmp_data_size;
xmedia_u16 bpp, dst_bpp;
xmedia_u16 i, j;
bpp = bmp_info->bmp_header.bi_bit_count / BITS_NUM_PER_BYTE;
dst_bpp = (bpp > 2) ? 4 : 2; /* RGB1555: 2byte, RGB8888: 4byte */
video_logo->width = bmp_info->bmp_header.bi_width;
video_logo->height = bmp_info->bmp_header.bi_height;
if (video_logo->stride == 0) {
video_logo->stride = video_logo->width * dst_bpp;
}
bmp_data_stride = video_logo->width * bpp;
bmp_data_stride = align_up(bmp_data_stride, STRIDE_ALIGN);
bmp_data_size = video_logo->height * bmp_data_stride;
/* RGB8888 or RGB1555 */
orig_bmp_buf = (xmedia_u8 *)malloc(bmp_data_size);
if (orig_bmp_buf == NULL) {
printf("not enough memory to malloc!\n");
return XMEDIA_FAILURE;
}
fseek(file, bmp_file_header->bf_off_bits, 0);
if (fread(orig_bmp_buf, 1, bmp_data_size, file) != bmp_data_size) {
printf("fread error!line:%d\n", __LINE__);
perror("fread:");
}
for (i = 0; i < video_logo->height; i++) {
for (j = 0; j < video_logo->width; ++j) {
memcpy(rgb_buf + i * video_logo->stride + j * dst_bpp, orig_bmp_buf + ((video_logo->height - 1) - i) * bmp_data_stride + j * bpp, sizeof(xmedia_u16));
if (dst_bpp == 4) { /* 4: RGB8888 */
*(rgb_buf + i * video_logo->stride + j * dst_bpp + 3) = 0x80; /* 3: alpha offset */
}
}
}
free(orig_bmp_buf);
return XMEDIA_SUCCESS;
}
xmedia_s32 load_bmp(const xmedia_char *filename, osd_logo *video_logo)
{
osd_bit_map_file_header bmp_file_header;
osd_bit_map_info bmp_info;
FILE *file = XMEDIA_NULL;
xmedia_char *path = XMEDIA_NULL;
if (filename == XMEDIA_NULL || video_logo == XMEDIA_NULL) {
printf("load_bmp: null ptr args!\n");
return XMEDIA_FAILURE;
}
if (strlen(filename) > PATH_MAX - 1) {
printf("file name Extra long\n");
return XMEDIA_FAILURE;
}
path = realpath(filename, XMEDIA_NULL);
if (path == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
if (get_bmp_info(path, &bmp_file_header, &bmp_info) < 0) {
goto read_bmp_failed;
}
if (bmp_info.bmp_header.bi_bit_count > MAX_BIT_COUNT || bmp_info.bmp_header.bi_width > MAX_WIDTH ||
bmp_info.bmp_header.bi_height > MAX_HEIGHT || bmp_file_header.bf_off_bits > MAX_OFF_BITS) {
printf("bmp info error!");
goto read_bmp_failed;
}
if (is_support_bmp_file(&bmp_info, 2) != XMEDIA_TRUE) { /* each pixel should takes 2 (or more) bytes */
goto read_bmp_failed;
}
file = fopen(path, "rb");
if (file == XMEDIA_NULL) {
printf("Open file failed:%s!\n", filename);
goto read_bmp_failed;
}
if (read_bmp_data(&bmp_file_header, &bmp_info, file, video_logo) != XMEDIA_SUCCESS) {
fclose(file);
goto read_bmp_failed;
}
fclose(file);
free(path);
return XMEDIA_SUCCESS;
read_bmp_failed:
free(path);
return XMEDIA_FAILURE;
}
static xmedia_void updata_osd_logo_size_info(const osd_bit_map_info *bmp_info, osd_color_format fmt, osd_logo *video_logo)
{
video_logo->width = bmp_info->bmp_header.bi_width;
video_logo->height = bmp_info->bmp_header.bi_height;
switch (fmt) {
case OSD_COLOR_FORMAT_RGB444:
case OSD_COLOR_FORMAT_RGB555:
case OSD_COLOR_FORMAT_RGB565:
case OSD_COLOR_FORMAT_RGB1555:
case OSD_COLOR_FORMAT_RGB4444:
video_logo->stride = video_logo->width * BYTE_PER_PIX_1555;
return;
case OSD_COLOR_FORMAT_RGB888:
case OSD_COLOR_FORMAT_RGB8888:
video_logo->stride = video_logo->width * BYTE_PER_PIX_8888;
return;
case OSD_COLOR_FORMAT_CLUT2:
video_logo->stride = video_logo->width / PIX_PER_BYTE_CLUT2;
return;
case OSD_COLOR_FORMAT_CLUT4:
video_logo->stride = video_logo->width / PIX_PER_BYTE_CLUT4;
return;
default:
printf("file(%s), line(%d), no such format!\n", __FILE__, __LINE__);
return;
}
}
static xmedia_s32 copy_original_bmp_data(xmedia_u16 bpp, const xmedia_u8 *data, const bmp_data_size_info *data_size_info,
osd_logo *video_logo)
{
xmedia_u32 i, j;
xmedia_u8 *rgb_buf = video_logo->rgb_buf;
for (i = 0; i < data_size_info->height; ++i) {
for (j = 0; j < data_size_info->width; ++j) {
memcpy(rgb_buf + i * video_logo->stride + j * bpp, \
data + ((data_size_info->height - 1) - i) * data_size_info->stride + j * bpp, bpp);
}
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 copy_clut_bmp_data(xmedia_u16 bpp, osd_color_format fmt, const xmedia_u8 *data,
const bmp_data_size_info *data_size_info, osd_logo *video_logo)
{
xmedia_u32 i, j;
xmedia_u8 *rgb_buf = video_logo->rgb_buf;
xmedia_u32 width = data_size_info->width;
if (fmt == OSD_COLOR_FORMAT_CLUT4) {
width /= PIX_PER_BYTE_CLUT4;
} else if (fmt == OSD_COLOR_FORMAT_CLUT2) {
width /= PIX_PER_BYTE_CLUT2;
} else {
}
for (i = 0; i < data_size_info->height; ++i) {
for (j = 0; j < width; ++j) {
memcpy(rgb_buf + i * video_logo->stride + j, \
data + ((data_size_info->height - 1) - i) * data_size_info->stride + j, bpp);
}
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 copy_2byte_bmp(xmedia_u16 bpp, osd_color_format fmt, const xmedia_u8 *data,
const bmp_data_size_info *data_size_info, osd_logo *video_logo)
{
xmedia_u32 i, j;
xmedia_u8 *rgb_buf = video_logo->rgb_buf;
xmedia_u8 r, g, b;
xmedia_u8 *start = XMEDIA_NULL;
xmedia_u16 *dst = XMEDIA_NULL;
/* start color convert */
for (i = 0; i < data_size_info->height; ++i) {
for (j = 0; j < data_size_info->width; ++j) {
start = (xmedia_u8 *)(data + ((data_size_info->height - 1) - i) * data_size_info->stride + j * bpp);
dst = (xmedia_u16 *)(rgb_buf + i * video_logo->stride + j * 2); /* 2 bytes */
r = *(start);
g = *(start + 1);
b = *(start + 2); /* 2 bytes offset */
*dst = osd_make_color_u16(r, g, b, g_osd_comp_info[fmt]);
}
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 copy_4byte_bmp(xmedia_u16 bpp, const xmedia_u8 *data, const bmp_data_size_info *data_size_info,
osd_logo *video_logo)
{
xmedia_u32 i, j;
xmedia_u8 *rgb_buf = video_logo->rgb_buf;
for (i = 0; i < data_size_info->height; ++i) {
for (j = 0; j < data_size_info->width; ++j) {
memcpy(rgb_buf + i * video_logo->stride + j * 4, \
data + ((data_size_info->height - 1) - i) * data_size_info->stride + j * bpp, bpp);
*(rgb_buf + i * video_logo->stride + j * 4 + 3) = 0xff; /* 4 bytes data, alpha offset is 3 */
}
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 copy_original_bmp_data_and_fill_alpha(xmedia_u16 bpp, osd_color_format fmt, const xmedia_u8 *data,
const bmp_data_size_info *data_size_info, osd_logo *video_logo)
{
switch (fmt) {
case OSD_COLOR_FORMAT_RGB444:
case OSD_COLOR_FORMAT_RGB555:
case OSD_COLOR_FORMAT_RGB565:
case OSD_COLOR_FORMAT_RGB1555:
case OSD_COLOR_FORMAT_RGB4444:
return copy_2byte_bmp(bpp, fmt, data, data_size_info, video_logo);
case OSD_COLOR_FORMAT_RGB888:
case OSD_COLOR_FORMAT_RGB8888:
return copy_4byte_bmp(bpp, data, data_size_info, video_logo);
default:
printf("file(%s), line(%d), no such format!\n", __FILE__, __LINE__);
return XMEDIA_FAILURE;
}
}
static xmedia_s32 read_bmp_data_ex(const osd_bit_map_file_header *bmp_file_header, const osd_bit_map_info *bmp_info,
FILE *file, osd_logo *video_logo, osd_color_format fmt)
{
xmedia_u8 *orig_bmp_buf = NULL;
xmedia_u16 bpp = bmp_info->bmp_header.bi_bit_count / BITS_NUM_PER_BYTE;
xmedia_u32 bmp_data_stride;
xmedia_u32 bmp_data_size;
xmedia_s32 ret = XMEDIA_SUCCESS;
bmp_data_size_info data_size_info;
updata_osd_logo_size_info(bmp_info, fmt, video_logo);
bmp_data_stride = (bpp == 0) ? video_logo->stride : (video_logo->width * bpp);
bmp_data_stride = align_up(bmp_data_stride, STRIDE_ALIGN);
bmp_data_size = video_logo->height * bmp_data_stride;
data_size_info.width = video_logo->width;
data_size_info.height = video_logo->height;
data_size_info.stride = bmp_data_stride;
orig_bmp_buf = (xmedia_u8 *)malloc(bmp_data_size);
if (orig_bmp_buf == NULL) {
printf("not enough memory to malloc!\n");
return XMEDIA_FAILURE;
}
fseek(file, bmp_file_header->bf_off_bits, 0);
if (fread(orig_bmp_buf, 1, bmp_data_size, file) != bmp_data_size) {
printf("fread error!line:%d\n", __LINE__);
perror("fread:");
}
/* copy bmp data to rgb_buf according bpp (and fmt) */
if (bpp == 2 || bpp == 4) { /* each pixel takes 2 (or 4) bytes */
ret = copy_original_bmp_data(bpp, orig_bmp_buf, &data_size_info, video_logo);
goto copy_over_exit;
}
if (bpp <= 1) { /* such as clut2 or clut 4, or 2BPP... */
ret = copy_clut_bmp_data(bpp, fmt, orig_bmp_buf, &data_size_info, video_logo);
goto copy_over_exit;
}
/* bpp should equal to 3 here */
ret = copy_original_bmp_data_and_fill_alpha(bpp, fmt, orig_bmp_buf, &data_size_info, video_logo);
copy_over_exit:
free(orig_bmp_buf);
return ret;
}
xmedia_s32 load_bmp_ex(const xmedia_char *filename, osd_logo *video_logo, osd_color_format fmt)
{
osd_bit_map_file_header bmp_file_header;
osd_bit_map_info bmp_info;
FILE *file = XMEDIA_NULL;
xmedia_char *path = XMEDIA_NULL;
if (filename == XMEDIA_NULL || video_logo == XMEDIA_NULL) {
printf("load_bmp_ex: null ptr args!\n");
return XMEDIA_FAILURE;
}
if (strlen(filename) > PATH_MAX - 1) {
printf("file name Extra long\n");
return XMEDIA_FAILURE;
}
path = realpath(filename, XMEDIA_NULL);
if (path == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
if (get_bmp_info(path, &bmp_file_header, &bmp_info) < 0) {
goto read_bmp_failed;
}
if (bmp_info.bmp_header.bi_bit_count > MAX_BIT_COUNT || bmp_info.bmp_header.bi_width > MAX_WIDTH ||
bmp_info.bmp_header.bi_height > MAX_HEIGHT || bmp_file_header.bf_off_bits > MAX_OFF_BITS) {
printf("bmp info error!");
goto read_bmp_failed;
}
if (is_support_bmp_file(&bmp_info, 0) != XMEDIA_TRUE) {
goto read_bmp_failed;
}
file = fopen(path, "rb");
if (file == XMEDIA_NULL) {
printf("Open file failed:%s!\n", filename);
goto read_bmp_failed;
}
if (read_bmp_data_ex(&bmp_file_header, &bmp_info, file, video_logo, fmt) != XMEDIA_SUCCESS) {
fclose(file);
goto read_bmp_failed;
}
fclose(file);
free(path);
return XMEDIA_SUCCESS;
read_bmp_failed:
free(path);
return XMEDIA_FAILURE;
}
static xmedia_s32 read_bmp_canvas(const osd_bit_map_file_header *bmp_file_header, const osd_bit_map_info *bmp_info,
FILE *file, osd_logo *video_logo, osd_color_format fmt)
{
xmedia_u8 *orig_bmp_buf = NULL;
xmedia_u16 bpp = bmp_info->bmp_header.bi_bit_count / BITS_NUM_PER_BYTE;
xmedia_u32 bmp_data_size;
xmedia_s32 ret = XMEDIA_SUCCESS;
bmp_data_size_info data_size_info;
data_size_info.width = bmp_info->bmp_header.bi_width;
data_size_info.height = bmp_info->bmp_header.bi_height;
if (bpp == 0) {
if (fmt == OSD_COLOR_FORMAT_CLUT2) {
data_size_info.stride = data_size_info.width / PIX_PER_BYTE_CLUT2;
} else if (fmt == OSD_COLOR_FORMAT_CLUT4) {
data_size_info.stride = data_size_info.width / PIX_PER_BYTE_CLUT4;
} else {
data_size_info.stride = video_logo->stride;
}
} else {
data_size_info.stride = data_size_info.width * bpp;
data_size_info.stride = align_up(data_size_info.stride, STRIDE_ALIGN);
}
bmp_data_size = data_size_info.height * data_size_info.stride;
orig_bmp_buf = (xmedia_u8 *)malloc(bmp_data_size);
if (orig_bmp_buf == NULL) {
printf("not enough memory to malloc!\n");
return XMEDIA_FAILURE;
}
fseek(file, bmp_file_header->bf_off_bits, 0);
if (fread(orig_bmp_buf, 1, bmp_data_size, file) != bmp_data_size) {
printf("fread error!line:%d\n", __LINE__);
perror("fread:");
}
/* copy bmp data to rgb_buf according bpp (and fmt) */
if (bpp == 2 || bpp == 4) { /* each pixel takes 2 (or 4) bytes */
ret = copy_original_bmp_data(bpp, orig_bmp_buf, &data_size_info, video_logo);
goto copy_over_exit;
}
if (bpp <= 1) { /* such as clut2 or clut 4, or 2BPP... */
ret = copy_clut_bmp_data(bpp, fmt, orig_bmp_buf, &data_size_info, video_logo);
goto copy_over_exit;
}
/* bpp should equal to 3 here */
ret = copy_original_bmp_data_and_fill_alpha(bpp, fmt, orig_bmp_buf, &data_size_info, video_logo);
copy_over_exit:
free(orig_bmp_buf);
return ret;
}
xmedia_s32 load_bmp_canvas(const xmedia_char *filename, osd_logo *video_logo, osd_color_format fmt)
{
osd_bit_map_file_header bmp_file_header;
osd_bit_map_info bmp_info;
FILE *file = XMEDIA_NULL;
xmedia_char *path = XMEDIA_NULL;
if (filename == XMEDIA_NULL || video_logo == XMEDIA_NULL) {
printf("load_bmp_canvas: null ptr args!\n");
return XMEDIA_FAILURE;
}
if (strlen(filename) > PATH_MAX - 1) {
printf("file name Extra long\n");
return XMEDIA_FAILURE;
}
path = realpath(filename, XMEDIA_NULL);
if (path == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
if (get_bmp_info(path, &bmp_file_header, &bmp_info) < 0) {
goto read_bmp_failed;
}
if (bmp_info.bmp_header.bi_bit_count > MAX_BIT_COUNT || bmp_info.bmp_header.bi_width > MAX_WIDTH ||
bmp_info.bmp_header.bi_height > MAX_HEIGHT || bmp_file_header.bf_off_bits > MAX_OFF_BITS) {
printf("bmp info error!");
goto read_bmp_failed;
}
if (is_support_bmp_file(&bmp_info, 0) != XMEDIA_TRUE) {
goto read_bmp_failed;
}
file = fopen(path, "rb");
if (file == XMEDIA_NULL) {
printf("Open file failed:%s!\n", filename);
goto read_bmp_failed;
}
if (read_bmp_canvas(&bmp_file_header, &bmp_info, file, video_logo, fmt) != XMEDIA_SUCCESS) {
fclose(file);
goto read_bmp_failed;
}
fclose(file);
free(path);
return XMEDIA_SUCCESS;
read_bmp_failed:
free(path);
return XMEDIA_FAILURE;
}
xmedia_char *get_ext_name(const xmedia_char *filename)
{
xmedia_char *pret = XMEDIA_NULL;
xmedia_u32 len;
if (filename == XMEDIA_NULL) {
printf("filename can't be null!");
return XMEDIA_NULL;
}
len = strlen(filename);
while (len) {
pret = (xmedia_char *)(filename + len);
if (*pret == '.') {
return (pret + 1);
}
len--;
}
return pret;
}
xmedia_s32 load_image(const xmedia_char *filename, osd_logo *video_logo)
{
xmedia_char *ext = get_ext_name(filename);
if (ext == XMEDIA_NULL) {
printf("get_ext_name error!\n");
return -1;
}
if (strcmp(ext, "bmp") == 0) {
if (load_bmp(filename, video_logo) != 0) {
printf("load_bmp error!\n");
return -1;
}
} else {
printf("not supported image file!\n");
return -1;
}
return 0;
}
xmedia_s32 load_image_ex(const xmedia_char *filename, osd_logo *video_logo, osd_color_format fmt)
{
xmedia_char *ext = get_ext_name(filename);
if (ext == XMEDIA_NULL) {
printf("load_image_ex error!\n");
return -1;
}
if (strcmp(ext, "bmp") == 0) {
if (load_bmp_ex(filename, video_logo, fmt) != 0) {
printf("load_bmp_ex error!\n");
return -1;
}
} else {
printf("not supported image file!\n");
return -1;
}
return 0;
}
xmedia_s32 load_canvas_ex(const xmedia_char *filename, osd_logo *video_logo, osd_color_format fmt)
{
xmedia_char *ext = get_ext_name(filename);
if (ext == XMEDIA_NULL) {
printf("load_canvas_ex error!\n");
return -1;
}
if (strcmp(ext, "bmp") == 0) {
if (load_bmp_canvas(filename, video_logo, fmt) != 0) {
printf("OSD_LoadBMP error!\n");
return -1;
}
} else {
printf("not supported image file!\n");
return -1;
}
return 0;
}
xmedia_s32 load_bit_map_to_surface(const xmedia_char *file_name, const osd_surface *surface, xmedia_u8 *virt)
{
osd_logo logo;
logo.stride = surface->stride;
logo.rgb_buf = virt;
return load_image(file_name, &logo);
}
xmedia_s32 create_surface_by_bit_map(const xmedia_char *file_name, osd_surface *surface, xmedia_u8 *virt)
{
osd_logo logo;
logo.rgb_buf = virt;
if (load_image_ex(file_name, &logo, surface->color_format) < 0) {
printf("load bmp error!\n");
return -1;
}
surface->height = logo.height;
surface->width = logo.width;
surface->stride = logo.stride;
return 0;
}
xmedia_s32 create_surface_by_canvas(const xmedia_char *file_name, osd_surface *surface, xmedia_u8 *virt,
const canvas_size_info *canvas_size)
{
osd_logo logo;
logo.rgb_buf = virt;
logo.width = canvas_size->width;
logo.height = canvas_size->height;
logo.stride = canvas_size->stride;
if (load_canvas_ex(file_name, &logo, surface->color_format) < 0) {
printf("load bmp error!\n");
return -1;
}
surface->height = canvas_size->height;
surface->width = canvas_size->width;
surface->stride = canvas_size->stride;
return 0;
}
sample/common/loadbmp.h
Executable
+110
View File
@@ -0,0 +1,110 @@
/*
Copyright (c), 2001-2021, Shenshu Tech. Co., Ltd.
*/
#ifndef __LOAD_BMP_H__
#define __LOAD_BMP_H__
#include "xmedia_type.h"
/* the color format OSD supported */
typedef enum {
OSD_COLOR_FORMAT_RGB444 = 0,
OSD_COLOR_FORMAT_RGB4444 = 1,
OSD_COLOR_FORMAT_RGB555 = 2,
OSD_COLOR_FORMAT_RGB565 = 3,
OSD_COLOR_FORMAT_RGB1555 = 4,
OSD_COLOR_FORMAT_RGB888 = 6,
OSD_COLOR_FORMAT_RGB8888 = 7,
OSD_COLOR_FORMAT_CLUT2 = 8,
OSD_COLOR_FORMAT_CLUT4 = 9,
OSD_COLOR_FORMAT_BUTT
} osd_color_format;
typedef struct {
xmedia_u8 r;
xmedia_u8 g;
xmedia_u8 b;
xmedia_u8 reserved;
} osd_rgb;
typedef struct {
osd_color_format color_format; /* color format */
xmedia_u16 height; /* operation height */
xmedia_u16 width; /* operation width */
xmedia_u16 stride; /* surface stride */
xmedia_u16 reserved;
xmedia_u8 *virt_addr; /* virtual address */
} osd_surface;
typedef struct {
xmedia_u32 width; /* out */
xmedia_u32 height; /* out */
xmedia_u32 stride; /* in */
xmedia_u8 *rgb_buf; /* in/out */
} osd_logo;
typedef struct {
xmedia_u16 bi_size;
xmedia_u32 bi_width;
xmedia_s32 bi_height;
xmedia_u16 bi_planes;
xmedia_u16 bi_bit_count;
xmedia_u32 bi_compression;
xmedia_u32 bi_size_image;
xmedia_u32 bi_x_pels_per_meter;
xmedia_u32 bi_y_pels_per_meter;
xmedia_u32 bi_clr_used;
xmedia_u32 bi_clr_important;
} osd_bit_map_info_header;
typedef struct {
xmedia_u32 bf_size;
xmedia_u16 bf_reserved1;
xmedia_u16 bf_reserved2;
xmedia_u32 bf_off_bits;
} osd_bit_map_file_header;
typedef struct {
xmedia_u8 blue;
xmedia_u8 green;
xmedia_u8 red;
xmedia_u8 reserved;
} osd_rgb_quad;
typedef struct {
osd_bit_map_info_header bmp_header;
osd_rgb_quad bmp_colors[1];
} osd_bit_map_info;
typedef struct {
xmedia_u8 a_len;
xmedia_u8 r_len;
xmedia_u8 g_len;
xmedia_u8 b_len;
} osd_component_info;
typedef struct {
xmedia_u32 width;
xmedia_u32 height;
xmedia_u32 stride;
} canvas_size_info;
typedef canvas_size_info bmp_data_size_info;
#ifdef __cplusplus
extern "C" {
#endif
xmedia_s32 load_image(const xmedia_char *filename, osd_logo *video_logo);
xmedia_s32 load_bit_map_to_surface(const xmedia_char *file_name, const osd_surface *surface, xmedia_u8 *virt);
xmedia_s32 create_surface_by_bit_map(const xmedia_char *file_name, osd_surface *surface, xmedia_u8 *virt);
xmedia_s32 create_surface_by_canvas(const xmedia_char *file_name, osd_surface *surface, xmedia_u8 *virt,
const canvas_size_info *canvas_size);
xmedia_s32 get_bmp_info(const xmedia_char *filename, osd_bit_map_file_header *bmp_file_header, osd_bit_map_info *bmp_info);
#ifdef __cplusplus
}
#endif
#endif /* End of #ifndef __LOAD_BMP_H__ */
sample/common/sample_comm.h
Executable
+244
View File
@@ -0,0 +1,244 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_H__
#define __SAMPLE_COMM_H__
#include "xmedia_type.h"
#include "xmedia_video_common.h"
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif /* End of #ifdef __cplusplus */
#define SAMPLE_PRT(fmt...) \
do {\
printf("[%s]-%d: ", __FUNCTION__, __LINE__);\
printf(fmt);\
} while(0)
#define SAMPLE_ERR(fmt...) \
do {\
printf("[%s]-%d: ", __FUNCTION__, __LINE__);\
printf(fmt);\
} while(0)
#ifndef CHECK_RET
#define CHECK_RET(express, name)\
do {\
xmedia_s32 express_ret;\
express_ret = express;\
if (XMEDIA_SUCCESS != express_ret) {\
printf("%s failed at %s: line: %d with %#x!\n", name, __FUNCTION__, __LINE__, express_ret);\
return express_ret;\
}\
} while (0)
#endif
#define CHECK_NULL_PTR(p)\
do {\
if (XMEDIA_NULL == p) {\
printf("null ptr at %s: line: %d\n", __FUNCTION__, __LINE__);\
return XMEDIA_FAILURE;\
}\
} while (0)
#define CHECK_NULL_PTR_VOID(p)\
do {\
if (XMEDIA_NULL == p) {\
printf("null ptr at %s: line: %d\n", __FUNCTION__, __LINE__);\
}\
} while (0)
#define PAUSE(exit)\
printf("---------------press any key to exit!---------------\n");\
do {\
xmedia_s32 c = sample_comm_sys_getchar_timeout(200);\
if (XMEDIA_FAILURE != c) {\
break;\
}\
} while (!exit)
#define SAMPLE_COMM_COMPONENT_NUM 3
#define MAX_SENSOR_NUM 5
#define MAX_SCREEN_NUM 2
typedef enum pic_size_e
{
PIC_CIF,
PIC_360P, /* 640 * 360 */
PIC_VGA,
PIC_640x360,
PIC_D1_PAL, /* 720 * 576 */
PIC_D1_NTSC, /* 720 * 480 */
PIC_720P, /* 1280 * 720 */
PIC_1080P, /* 1920 * 1080 */
PIC_2304x1296,
PIC_2560x1440,
PIC_2560x1920,
PIC_2592x1520,
PIC_2592x1536,
PIC_2592x1944,
PIC_2688x1520,
PIC_2688x1536,
PIC_2688x1944,
PIC_2716x1524,
PIC_2880x1620,
PIC_3840x2160,
PIC_4096x2160,
PIC_3000x3000,
PIC_4000x3000,
PIC_7680x4320,
PIC_3840x8640,
PIC_3072x1728,
PIC_BUTT
} pic_size_e;
typedef enum {
SONY_IMX290_MIPI_2M_30FPS_10BIT = 0,
SONY_IMX290_MIPI_2M_30FPS_16BIT,
SONY_IMX290_MIPI_2M_30FPS_10BIT_WDR2TO1,
SONY_IMX327_MIPI_2M_30FPS_12BIT,
SONY_IMX307_MIPI_2M_2L_30FPS_10BIT,
SONY_IMX307_MIPI_2M_2L_30FPS_10BIT_WDR2TO1,
SONY_IMX415_MIPI_8M_20FPS_10BIT,
SONY_IMX415_MIPI_8M_20FPS_10BIT_WDR2TO1,
SONY_IMX678_MIPI_8M_20FPS_12BIT,
SONY_IMX678_MIPI_8M_20FPS_10BIT_WDR2TO1,
SONY_IMX179_MIPI_8M_20FPS_10BIT,
SONY_IMX179_MIPI_640_480_120FPS_10BIT,
GALAXYCORE_GC2053_MIPI_2M_30FPS_10BIT,
GALAXYCORE_GC2053_MIPI_2M_30FPS_10BIT_WDR2TO1,
GALAXYCORE_GC20C3_MIPI_2M_30FPS_10BIT,
GALAXYCORE_GC2083_MIPI_2M_30FPS_10BIT,
GALAXYCORE_GC4663_MIPI_4M_30FPS_10BIT,
GALAXYCORE_GC4663_MIPI_4M_25FPS_10BIT_WDR2TO1,
GALAXYCORE_GC8613_MIPI_8M_20FPS_14BIT,
GALAXYCORE_GC8613_MIPI_8M_20FPS_10BIT,
GALAXYCORE_GC5603_MIPI_5M_30FPS_10BIT,
GALAXYCORE_GC4653_MIPI_4M_30FPS_10BIT,
GALAXYCORE_GC6603_MIPI_5M_30FPS_10BIT,
GALAXYCORE_OV4689_MIPI_4M_30FPS_10BIT,
SMART_SC8238_MIPI_2M_30FPS_10BIT,
SMART_SC8238_MIPI_2M_30FPS_10BIT_WDR2TO1,
SMART_SC8238_MIPI_3M_30FPS_10BIT,
SMART_SC8238_MIPI_3M_30FPS_10BIT_WDR2TO1,
SMART_SC8238_MIPI_4M_30FPS_10BIT,
SMART_SC8238_MIPI_4M_30FPS_10BIT_WDR2TO1,
SMART_SC8238_MIPI_5M_30FPS_10BIT,
SMART_SC8238_MIPI_5M_30FPS_10BIT_WDR2TO1,
SMART_SC8238_MIPI_8M_20FPS_10BIT,
SMART_SC8238_MIPI_8M_20FPS_10BIT_WDR2TO1,
SMART_SC4336_MIPI_4M_30FPS_10BIT,
SMART_SC4336P_MIPI_4M_30FPS_10BIT,
SMART_SC3338_MIPI_3M_30FPS_10BIT,
OMNIVISION_OS08A20_MIPI_2M_30FPS_10BIT,
OMNIVISION_OS08A20_MIPI_2M_30FPS_10BIT_WDR2TO1,
OMNIVISION_OS08A20_MIPI_4M_30FPS_10BIT,
OMNIVISION_OS08A20_MIPI_4M_30FPS_10BIT_WDR2TO1,
OMNIVISION_OS08A20_MIPI_5M_30FPS_10BIT,
OMNIVISION_OS08A20_MIPI_5M_30FPS_10BIT_WDR2TO1,
OMNIVISION_OS08A20_MIPI_8M_20FPS_10BIT,
OMNIVISION_OS08A20_MIPI_8M_20FPS_10BIT_WDR2TO1,
OMNIVISION_OS05A10_MIPI_4M_30FPS_12BIT,
OMNIVISION_OS05A10_MIPI_4M_30FPS_10BIT_WDR2TO1,
OMNIVISION_OS05A10_MIPI_5M_30FPS_12BIT,
OMNIVISION_OS05A10_MIPI_5M_30FPS_10BIT_WDR2TO1,
OMNIVISION_OS02K10_MIPI_2M_30FPS_10BIT,
OMNIVISION_OS02K10_MIPI_2M_30FPS_12BIT_BUILT_IN,
OMNIVISION_OX03F10_MIPI_1M_10FPS_14BIT_BUILT_IN,
OMNIVISION_OX03F10_MIPI_3M_60FPS_14BIT_BUILT_IN,
OMNIVISION_OX03F10_MIPI_3M_60FPS_10BIT,
SMART_SC850SL_MIPI_8M_20FPS_12BIT,
SMART_SC850SL_MIPI_8M_20FPS_10BIT_WDR2TO1,
SMART_SC850SL_MIPI_5M_30FPS_12BIT,
SMART_SC850SL_MIPI_5M_20FPS_10BIT_WDR2TO1,
SMART_SC850SL_MIPI_4M_30FPS_12BIT,
SMART_SC850SL_MIPI_4M_20FPS_10BIT_WDR2TO1,
SMART_SC485SL_MIPI_4M_2688_1520_30FPS_4LANE_12BIT,
SMART_SC485SL_MIPI_4M_2560_1440_30FPS_4LANE_12BIT,
SMART_SC485SL_MIPI_4M_30FPS_2LANE_12BIT,
SMART_SC485SL_MIPI_4M_30FPS_4LANE_10BIT_WDR2TO1,
SMART_SC231HAI_MIPI_2M_2LANE_30FPS_10BIT,
SMART_SC235HAI_MIPI_2M_2LANE_30FPS_10BIT,
SMART_SC431HAI_MIPI_4M_30FPS_10BIT,
SMART_SC435HAI_MIPI_4M_30FPS_10BIT,
SMART_SC285SL_MIPI_2M_4LANE_30FPS_12BIT,
SMART_SC285SL_MIPI_2M_2LANE_30FPS_12BIT,
SMART_SC533HAI_MIPI_5M_2L_30FPS_10BIT,
SMART_SC465SL_MIPI_4M_4LANE_30FPS_12BIT,
SMART_SC465SL_MIPI_4M_2LANE_30FPS_12BIT,
SMART_SC465SL_MIPI_4M_30FPS_4LANE_10BIT_WDR2TO1,
IMAGEDESIGN_MIS40H1_MIPI_4M_2LANE_30FPS_10BIT,
IMAGEDESIGN_MIS20S1_MIPI_2M_2LANE_30FPS_10BIT,
CVSENS_CV4003_MIPI_4M_30FPS_10BIT,
CVSENS_CV4003_MIPI_1M_120FPS_10BIT_PREROLL_READBACK,
CVSENS_CV2005_MIPI_2M_30FPS_10BIT,
SMART_SC200AI_MIPI_2M_30FPS_10BIT,
SMART_SC200AI_MIPI_2M_30FPS_10BIT_WDR2TO1,
SMART_SC500AI_MIPI_5M_30FPS_10BIT,
SMART_SC500AI_MIPI_5M_30FPS_10BIT_WDR2TO1,
SMART_SC450AI_MIPI_4M_30FPS_10BIT,
SMART_SC2337P_MIPI_2M_30FPS_10BIT,
SMART_SC530AI_MIPI_5M_4L_30FPS_10BIT,
SMART_SC530AI_MIPI_5M_2L_30FPS_10BIT,
SMART_SC530AI_MIPI_5M_4L_30FPS_10BIT_WDR2TO1,
OMNIVISION_OS04A10_MIPI_4M_30FPS_12BIT,
OMNIVISION_OS04A10_MIPI_4M_30FPS_10BIT_WDR2TO1,
OMNIVISION_OS04D10_MIPI_4M_30FPS_10BIT,
OMNIVISION_OS04C10_MIPI_4M_30FPS_10BIT,
OMNIVISION_OS04J10_MIPI_4M_30FPS_12BIT,
SONY_IMX334_MIPI_8M_20FPS_12BIT,
OMNIVISION_OX05B1S_MIPI_1M_30FPS_10BIT, //RGBIR
OMNIVISION_OX05B1S_MIPI_5M_60FPS_10BIT,
VI_AHD_MIPI_2M_YUV,
SENSOR_TYPE_INVALID,
} sample_comm_sensor_type;
typedef struct {
xmedia_video_format video_fmt;
xmedia_video_pixel_format pixel_fmt;
xmedia_video_data_width data_width;
xmedia_video_compress_mode compress_mode;
} sample_comm_video_param;
typedef enum {
BOARD_TYPE_XM7206_V10_RB = 0,
BOARD_TYPE_XM7206_V10B_RBA,
BOARD_TYPE_XM7206_V10B_EVB,
BOARD_TYPE_XM7206_V11A_RBA,
BOARD_TYPE_XM7206_V11A_EVB,
BOARD_TYPE_MAX,
} sample_comm_board_type;
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* End of #ifdef __cplusplus */
#endif /* End of #ifndef __SAMPLE_COMM_H__ */
sample/common/sample_comm_aov.c
Executable
+1741
View File
File diff suppressed because it is too large Load Diff
sample/common/sample_comm_aov.h
Executable
+140
View File
@@ -0,0 +1,140 @@
#ifndef __SAMPLE_COMM_AOV_H__
#define __SAMPLE_COMM_AOV_H__
#include <stdio.h>
#include "xmedia_type.h"
#include "xmedia_video_common.h"
#include "xmedia_sys.h"
#include "xmedia_vb.h"
#include "xmedia_vi.h"
#include "xmedia_isp.h"
#include "xmedia_ae.h"
#include "xmedia_awb.h"
#include "xmedia_venc.h"
#include "xmedia_vpss.h"
#include "xmedia_vgs.h"
#include "xmedia_svp.h"
#include "xmedia_tde.h"
#include "xmedia_pm.h"
#include "xmedia_cl.h"
#include "xmedia_mmz.h"
#include "xmedia_ive_common.h"
#include "xmedia_ive.h"
#include "xmedia_md.h"
#include "drv_misc.h"
#define NPU_CHN_WIDTH 640
#define NPU_CHN_HEIGHT 360
#define NPU_NORMAL_STATE_CONTINUE_COUNT 300
#define VENC_STR_BUF_DEFAULT_MAX_FRAME_COUNT 600
#define RTC_SAFE_THRESOHLD_MS 50
#define AOV_IVE_MD_IMAGE_NUM 2
#define IVE_DETECT_SUPPORT 1
//#define APP_STANDBY_SENSOR 1
//#define AOV_APP_TIMESTAMP 1
#define SDCARD_USE_SDIO0 1 //demo板使用SDIO0连接SD卡，若硬件修改为SDIO1连接SD卡，需将SDCARD_USE_SDIO0宏修改为0
#define AOV_SUPPORT_MAX_SENSOR_NUM 2
typedef struct aov_ive_param {
xmedia_s32 md_chn;
xmedia_ive_src_image_s astImg[AOV_IVE_MD_IMAGE_NUM];
xmedia_s32 cur_idx;
xmedia_ive_dst_mem_info_s stBlob;
xmedia_md_attr_s stMdAttr;
xmedia_bool is_first_frm;
} aov_ive_param;
typedef enum sample_aov_work_mode {
MEDIA_WORK_AOV = 0,
MEDIA_WORK_NORMAL,
} sample_aov_work_mode;
#ifdef APP_STANDBY_SENSOR
typedef enum sensor_status_ {
SENSOR_STATUS_NONE = 0,
SENSOR_STATUS_START,
SENSOR_STATUS_STANDBY,
SENSOR_STATUS_RESUME,
} sensor_status_t;
#endif
typedef struct sample_aov_venc_chn_frame {
xmedia_s32 venc_chn_num;
xmedia_s32 venc_chn[VENC_MAX_CHN_NUM];
xmedia_u32 frame_num[VENC_MAX_CHN_NUM];
} sample_aov_venc_chn_frame;
typedef struct sample_aov_isp_param {
xmedia_s32 isp_pipe_num;
xmedia_s32 isp_pipe[VI_MAX_DEV_NUM];
} sample_aov_isp_param;
typedef struct sample_aov_venc_param {
xmedia_s32 venc_chn_num;
xmedia_bool en_aov[VENC_MAX_CHN_NUM];
xmedia_s32 venc_chn[VENC_MAX_CHN_NUM];
xmedia_s32 chn_max_size[VENC_MAX_CHN_NUM];
xmedia_s32 chn_threshold_size[VENC_MAX_CHN_NUM];
} sample_aov_venc_param;
typedef struct sample_aov_vpss_normal_only_param {
xmedia_s32 vpss_pipe_num;
xmedia_s32 vpss_pipe[VPSS_MAX_PIPE_NUM];
xmedia_s32 vpss_ochn_num[VPSS_MAX_PIPE_NUM];
xmedia_s32 vpss_ochn[VPSS_MAX_PIPE_NUM][VPSS_MAX_OCHN_NUM];
} sample_aov_vpss_normal_only_param;
typedef struct sample_aov_vpss_npu_param {
xmedia_s32 npu_detect_num;
xmedia_s32 npu_svp_handle[VPSS_MAX_PIPE_NUM];
xmedia_bool en_switch_mode[VPSS_MAX_PIPE_NUM];
xmedia_s32 vpss_pipe[VPSS_MAX_PIPE_NUM];
xmedia_s32 vpss_ochn[VPSS_MAX_PIPE_NUM];
} sample_aov_vpss_npu_param;
typedef xmedia_void (*sample_aov_normal_npu_notice)(sample_aov_work_mode);
typedef xmedia_void (*sample_aov_normal_resume)(xmedia_void);
typedef xmedia_void (*sample_aov_normal_suspend)(xmedia_void);
typedef struct sample_aov_init_param {
xmedia_s32 suspend_time;
sample_aov_normal_npu_notice npu_notice_callback;
sample_aov_normal_resume normal_resume_callback;
sample_aov_normal_suspend normal_suspend_callback;
sample_aov_isp_param isp_param;//sensor standby or resume used.
sample_aov_vpss_normal_only_param vpss_param;//aov mode:vpss ochn should disable.
sample_aov_vpss_npu_param npu_param;//npu detect. svp handle vpss pipe & ochn.
sample_aov_venc_param venc_param;// venc chn param.
#ifdef APP_STANDBY_SENSOR
sensor_status_t sensor_status[AOV_SUPPORT_MAX_SENSOR_NUM];
#endif
} sample_aov_init_param;
typedef struct sample_aov_detect_ {
#ifdef IVE_DETECT_SUPPORT
aov_ive_param ive_param[AOV_SUPPORT_MAX_SENSOR_NUM];
#endif
xmedia_svp_aov_detect_output svp_result[AOV_SUPPORT_MAX_SENSOR_NUM];
xmedia_s32 svp_detect_none_cnt[AOV_SUPPORT_MAX_SENSOR_NUM];
xmedia_s32 detect_complete_flag[AOV_SUPPORT_MAX_SENSOR_NUM];
}sample_aov_detect_t;
xmedia_void sample_comm_aov_init(sample_aov_init_param *aov_init_param);
xmedia_void sample_comm_aov_exit(xmedia_void);
xmedia_void sample_comm_aov_set_work_mode(sample_aov_work_mode work_mode);
xmedia_void sample_comm_aov_get_work_mode(sample_aov_work_mode *work_mode);
xmedia_s32 sample_comm_aov_npu_init(xmedia_void);
xmedia_s32 sample_comm_aov_npu_create(xmedia_s32 *handle, xmedia_svp_task_cfg *task_cfg);
xmedia_s32 sample_comm_aov_npu_destroy(xmedia_s32 handle);
xmedia_void sample_comm_aov_npu_exit(xmedia_void);
xmedia_s32 sample_comm_aov_venc_thread_create(xmedia_void);
xmedia_s32 sample_comm_aov_venc_thread_destroy(xmedia_void);
xmedia_s32 sample_comm_aov_work_thread_create(xmedia_void);
xmedia_s32 sample_comm_aov_work_thread_destroy(xmedia_void);
xmedia_s32 sample_comm_aov_misc_init(misc_aov_isp_info *isp_info);
xmedia_s32 sample_comm_aov_get_misc_fd(xmedia_void);
#endif //__SAMPLE_COMM_AOV_H__
sample/common/sample_comm_audio.c
+2037
View File
File diff suppressed because it is too large Load Diff
sample/common/sample_comm_audio.h
+137
View File
@@ -0,0 +1,137 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_AUDIO_H__
#define __SAMPLE_COMM_AUDIO_H__
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "common.h"
#include "xmedia_type.h"
#include "sample_comm.h"
#include "xmedia_audio_ai.h"
#include "xmedia_audio_ao.h"
#include "xmedia_audio_adec.h"
#include "xmedia_audio_aenc.h"
#include "xmedia_audio_vqe.h"
#include "xmedia_audio_codec.h"
#include "xmedia_audio_codec_voice.h"
#include "xmedia_audio_vqe_bcd.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
audio_sample_rate frm_rate;
audio_channel frm_chn;
audio_bit_depth frm_bit;
} sample_ao_frame;
typedef struct {
ai_dev dev;
ai_dev_attr dev_attr;
ai_user_chn_attr chn_attr;
xmedia_bool res_enable;
xmedia_bool vqe_enable;
ai_vqe_attr vqe_attr;
ai_ec_source source;
xmedia_u32 ec_chn_id;
} sample_ai_config;
typedef struct {
ao_dev dev;
ao_dev_attr dev_attr;
xmedia_bool res_enable;
xmedia_bool vqe_enable;
ao_vqe_attr vqe_attr;
xmedia_mod_id binder_src;
sample_ao_frame frame_info;
} sample_ao_config;
typedef struct {
adec_chn chn;
audio_codec_type type;
voice_format format;
xmedia_s32 sample_rate;
} sample_adec_config;
typedef struct {
aenc_chn chn;
audio_sample_rate sample_rate;
audio_channel channels;
audio_bit_depth bit_depth;
voice_format format;
audio_codec_type type;
ai_dev binder_dev;
xmedia_mod_id binder_src;
} sample_aenc_config;
xmedia_s32 sample_comm_audio_init();
xmedia_s32 sample_comm_audio_exit();
xmedia_s32 sample_comm_ai_register(xmedia_u32 mask, ai_vqe_attr_version version, xmedia_bool res_enable);
xmedia_s32 sample_comm_ai_get_default_attr(ai_dev dev, ai_dev_attr* dev_attr);
xmedia_s32 sample_comm_ai_set_share_mode(xmedia_bool enable);
xmedia_s32 sample_comm_ai_start(sample_ai_config* config);
xmedia_s32 sample_comm_ai_stop(sample_ai_config* config);
xmedia_s32 sample_comm_ai_set_codec_volume(ai_dev dev, xmedia_s32 volume);
xmedia_s32 sample_comm_ai_set_volume(sample_ai_config* config, xmedia_s32 volume);
xmedia_s32 sample_comm_ai_get_volume(sample_ai_config* config, xmedia_s32* volume);
xmedia_s32 sample_comm_ai_set_ec_source(sample_ai_config* config);
xmedia_s32 sample_comm_ai_enable_org_frame(sample_ai_config* config, xmedia_bool enable);
xmedia_s32 sample_comm_ai_enable_ec_frame(sample_ai_config* config, xmedia_bool enable);
xmedia_s32 sample_comm_ai_set_dev_param(sample_ai_config* config, ai_dev_param_cmd cmd, xmedia_void* param);
xmedia_s32 sample_comm_ai_set_trackmode(sample_ai_config* config, audio_track_mode trackmode);
xmedia_s32 sample_comm_ai_get_trackmode(sample_ai_config* config, audio_track_mode* trackmode);
xmedia_s32 sample_comm_ai_create_output_thread_to_aenc(sample_ai_config* config);
xmedia_s32 sample_comm_ai_destroy_output_thread_to_aenc(sample_ai_config* config);
xmedia_s32 sample_comm_ai_create_output_thread_to_ao(sample_ai_config* config, ao_dev dev, ao_chn chn);
xmedia_s32 sample_comm_ai_destroy_output_thread_to_ao(sample_ai_config* config);
xmedia_s32 sample_comm_ai_create_output_thread_to_file(sample_ai_config* config, FILE** output_file);
xmedia_s32 sample_comm_ai_destroy_output_thread_to_file(sample_ai_config* config);
xmedia_s32 sample_comm_detect_open(ai_dev dev, ai_vqe_attr* vqe_attr);
xmedia_s32 sample_comm_ao_register(xmedia_u32 mask, ao_vqe_attr_version version, xmedia_bool res_enable);
xmedia_s32 sample_comm_ao_get_default_attr(ao_dev dev, ao_dev_attr* dev_attr);
xmedia_s32 sample_comm_ao_start(sample_ao_config* config);
xmedia_s32 sample_comm_ao_stop(sample_ao_config* config);
xmedia_s32 sample_comm_ao_set_volume(sample_ao_config* config, xmedia_s32 volume);
xmedia_s32 sample_comm_ao_get_volume(sample_ao_config* config, xmedia_s32* volume);
xmedia_s32 sample_comm_ao_set_dev_param(sample_ao_config* config, ao_dev_param_cmd cmd, xmedia_void* param);
xmedia_s32 sample_comm_ao_create_input_thread_from_file(sample_ao_config* config, FILE** input_file);
xmedia_s32 sample_comm_ao_destroy_input_thread_from_file(sample_ao_config* config);
xmedia_s32 sample_comm_adec_register(audio_codec_type type);
xmedia_s32 sample_comm_adec_unregister(audio_codec_type type);
xmedia_s32 sample_comm_adec_start(sample_adec_config* config);
xmedia_s32 sample_comm_adec_stop(sample_adec_config* config);
xmedia_s32 sample_comm_adec_create_input_thread_from_file(sample_adec_config* config, FILE** input_file);
xmedia_s32 sample_comm_adec_destroy_input_thread_from_file(sample_adec_config* config);
xmedia_s32 sample_comm_adec_create_output_thread_to_ao(sample_adec_config* config, ao_dev dev, ao_chn chn);
xmedia_s32 sample_comm_adec_destroy_output_thread_to_ao(sample_adec_config* config);
xmedia_s32 sample_comm_adec_create_output_thread_to_file(sample_adec_config* config, FILE** output_file);
xmedia_s32 sample_comm_adec_destroy_output_thread_to_file(sample_adec_config* config);
xmedia_s32 sample_comm_aenc_register(audio_codec_type type);
xmedia_s32 sample_comm_aenc_unregister(audio_codec_type type);
xmedia_s32 sample_comm_aenc_start(sample_aenc_config* config);
xmedia_s32 sample_comm_aenc_stop(sample_aenc_config* config);
xmedia_s32 sample_comm_aenc_create_input_thread_from_file(sample_aenc_config* config, FILE** input_file);
xmedia_s32 sample_comm_aenc_destroy_input_thread_from_file(sample_aenc_config* config);
xmedia_s32 sample_comm_aenc_create_output_thread_to_file(sample_aenc_config* config, FILE** output_file);
xmedia_s32 sample_comm_aenc_destroy_output_thread_to_file(sample_aenc_config* config);
xmedia_s32 sample_comm_get_codec_info(xmedia_char* file_name, audio_codec_type* type, voice_format* format);
#ifdef __cplusplus
}
#endif
#endif
sample/common/sample_comm_ircut.c
Executable
+198
View File
@@ -0,0 +1,198 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/mman.h>
#include "sample_comm_ircut.h"
static xmedia_s32 g_mem_dev = 0;
static xmedia_s32 sample_comm_ircut_memopen(xmedia_void)
{
if (g_mem_dev <= 0) {
g_mem_dev = open ("/dev/mem", O_CREAT | O_RDWR | O_SYNC);
if (g_mem_dev <= 0) {
return XMEDIA_FAILURE;
}
}
return XMEDIA_SUCCESS;
}
static xmedia_void sample_comm_ircut_memclose(xmedia_void)
{
if (g_mem_dev > 0) {
close(g_mem_dev);
g_mem_dev = 0;
}
}
static xmedia_void* sample_comm_ircut_memmap(xmedia_u32 phy_addr, xmedia_u32 size)
{
xmedia_u32 diff;
xmedia_u32 page_phy;
xmedia_u32 page_size;
xmedia_u8* page_addr;
page_phy = phy_addr & 0xfffff000;
diff = phy_addr - page_phy;
page_size = ((size + diff - 1) & 0xfffff000) + 0x1000;
page_addr = mmap((void *)0, page_size, PROT_READ|PROT_WRITE, MAP_SHARED, g_mem_dev, page_phy);
if (MAP_FAILED == page_addr) {
perror("mmap error\n");
return NULL;
}
return (xmedia_void *) (page_addr + diff);
}
static xmedia_s32 sample_comm_ircut_memunmap(xmedia_void* vir_addr, xmedia_u32 size)
{
xmedia_u32 page_addr;
xmedia_u32 page_size;
xmedia_u32 diff;
page_addr = (((xmedia_u32)vir_addr) & 0xfffff000);
diff = (xmedia_u32)vir_addr - page_addr;
page_size = ((size + diff - 1) & 0xfffff000) + 0x1000;
return munmap((xmedia_void*)page_addr, page_size);
}
static xmedia_void sample_comm_ircut_set_reg(xmedia_u32 addr,xmedia_u32 value)
{
xmedia_u32 *port_vir_addr;
port_vir_addr = sample_comm_ircut_memmap(addr,sizeof(value));
*port_vir_addr = value;
sample_comm_ircut_memunmap(port_vir_addr,sizeof(value));
}
xmedia_s32 sample_comm_ircut_set_status_ir(sample_comm_board_type board_type, xmedia_s32 vi_dev)
{
xmedia_s32 ret = 0;
if (vi_dev >= VI_MAX_DEV_NUM || board_type >= BOARD_TYPE_MAX) {
return XMEDIA_FAILURE;
}
ret = sample_comm_ircut_memopen();
if (ret != XMEDIA_SUCCESS) {
return ret;
}
switch (board_type) {
case BOARD_TYPE_XM7206_V10_RB:{
//pin_mux-- GPIO4_6,GPIO4_3
sample_comm_ircut_set_reg(0x100C0024,0x05); // mutex
sample_comm_ircut_set_reg(0x100C0018,0x05); // mutex
sample_comm_ircut_set_reg(0x120B4400,0x48); // dir
sample_comm_ircut_set_reg(0x120B4120,0x40); // data
break;
}
case BOARD_TYPE_XM7206_V10B_RBA:{
//pin_mux-- GPIO3_5, GPIO3_6
sample_comm_ircut_set_reg(0x100C0000,0x00); // mutex
sample_comm_ircut_set_reg(0x100C0004,0x00); // mutex
sample_comm_ircut_set_reg(0x120B3400,0x60); // dir
sample_comm_ircut_set_reg(0x120B3180,0x20); // data
break;
}
case BOARD_TYPE_XM7206_V10B_EVB:{
//pin_mux-- GPIO5_4, GPIO5_5
sample_comm_ircut_set_reg(0x100C003C,0x00); // mutex
sample_comm_ircut_set_reg(0x100C0040,0x00); // mutex
sample_comm_ircut_set_reg(0x120B5400,0x30); // dir
sample_comm_ircut_set_reg(0x120B50C0,0x10); // data
break;
}
case BOARD_TYPE_XM7206_V11A_RBA:{
//pin_mux-- GPIO7_5, GPIO7_6
sample_comm_ircut_set_reg(0x100C0080,0x00); // mutex
sample_comm_ircut_set_reg(0x100C0084,0x00); // mutex
sample_comm_ircut_set_reg(0x120B7400,0x60); // dir
sample_comm_ircut_set_reg(0x120B7180,0x20); // data
break;
}
case BOARD_TYPE_XM7206_V11A_EVB:{
//pin_mux-- GPIO6_5, GPIO6_6
sample_comm_ircut_set_reg(0x100C0060,0x10); // mutex
sample_comm_ircut_set_reg(0x100C0064,0x10); // mutex
sample_comm_ircut_set_reg(0x120B6400,0x60); // dir
sample_comm_ircut_set_reg(0x120B6180,0x20); // data
break;
}
default:
break;
}
sample_comm_ircut_memclose();
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_ircut_set_status_normal(sample_comm_board_type board_type, xmedia_s32 vi_dev)
{
xmedia_s32 ret = 0;
if (vi_dev >= VI_MAX_DEV_NUM || board_type >= BOARD_TYPE_MAX) {
return XMEDIA_FAILURE;
}
ret = sample_comm_ircut_memopen();
if (ret != XMEDIA_SUCCESS) {
return ret;
}
switch (board_type) {
case BOARD_TYPE_XM7206_V10_RB:{
//pin_mux-- GPIO4_6,GPIO4_3
sample_comm_ircut_set_reg(0x100C0024,0x05); // mutex
sample_comm_ircut_set_reg(0x100C0018,0x05); // mutex
sample_comm_ircut_set_reg(0x120B4400,0x48); // dir
sample_comm_ircut_set_reg(0x120B4120,0x08); // data
break;
}
case BOARD_TYPE_XM7206_V10B_RBA:{
//pin_mux-- GPIO3_5, GPIO3_6
sample_comm_ircut_set_reg(0x100C0000,0x00); // mutex
sample_comm_ircut_set_reg(0x100C0004,0x00); // mutex
sample_comm_ircut_set_reg(0x120B3400,0x60); // dir
sample_comm_ircut_set_reg(0x120B3180,0x40); // data
break;
}
case BOARD_TYPE_XM7206_V10B_EVB:{
//pin_mux-- GPIO5_4, GPIO5_5
sample_comm_ircut_set_reg(0x100C003C,0x00); // mutex
sample_comm_ircut_set_reg(0x100C0040,0x00); // mutex
sample_comm_ircut_set_reg(0x120B5400,0x30); // dir
sample_comm_ircut_set_reg(0x120B50C0,0x20); // data
break;
}
case BOARD_TYPE_XM7206_V11A_RBA:{
//pin_mux-- GPIO7_5, GPIO7_6
sample_comm_ircut_set_reg(0x100C0080,0x00); // mutex
sample_comm_ircut_set_reg(0x100C0084,0x00); // mutex
sample_comm_ircut_set_reg(0x120B7400,0x60); // dir
sample_comm_ircut_set_reg(0x120B7180,0x40); // data
break;
}
case BOARD_TYPE_XM7206_V11A_EVB:{
//pin_mux-- GPIO6_5, GPIO6_6
sample_comm_ircut_set_reg(0x100C0060,0x10); // mutex
sample_comm_ircut_set_reg(0x100C0064,0x10); // mutex
sample_comm_ircut_set_reg(0x120B6400,0x60); // dir
sample_comm_ircut_set_reg(0x120B6180,0x40); // data
break;
}
default:
break;
}
sample_comm_ircut_memclose();
return XMEDIA_SUCCESS;
}
sample/common/sample_comm_ircut.h
Executable
+39
View File
@@ -0,0 +1,39 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_IRCUT_H__
#define __SAMPLE_COMM_IRCUT_H__
#include <pthread.h>
#include "common.h"
#include "defines.h"
#include "xmedia_sys.h"
#include "xmedia_type.h"
#include "xmedia_mmz.h"
#include "sample_comm.h"
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif
xmedia_s32 sample_comm_ircut_set_status_normal(sample_comm_board_type board_type, xmedia_s32 vi_dev);
xmedia_s32 sample_comm_ircut_set_status_ir(sample_comm_board_type board_type, xmedia_s32 vi_dev);
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif
#endif
sample/common/sample_comm_isp.c
Executable
+1459
View File
File diff suppressed because it is too large Load Diff
sample/common/sample_comm_isp.h
Executable
+94
View File
@@ -0,0 +1,94 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_ISP_H__
#define __SAMPLE_COMM_ISP_H__
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "xmedia_sys.h"
#include "xmedia_type.h"
#include "xmedia_isp.h"
#include "xmedia_ae.h"
#include "xmedia_awb.h"
#include "sample_comm_vi.h"
#ifdef __cplusplus
extern "C" {
#endif
#define ISP_MAX_PIPE_NUM VI_MAX_PIPE_NUM
typedef struct {
xmedia_bool isp_sensor_en;
xmedia_bool isp_pipe_en;
xmedia_bool i2c_addr_en;
xmedia_u32 i2c_addr;
sample_comm_sensor_type sensor_type;
xmedia_u32 sns_clk_ch;
xmedia_u32 sns_rst_ch;
xmedia_sensor_trig_signal signal;
xmedia_sensor_config sns_cfg;
xmedia_sensor_work_mode sns_work_mode;
xmedia_isp_config isp_config;
xmedia_bool mirror;
xmedia_bool flip;
xmedia_bool serdes_enable;
xmedia_bool disable_dynamic_fps;
} sample_isp_info;
typedef struct {
xmedia_s32 pipe[ISP_MAX_PIPE_NUM]; /*vi master pipe number*/
sample_isp_info isp_info[ISP_MAX_PIPE_NUM];
xmedia_char *ainr_model_path[ISP_MAX_PIPE_NUM];
} sample_isp_param;
// for load ainr model and pqbin
#define AINR_LIST_NUM (16)
typedef struct {
sample_comm_sensor_type sensor_type;
xmedia_char *load_file;
} sample_isp_sensor_effect_list;
extern sample_isp_sensor_effect_list g_ainr_pqbin_list[AINR_LIST_NUM];
extern sample_isp_sensor_effect_list g_ainr_model_list[AINR_LIST_NUM];
xmedia_s32 sample_comm_isp_init(sample_isp_param *isp_param, sample_vi_config *vi_config);
xmedia_s32 sample_comm_isp_exit(sample_isp_param *isp_param);
xmedia_s32 sample_comm_isp_start(sample_isp_param *isp_param);
xmedia_s32 sample_comm_isp_stop(sample_isp_param *isp_param);
xmedia_s32 sample_comm_isp_get_sensor_bayer_fmt(xmedia_u32 pipe, xmedia_video_size size, xmedia_video_wdr_mode wdr_mode,
xmedia_bool mirror, xmedia_bool flip,
xmedia_video_bayer_format *bayer_fmt);
xmedia_s32 sample_comm_isp_get_sensor_bit_rate(xmedia_u32 pipe, xmedia_u32 *bit_rate);
xmedia_void sample_comm_isp_set_multi_pipe_mode(xmedia_bool multi_pipe_mode,
xmedia_s32 master_pipe_id, xmedia_s32 slave_pipe_id);
xmedia_bool sample_comm_isp_is_wdr_mode(sample_comm_sensor_type sensor_type);
xmedia_s32 sample_comm_isp_ainr_init(sample_isp_param *isp_param, sample_vi_config *vi_config);
xmedia_void sample_comm_isp_ainr_exit(sample_isp_param *isp_param);
xmedia_s32 sample_comm_isp_enable_fpn(xmedia_u32 isp_pipe, const xmedia_char *fpn_path);
xmedia_s32 sample_comm_isp_disable_fpn(xmedia_u32 isp_pipe);
xmedia_s32 sample_comm_isp_get_sensor_effect_index(sample_isp_sensor_effect_list list[], xmedia_s32 list_num,
sample_comm_sensor_type sensor_type);
xmedia_s32 sample_comm_isp_sensor_reset(xmedia_s32 sns_id);
#ifdef __cplusplus
}
#endif
#endif /*__SAMPLE_COMM_ISP_H__*/
sample/common/sample_comm_livestream.c
Executable
+150
View File
@@ -0,0 +1,150 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <arpa/inet.h>
#include "sample_comm_livestream.h"
#include "sample_comm_venc.h"
#define APP_LISTEN_PORT 554
#define APP_MAX_CONN_NUM 4
#define APP_PATTERN_NAME "livestream"
static xmedia_char g_stream_name[4][8] = {"0", "1", "2", "3"};
static xmedia_u8 g_stream_cnt = 0;
static xmedia_char server_ip_addr[20];
static int app_liveserver_get_ip(const char *adapter_name, char *addr)
{
struct ifreq ifr;
const char *ifname = adapter_name;
int skfd;
struct sockaddr_in *ipad;
skfd = socket(AF_INET, SOCK_DGRAM, 0);
if(skfd < 0)
{
printf("socket create error\n");
return -1;
}
memset(&ifr, 0, sizeof(struct ifreq));
strcpy(ifr.ifr_name, ifname);
ifr.ifr_addr.sa_family = AF_INET;
if (ioctl(skfd, SIOCGIFADDR, &ifr) == 0)
{
ipad = (struct sockaddr_in *)&ifr.ifr_addr;
strcpy(addr,inet_ntoa(ipad->sin_addr));
}
else
{
close(skfd);
//printf("error!!:%s,device:%s\n",strerror(errno),adapter_name);
return -1;
}
close(skfd);
return 0;
}
xmedia_s32 app_liveserver_init(xmedia_void)
{
xcam_liveserver_init_param init_param;
(xmedia_void)xcam_log_init();
memset(server_ip_addr, 0, sizeof(server_ip_addr));
if(app_liveserver_get_ip("eth0", server_ip_addr) != 0) {
printf("rtsp get host ip fail\n");
return XMEDIA_FAILURE;
}
memset(&init_param, 0, sizeof(init_param));
init_param.listen_port = APP_LISTEN_PORT;
init_param.max_conn_num = APP_MAX_CONN_NUM;
strncpy(init_param.pattern_name, APP_PATTERN_NAME, 16);
xcam_s32 ret = xcam_liveserver_init(init_param);
if (ret != XMEDIA_SUCCESS) {
printf("liveserver init error, ret=%#x \n", ret);
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
xmedia_void app_liveserver_deinit(xmedia_void)
{
xcam_liveserver_deinit();
xcam_log_deinit();
}
xmedia_s32 app_liveserver_get_video_src_info(int index, xcam_track_video_source_info *video_src_info,
xmedia_video_size *chn_size,xmedia_u32 frame_rate)
{
video_src_info->codec_type = XCAM_TRACK_VIDEO_CODEC_H265;
video_src_info->width = chn_size[index].width;
video_src_info->height = chn_size[index].height;
video_src_info->speed = 1;
video_src_info->frame_rate = frame_rate;
video_src_info->gop = frame_rate * 2;
video_src_info->bit_rate = 20 * 1024 * 1024;
return XMEDIA_SUCCESS;
}
xmedia_s32 app_liveserver_video_chn_request_key_frame(xcam_handle venc_handle, xmedia_void* param)
{
xmedia_s32 venc_chn;
xmedia_s32 ret;
venc_chn = (xmedia_s32)venc_handle;
ret = xmedia_venc_request_idr(venc_chn, XMEDIA_TRUE);
if (XMEDIA_SUCCESS != ret) {
printf("xmedia_venc_request_idr(chn:%d) faild with%#x!\n", venc_chn, ret);
return XMEDIA_FAILURE;
} else {
printf("xmedia_venc_request_idr(chn:%d) successful!\n", venc_chn);
}
return ret;
}
xmedia_s32 app_liveserver_start(xmedia_video_size *chn_size,xmedia_u32 chn_cnt,xmedia_u32 frame_rate)
{
g_stream_cnt = chn_cnt;
for (int i = 0; i < chn_cnt; i++) {
xcam_track_video_source_info track_video;
app_liveserver_get_video_src_info(i, &track_video,chn_size,frame_rate);
int ret = xcam_liveserver_add_stream(i, &track_video,
-1, 0, (const xcam_char *)g_stream_name[i], app_liveserver_video_chn_request_key_frame);
if (ret != XMEDIA_SUCCESS) {
printf("liveserver add stream venc_handle[%u] failed! \n\n",i);
return -1;
}
printf("\nrtsp://%s:%d/%s/%d",server_ip_addr, APP_LISTEN_PORT,APP_PATTERN_NAME,i);
}
printf("\n");
return XMEDIA_SUCCESS;
}
xmedia_s32 app_liveserver_stop(xmedia_void)
{
for (int i = 0; i < g_stream_cnt; i++) {
int ret = xcam_liveserver_remove_stream((const xcam_char *)g_stream_name[i]);
if (ret != XMEDIA_SUCCESS) {
printf("liveserver remove stream venc_handle[%u] failed! \n\n",i);
return -1;
}
}
return XMEDIA_SUCCESS;
}
sample/common/sample_comm_livestream.h
Executable
+40
View File
@@ -0,0 +1,40 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_LIVESTREAM_H__
#define __SAMPLE_COMM_LIVESTREAM_H__
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif
#include "sample_comm.h"
#include "sample_comm_sys.h"
#include "xcam_log.h"
#include "xcam_livestream_rtsp_server.h"
#include "xcam_liveserver.h"
xmedia_s32 app_liveserver_init(xmedia_void);
xmedia_void app_liveserver_deinit(xmedia_void);
xmedia_s32 app_liveserver_get_video_src_info(int index, xcam_track_video_source_info *video_src_info,
xmedia_video_size *chn_size, xmedia_u32 frame_rate);
xmedia_s32 app_liveserver_video_chn_request_key_frame(xcam_handle venc_handle, xmedia_void* param);
xmedia_s32 app_liveserver_start(xmedia_video_size *chn_size,xmedia_u32 chn_cnt,xmedia_u32 frame_rate);
xmedia_s32 app_liveserver_stop(xmedia_void);
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif
#endif
sample/common/sample_comm_periph.c
Executable
+392
View File
@@ -0,0 +1,392 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <unistd.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/mman.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <sys/select.h>
#include <sys/socket.h>
#include "sample_comm.h"
#include "sample_comm_periph.h"
#include "xmedia_sys.h"
// 最大设备名长度
#define MAX_DEVICE_NAME_LENGTH 256
#define MAX_NL_BUF_SIZE (1024 * 16)
#define MAX_SELECT_TIMEOUT (2 * 1000 * 1000)
// 查找设备的分区（返回分区号，如 p1）
static xmedia_s32 sdcard_find_partition(const xmedia_char *device_name, xmedia_char *partition)
{
DIR *dir;
struct dirent *entry;
xmedia_char path[MAX_DEVICE_NAME_LENGTH + 32] = {0};
xmedia_s32 found = 0;
snprintf(path, sizeof(path), "/sys/block/%s", device_name);
dir = opendir(path);
if (!dir) {
return XMEDIA_FAILURE;
}
while ((entry = readdir(dir)) != NULL) {
if (strncmp(entry->d_name, device_name, strlen(device_name)) == 0 &&
strstr(entry->d_name, "p") != NULL) {
strncpy(partition, entry->d_name, MAX_DEVICE_NAME_LENGTH);
found = 1;
break;
}
}
closedir(dir);
return found ? XMEDIA_SUCCESS : XMEDIA_FAILURE;
}
// 挂载设备
static xmedia_s32 mount_device(const xmedia_char *mount_point, const xmedia_char *device_path)
{
const xmedia_char *fstypes[] = {"vfat", "ext4", "ntfs", "auto", NULL};
// 创建挂载点目录（若不存在）
if (mkdir(mount_point, 0755) && errno != EEXIST) {
SAMPLE_ERR("mkdir failed: %s\n", strerror(errno));
return XMEDIA_FAILURE;
}
// 尝试挂载常见文件系统类型（按优先级）
for (xmedia_s32 i = 0; fstypes[i]; i++) {
if (mount(device_path, mount_point, fstypes[i], MS_NOATIME, NULL) == 0) {
SAMPLE_PRT("Mounted %s (%s) to %s\n", device_path, fstypes[i], mount_point);
return XMEDIA_SUCCESS;
}
}
// 所有类型尝试失败
SAMPLE_ERR("Failed to mount %s: %s\n", device_path, strerror(errno));
return XMEDIA_FAILURE;
}
static xmedia_bool device_driver_is_bind(const xmedia_char *device, const xmedia_char *driver)
{
xmedia_char path[256] = {'\0'};
snprintf(path, 256, "%s/%s", driver, device);
return (access(path, F_OK) == 0);
}
static xmedia_s32 device_attach_driver(const xmedia_char *device, const xmedia_char *driver)
{
xmedia_s32 s32Ret = XMEDIA_FAILURE;
xmedia_char path[256] = {'\0'};
xmedia_s32 fd = -1;
snprintf(path, sizeof(path), "%s/bind", driver);
fd = open(path, O_WRONLY | O_NONBLOCK | O_CLOEXEC);
if (fd < 0) {
SAMPLE_ERR("[%s()] can't open %s because %s\n", __func__, driver, strerror(errno));
return XMEDIA_FAILURE;
}
//MEDIA_PRT("[%s()] start bind %s to %s\n", __func__, device, driver);
s32Ret = write(fd, device, strlen(device));
if (s32Ret < 0) {
SAMPLE_ERR("[%s()] bind %s to %s failed because %s\n", __func__, device, driver,strerror(errno));
close(fd);
return XMEDIA_FAILURE;
}
close(fd);
return XMEDIA_SUCCESS;
}
static xmedia_s32 device_detach_driver(const xmedia_char *device, const xmedia_char *driver)
{
xmedia_s32 s32Ret = XMEDIA_FAILURE;
xmedia_char path[256] = {'\0'};
xmedia_s32 fd = -1;
snprintf(path, sizeof(path), "%s/unbind", driver);
fd = open(path, O_WRONLY | O_NONBLOCK | O_CLOEXEC);
if (fd < 0) {
SAMPLE_ERR("[%s()] can't open %s because %s\n", __func__, path, strerror(errno));
return XMEDIA_FAILURE;
}
//MEDIA_PRT("[%s()] start unbind %s from %s\n", __func__, device, driver);
s32Ret = write(fd, device, strlen(device));
if (s32Ret < 0) {
SAMPLE_ERR("[%s()] unbind %s from %s failed because %s\n", __func__, device, driver, strerror(errno));
close(fd);
return XMEDIA_FAILURE;
}
close(fd);
return XMEDIA_SUCCESS;
}
static xmedia_bool device_action_check(const xmedia_char *device, const xmedia_char *notice_str, xmedia_char *buf)
{
xmedia_char *action = XMEDIA_NULL;
xmedia_char *subsystem = XMEDIA_NULL;
xmedia_char *devtype = XMEDIA_NULL;
xmedia_char *field = buf;
if (strstr(device, "sdhci") != XMEDIA_NULL) {
if (strcmp(notice_str, "add") == 0) {
while (*field != '\0' && field < buf + MAX_NL_BUF_SIZE) {
if (strstr(field, "ACTION=")) {
action = field + strlen("ACTION=");
} else if (strstr(field, "SUBSYSTEM=")) {
subsystem = field + strlen("SUBSYSTEM=");
} else if (strstr(field, "DEVTYPE=")) {
devtype = field + strlen("DEVTYPE=");
}
while (*field != '\0') field++;
field++;
}
if (subsystem && strcmp(subsystem, "block") == 0 && devtype && strcmp(devtype, "disk") == 0) {
if (strcmp(action, notice_str) == 0) {
//SAMPLE_ERR("notice_str :%s success\n", notice_str);
return XMEDIA_TRUE;
}
}
} else if (strcmp(notice_str, "remove") == 0) {
while (*field != '\0' && field < buf + MAX_NL_BUF_SIZE) {
if (strstr(field, "ACTION=")) {
action = field + strlen("ACTION=");
} else if (strstr(field, "SUBSYSTEM=")) {
subsystem = field + strlen("SUBSYSTEM=");
}
while (*field != '\0') field++;
field++;
}
if (subsystem && strcmp(subsystem, "mmc_host") == 0) {
if (strcmp(action, notice_str) == 0) {
//SAMPLE_ERR("notice_str :%s success\n", notice_str);
return XMEDIA_TRUE;
}
}
}
}
return XMEDIA_FALSE;
}
xmedia_s32 sample_comm_periph_mount_sdcard(const xmedia_char* mount_path, xmedia_s32 timeout_ms)
{
DIR *block_dir;
struct dirent *entry;
xmedia_u64 start_time = 0;
xmedia_u64 end_time = 0;
xmedia_char partition[MAX_DEVICE_NAME_LENGTH] = {0};
xmedia_char device_path[MAX_DEVICE_NAME_LENGTH + 32] = {0};
xmedia_sys_get_cur_pts(&start_time);
LOOP_AGAIN:
block_dir = opendir("/sys/block");
if (!block_dir) {
SAMPLE_ERR("Failed to open /sys/block: %s\n", strerror(errno));
return XMEDIA_FAILURE;
}
while ((entry = readdir(block_dir)) != NULL) {
// 只处理 mmcblk 设备
if (strncmp(entry->d_name, "mmcblk", 6) != 0) {
continue;
}
// 查找分区
if (sdcard_find_partition(entry->d_name, partition) == 0) {
// 挂载分区（如 /dev/mmcblk0p1）
snprintf(device_path, sizeof(device_path), "/dev/%s", partition);
if (mount_device(mount_path, device_path) == XMEDIA_SUCCESS) {
closedir(block_dir);
return XMEDIA_SUCCESS;
}
} else {
// 无分区，挂载整个设备（如 /dev/mmcblk1）
snprintf(device_path, sizeof(device_path), "/dev/%s", entry->d_name);
if (mount_device(mount_path, device_path) == XMEDIA_SUCCESS) {
closedir(block_dir);
return XMEDIA_SUCCESS;
}
}
}
closedir(block_dir);
xmedia_sys_get_cur_pts(&end_time);
if(end_time - start_time < timeout_ms * 1000) {
usleep(50 * 1000);
SAMPLE_PRT("No SD card found, find again\n");
goto LOOP_AGAIN;
}
SAMPLE_ERR("No SD card found.\n");
return XMEDIA_FAILURE;
}
xmedia_s32 sample_comm_periph_umount_sdcard(const xmedia_char *mount_path)
{
const xmedia_s32 max_retries = 30;
xmedia_s32 retry_count = 0;
while (retry_count < max_retries) {
if (umount(mount_path) == 0) {
return XMEDIA_SUCCESS;
}
// 错误处理
switch (errno) {
case EBUSY:
SAMPLE_ERR("ERROR: %s is busy (retry %d/%d)\n",
mount_path, retry_count + 1, max_retries);
break;
case EINVAL:
SAMPLE_ERR("Error: %s not mounted or invalid path\n", mount_path);
return XMEDIA_FAILURE;
case EPERM:
SAMPLE_ERR("Error: Requires root privileges\n");
return XMEDIA_FAILURE;
default:
SAMPLE_ERR("Unmount failed: %s\n", strerror(errno));
return XMEDIA_FAILURE;
}
retry_count++;
usleep(10 * 1000);
}
SAMPLE_ERR("Error: Failed to unmount %s after %d attempts\n", mount_path, max_retries);
return XMEDIA_FAILURE;
}
xmedia_s32 sample_comm_periph_drv_bind(const xmedia_char *device, const xmedia_char *driver, const xmedia_char *notice_str)
{
xmedia_s32 s32Ret = 0;
xmedia_s32 fd = -1;
xmedia_char buf[MAX_NL_BUF_SIZE] = {'\0'};
fd_set read_set;
struct timeval timeout;
struct sockaddr_nl addr;
if (device_driver_is_bind(device, driver)) {
SAMPLE_ERR("[%s()] sdcard device already bind!\n", __func__);
return XMEDIA_SUCCESS;
}
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
addr.nl_groups = 1;
addr.nl_pid = 0;
fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_KOBJECT_UEVENT);
if (fd < 0) {
SAMPLE_ERR("[%s()] Failed to open sdcard netlink because %s\n", __func__, strerror(errno));
return XMEDIA_FAILURE;
} else if (bind(fd, (struct sockaddr *)(&addr), sizeof(addr)) != 0) {
SAMPLE_ERR("[%s()] bind sdcard netlink addr failed because %s\n", __func__, strerror(errno));
goto FAILED;
}
FD_ZERO(&read_set);
FD_SET(fd, &read_set);
timeout.tv_sec = 0;
timeout.tv_usec = MAX_SELECT_TIMEOUT;
// bind sdcard
if (device_attach_driver(device, driver) != XMEDIA_SUCCESS) {
goto FAILED;
}
// wait for bind success
RETRY:
s32Ret = select(fd + 1, &read_set, NULL, NULL, &timeout);
if (s32Ret > 0) {
memset(&buf, 0, sizeof(buf));
read(fd, buf, sizeof(buf));
buf[MAX_NL_BUF_SIZE - 1] = '\0';
if (device_action_check(device, notice_str, buf) == XMEDIA_TRUE) {
goto SUCCESS;
}
goto RETRY; // drop all message
} else {
SAMPLE_ERR("[%s()] select error %s\n", __func__, strerror(errno));
goto FAILED;
}
SUCCESS:
close(fd);
return XMEDIA_SUCCESS;
FAILED:
close(fd);
return XMEDIA_FAILURE;
}
xmedia_s32 sample_comm_periph_drv_unbind(const xmedia_char *device, const xmedia_char *driver, const xmedia_char *notice_str)
{
xmedia_s32 s32Ret = 0;
xmedia_s32 fd = -1;
xmedia_char buf[MAX_NL_BUF_SIZE] = {'\0'};
fd_set read_set;
struct timeval timeout;
struct sockaddr_nl addr;
if (!device_driver_is_bind(device, driver)) {
SAMPLE_ERR("[%s()] sdcard device already unbind!\n", __func__);
return XMEDIA_SUCCESS;
}
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
addr.nl_groups = 1;
addr.nl_pid = 0;
fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_KOBJECT_UEVENT);
if (fd < 0) {
SAMPLE_ERR("[%s()] Failed to open sdcard netlink because %s\n", __func__, strerror(errno));
return XMEDIA_FAILURE;
} else if (bind(fd, (struct sockaddr *)(&addr), sizeof(addr)) != 0) {
SAMPLE_ERR("[%s()] bind sdcard netlink addr failed because %s\n", __func__, strerror(errno));
goto FAILED;
}
memset(&buf, 0, sizeof(buf));
FD_ZERO(&read_set);
FD_SET(fd, &read_set);
timeout.tv_sec = 0;
timeout.tv_usec = MAX_SELECT_TIMEOUT;
// unbind sdcard
if (device_detach_driver(device, driver) != XMEDIA_SUCCESS)
goto FAILED;
// wait for unbind success
RETRY:
s32Ret = select(fd + 1, &read_set, NULL, NULL, &timeout);
if (s32Ret > 0) {
memset(&buf, 0, sizeof(buf));
read(fd, buf, sizeof(buf));
buf[MAX_NL_BUF_SIZE - 1] = '\0';
if (device_action_check(device, notice_str, buf) == XMEDIA_TRUE) {
goto SUCCESS;
}
goto RETRY; // drop all message
} else {
SAMPLE_ERR("[%s()] select error %s\n", __func__, strerror(errno));
goto FAILED;
}
SUCCESS:
close(fd);
return XMEDIA_SUCCESS;
FAILED:
close(fd);
return XMEDIA_FAILURE;
}
sample/common/sample_comm_periph.h
Executable
+12
View File
@@ -0,0 +1,12 @@
#ifndef __SAMPLE_COMM_PERIPHERAL_H__
#define __SAMPLE_COMM_PERIPHERAL_H__
#include "xmedia_type.h"
xmedia_s32 sample_comm_periph_mount_sdcard(const xmedia_char* mount_point, xmedia_s32 timeout_ms);
xmedia_s32 sample_comm_periph_umount_sdcard(const xmedia_char *mount_path);
xmedia_s32 sample_comm_periph_drv_bind(const xmedia_char *device, const xmedia_char *driver, const xmedia_char *notice_str);
xmedia_s32 sample_comm_periph_drv_unbind(const xmedia_char *device, const xmedia_char *driver, const xmedia_char *notice_str);
#endif /*__SAMPLE_COMM_PERIPHERAL_H__*/
sample/common/sample_comm_pq_bin.c
Executable
+557
View File
@@ -0,0 +1,557 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dlfcn.h>
#include "xmedia_sys.h"
#include "xmedia_isp.h"
#include "xmedia_vi.h"
#include "sample_comm.h"
#include "sample_comm_pq_bin.h"
xmedia_u32 g_isp_len = 0;
xmedia_u32 g_isp_ex_len = 0;
/**************************** isp bin data content ***************************
*
* magic_isp : 16byte
* pipe : sizeof(xmedia_s32)
* isp_data : sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM +
* xmedia_isp_module_info.length[i] * ISP_MODULE_ISP_EX_NUM
*
*****************************************************************************/
xmedia_u32 get_isp_export_len(xmedia_void)
{
return g_isp_len;
}
/**************************** isp_ex bin data content ***************************
*
* magic_isp : 16byte
* pipe : sizeof(xmedia_s32)
* isp_data : sizeof(xmedia_isp_module_info) + xmedia_isp_module_info.length[ISP_EX]
*
*****************************************************************************/
xmedia_u32 get_isp_ex_export_len(xmedia_void)
{
return g_isp_ex_len;
}
xmedia_u32 pq_bin_isp_export(bin_module_info *module, xmedia_isp_module_info *isp_mod_info)
{
xmedia_s32 ret;
isp_mod_info[0].module = XMEDIA_ISP_MODULE_ID_ISP;
isp_mod_info[1].module = XMEDIA_ISP_MODULE_ID_AWB;
isp_mod_info[2].module = XMEDIA_ISP_MODULE_ID_AE;
//isp_mod_info[3].module = XMEDIA_ISP_MODULE_ID_AF;
ret = xmedia_isp_export(module->vi.pipe, isp_mod_info);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_isp_export err(%#x)\n", ret);
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
xmedia_u32 pq_bin_isp_ex_export(bin_module_info *module, xmedia_isp_module_info *isp_mod_info)
{
xmedia_s32 ret;
isp_mod_info[0].module = XMEDIA_ISP_MODULE_ID_ISP_EX;
ret = xmedia_isp_export(module->ex.pipe, isp_mod_info);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_isp_export err(%#x)\n", ret);
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
xmedia_u32 get_isp_data_len(bin_module_info *module)
{
xmedia_s32 ret;
xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };
g_isp_len = MAGIC_DATA_LEN;
g_isp_len += sizeof(xmedia_s32);
g_isp_len += sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM;
ret = pq_bin_isp_export(module, isp_mod_info);
if (ret != XMEDIA_SUCCESS) {
return ret;
}
for (xmedia_s32 i = 0; i < ISP_MODULE_ISP_EX_NUM; i++) {
SAMPLE_PRT("isp[%d].length = %d\n", i, isp_mod_info[i].length);
g_isp_len += isp_mod_info[i].length;
}
return g_isp_len;
}
xmedia_u32 get_isp_ex_data_len(bin_module_info *module)
{
xmedia_s32 ret;
xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };
g_isp_ex_len = MAGIC_DATA_LEN;
g_isp_ex_len += sizeof(xmedia_s32);
g_isp_ex_len += sizeof(xmedia_isp_module_info);
ret = pq_bin_isp_ex_export(module, isp_mod_info);
if (ret != XMEDIA_SUCCESS) {
return ret;
}
for (xmedia_s32 i = 0; i < XMEDIA_ISP_MODULE_MAX_NUM; i++) {
if (isp_mod_info[i].module == XMEDIA_ISP_MODULE_ID_ISP_EX) {
SAMPLE_PRT("isp_ex.length = %d\n", isp_mod_info[i].length);
g_isp_ex_len += isp_mod_info[i].length;
break;
}
}
return g_isp_ex_len;
}
xmedia_u32 get_isp_import_len(xmedia_u8* buffer)
{
xmedia_u32 len;
xmedia_u8 *pos = buffer;
xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };
pos += MAGIC_DATA_LEN;
pos += sizeof(xmedia_s32);
memcpy(&isp_mod_info, pos, sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM);
pos += sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM;
for (xmedia_s32 index = 0; index < ISP_MODULE_ISP_EX_NUM; index++) {
SAMPLE_PRT("isp[%d].length=%d\n", index, isp_mod_info[index].length);
pos += isp_mod_info[index].length;
}
len = pos - buffer;
return len;
}
xmedia_u32 get_isp_ex_import_len(xmedia_u8* buffer)
{
xmedia_u32 len;
xmedia_u8 *pos = buffer;
xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };
pos += MAGIC_DATA_LEN;
pos += sizeof(xmedia_s32);
memcpy(&isp_mod_info, pos, sizeof(xmedia_isp_module_info));
pos += sizeof(xmedia_isp_module_info);
SAMPLE_PRT("isp_ex.length=%d\n", isp_mod_info[0].length);
pos += isp_mod_info[0].length;
len = pos - buffer;
return len;
}
xmedia_s32 pq_bin_export_isp_data(bin_module_info *module, xmedia_u8 *buffer, xmedia_u32 isp_data_len)
{
xmedia_u8 *pos = buffer;
xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };
xmedia_s32 ret;
CHECK_NULL_PTR(module);
CHECK_NULL_PTR(buffer);
memcpy(pos, magic_isp, MAGIC_DATA_LEN);
pos += MAGIC_DATA_LEN;
memcpy(pos, &module->vi.pipe, sizeof(xmedia_s32));
pos += sizeof(xmedia_s32);
ret = pq_bin_isp_export(module, isp_mod_info);
if (ret != XMEDIA_SUCCESS) {
return XMEDIA_FAILURE;
}
memcpy(pos, &isp_mod_info, sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM);
pos += sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM;
for (xmedia_s32 index = 0; index < ISP_MODULE_ISP_EX_NUM; index++) {
memcpy(pos, isp_mod_info[index].addr, isp_mod_info[index].length);
pos += isp_mod_info[index].length;
}
if (isp_data_len != (pos - buffer)) {
SAMPLE_ERR("The exported length does not match the expected length.\n");
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
xmedia_s32 pq_bin_export_isp_ex_data(bin_module_info *module, xmedia_u8 *buffer, xmedia_u32 isp_ex_data_len)
{
xmedia_u8 *pos = buffer;
xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };
xmedia_s32 ret;
CHECK_NULL_PTR(module);
CHECK_NULL_PTR(buffer);
memcpy(pos, magic_isp_ex, MAGIC_DATA_LEN);
pos += MAGIC_DATA_LEN;
memcpy(pos, &module->ex.pipe, sizeof(xmedia_s32));
pos += sizeof(xmedia_s32);
ret = pq_bin_isp_ex_export(module, isp_mod_info);
if (ret != XMEDIA_SUCCESS) {
return XMEDIA_FAILURE;
}
memcpy(pos, &isp_mod_info, sizeof(xmedia_isp_module_info));
pos += sizeof(xmedia_isp_module_info);
for (xmedia_s32 index = 0; index < XMEDIA_ISP_MODULE_MAX_NUM; index++) {
if (isp_mod_info[index].module == XMEDIA_ISP_MODULE_ID_ISP_EX) {
memcpy(pos, isp_mod_info[index].addr, isp_mod_info[index].length);
pos += isp_mod_info[index].length;
break;
}
if (index == XMEDIA_ISP_MODULE_MAX_NUM) {
return XMEDIA_FAILURE;
}
}
if (isp_ex_data_len != (pos - buffer)) {
SAMPLE_ERR("The exported length does not match the expected length.\n");
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
xmedia_s32 pq_bin_import_isp_data(bin_module_info *module, xmedia_u8* buffer)
{
xmedia_s32 ret = XMEDIA_SUCCESS;
xmedia_u8 *pos = buffer;
xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };
pos += MAGIC_DATA_LEN;
pos += sizeof(xmedia_s32);
memcpy(&isp_mod_info, pos, sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM);
pos += sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM;
for (xmedia_s32 index = 0; index < ISP_MODULE_ISP_EX_NUM; index++) {
isp_mod_info[index].addr = pos;
pos += isp_mod_info[index].length;
}
ret = xmedia_isp_import(module->vi.pipe, isp_mod_info);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_isp_import failed.\n");
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
xmedia_s32 pq_bin_import_isp_ex_data(bin_module_info *module, xmedia_u8* buffer)
{
xmedia_s32 ret = XMEDIA_SUCCESS;
xmedia_u8 *pos = buffer;
xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };
pos += MAGIC_DATA_LEN;
pos += sizeof(xmedia_s32);
memcpy(&isp_mod_info, pos, sizeof(xmedia_isp_module_info));
pos += sizeof(xmedia_isp_module_info);
isp_mod_info[0].addr = pos;
pos += isp_mod_info[0].length;
ret = xmedia_isp_import(module->ex.pipe, isp_mod_info);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_isp_import failed.\n");
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
xmedia_s32 pq_bin_data_export(bin_module_info *module, xmedia_u8 *buffer, xmedia_u32 total_len)
{
xmedia_s32 ret;
xmedia_u32 len;
xmedia_s32 result = -1;
xmedia_u8 *pos = buffer;
xmedia_sys_get_tuning_connect(&result);
if (result == 0 || result == -1) {
SAMPLE_ERR("xmedia_sys_get_tuning_connect failed\n");
return XMEDIA_FAILURE;
}
// Export ISP Data
if (module->vi.enable == XMEDIA_TRUE) {
len = get_isp_export_len();
ret = pq_bin_export_isp_data(module, buffer, len);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("pq_bin_export_isp_data failed\n");
return ret;
}
buffer += len;
}
// Export ISP_EX Data
if (module->ex.enable == XMEDIA_TRUE) {
len = get_isp_ex_export_len();
ret = pq_bin_export_isp_ex_data(module, buffer, len);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("pq_bin_export_isp_ex_data failed\n");
return ret;
}
buffer += len;
}
if (total_len != buffer - pos) {
SAMPLE_ERR("The exported length does not match the expected length.\n");
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
xmedia_s32 pq_bin_data_import(bin_module_info *module, xmedia_u8 *buffer, xmedia_u32 total_len)
{
xmedia_s32 ret = XMEDIA_SUCCESS;
xmedia_u32 len;
xmedia_s32 result = -1;
if (buffer == XMEDIA_NULL) {
SAMPLE_ERR("buffer is a null pointer.\n");
return XMEDIA_FAILURE;
}
xmedia_sys_get_tuning_connect(&result);
if (result == 0 || result == -1) {
SAMPLE_ERR("xmedia_sys_get_tuning_connect failed.\n");
return XMEDIA_FAILURE;
}
//isp data
if (total_len > sizeof(magic_isp) && memcmp(&magic_isp, buffer, sizeof(magic_isp)) == 0) {
len = get_isp_import_len(buffer);
total_len -= len;
if (total_len < 0) {
SAMPLE_ERR("pq_bin data is incomplete!\n");
return XMEDIA_FAILURE;
}
if (module->vi.enable == XMEDIA_TRUE) {
SAMPLE_ERR("pq_bin isp data size: %d\n", len);
ret = pq_bin_import_isp_data(module, buffer);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("pq_bin import isp data failed\n");
return ret;
}
SAMPLE_ERR("pq_bin import isp data success\n");
}
buffer += len;
} else if (module->vi.enable == XMEDIA_TRUE) {
SAMPLE_ERR("pq_bin does not cantain data for isp, cannot enable isp.\n");
return XMEDIA_FAILURE;
}
//isp_ex data
if (total_len > sizeof(magic_isp_ex) && memcmp(&magic_isp_ex, buffer, sizeof(magic_isp_ex)) == 0) {
len = get_isp_ex_import_len(buffer);
total_len -= len;
if (total_len < 0) {
SAMPLE_ERR("pq_bin data is incomplete!\n");
return XMEDIA_FAILURE;
}
if (module->ex.enable == XMEDIA_TRUE) {
SAMPLE_ERR("pq_bin isp_ex data size: %d\n", len);
ret = pq_bin_import_isp_ex_data(module, buffer);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("pq_bin import isp_ex data failed\n");
return ret;
}
SAMPLE_ERR("pq_bin import isp_ex data success\n");
}
} else if (module->ex.enable == XMEDIA_TRUE) {
SAMPLE_ERR("pq_bin does not cantain data for isp_ex, cannot enable isp_ex.\n");
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
xmedia_u32 get_pq_bin_length(xmedia_u8 *para)
{
xmedia_u32 offSet = 0;
xmedia_u32 length = 0;
xmedia_u32 tmp_len = 0;
bin_module_info mod = { 0 };
mod.vi.pipe = *(xmedia_s32 *)(para + offSet);
offSet += sizeof(xmedia_s32);
mod.vpss.pipe = *(xmedia_s32 *)(para + offSet);
offSet += sizeof(xmedia_s32);
mod.mcf.pipe = *(xmedia_s32 *)(para + offSet);
offSet += sizeof(xmedia_s32);
mod.mcf.ichn = *(xmedia_s32 *)(para + offSet);
offSet += sizeof(xmedia_s32);
mod.ex.pipe = *(xmedia_s32 *)(para + offSet);
offSet += sizeof(xmedia_s32);
mod.vi.enable = *(xmedia_s32 *)(para + offSet);
offSet += sizeof(xmedia_s32);
mod.vpss.enable = *(xmedia_s32 *)(para + offSet);
offSet += sizeof(xmedia_s32);
mod.mcf.enable = *(xmedia_s32 *)(para + offSet);
offSet += sizeof(xmedia_s32);
mod.ex.enable = *(xmedia_s32 *)(para + offSet);
if (mod.vi.enable != XMEDIA_TRUE && mod.ex.enable != XMEDIA_TRUE) {
SAMPLE_ERR("Please at least one module that you want to export.\n");
return XMEDIA_FAILURE;
}
if (mod.vi.enable == XMEDIA_TRUE) {
tmp_len = get_isp_data_len(&mod);
if (tmp_len == XMEDIA_FAILURE) {
return XMEDIA_FAILURE;
}
SAMPLE_ERR("Export ISP data total len: %u\n", tmp_len);
length += tmp_len;
}
if (mod.ex.enable == XMEDIA_TRUE) {
tmp_len = get_isp_ex_data_len(&mod);
if (tmp_len == XMEDIA_FAILURE) {
return XMEDIA_FAILURE;
}
SAMPLE_ERR("Export ISP_EX data total len: %u\n", tmp_len);
length += tmp_len;
}
return length;
}
xmedia_s32 sample_comm_pq_bin_export(bin_module_info *module, xmedia_u8 *buffer,
xmedia_u32 total_length, xmedia_char *file_name)
{
xmedia_s32 ret;
xmedia_u32 tmp_len;
FILE *fd = XMEDIA_NULL;
fd = fopen(file_name, "wb+");
if (fd == XMEDIA_NULL) {
SAMPLE_ERR("pq bin file open failed.\n");
ret = -1;
goto err;
}
ret = pq_bin_data_export(module, buffer, total_length);
if (ret != 0) {
SAMPLE_ERR("pq_bin_data_export err(%#x)!\n", ret);
} else {
tmp_len = fwrite(buffer, 1, total_length, fd);
if (tmp_len != total_length) {
SAMPLE_ERR("write pq bin file err!\n");
ret = -1;
goto err;
}
SAMPLE_ERR("\nexport bin data success!\n");
}
err:
if (fd != XMEDIA_NULL) {
fclose(fd);
}
return ret;
}
xmedia_s32 sample_comm_pq_bin_import(bin_module_info *module, xmedia_char *file_name)
{
xmedia_s32 ret = XMEDIA_FAILURE;
xmedia_u32 size;
xmedia_u32 tmp_len;
xmedia_u8 *buffer = XMEDIA_NULL;
FILE *fd = XMEDIA_NULL;
fd = fopen(file_name, "r");
if (fd == XMEDIA_NULL) {
SAMPLE_ERR("No such file.\n");
return XMEDIA_FAILURE;
}
fseek(fd, 0, SEEK_END);
size = ftell(fd);
fseek(fd, 0, SEEK_SET);
buffer = (xmedia_u8 *)malloc(size);
if (buffer == XMEDIA_NULL) {
SAMPLE_ERR("buffer malloc fail\n");
fclose(fd);
return XMEDIA_FAILURE;
}
tmp_len = fread(buffer, sizeof(xmedia_u8), size, fd);
if (tmp_len == 0) {
SAMPLE_ERR("read error\n");
goto err;
}
ret = pq_bin_data_import(module, buffer, size);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("pq_bin_data_import err(%#x)\n", ret);
} else {
SAMPLE_ERR("\nimport bin data success!\n");
}
err:
fclose(fd);
free(buffer);
buffer = XMEDIA_NULL;
return ret;
}
sample/common/sample_comm_pq_bin.h
Executable
+57
View File
@@ -0,0 +1,57 @@
#ifndef _SAMPLE_COMM_PQ_BIN_H_
#define _SAMPLE_COMM_PQ_BIN_H_
#include "sample_comm.h"
#define MAGIC_DATA_LEN 16
#define ISP_MODULE_ISP_EX_NUM 4
typedef struct isp_info {
xmedia_s32 enable;
xmedia_s32 pipe;
} bin_isp_info;
typedef struct vi_info {
xmedia_s32 enable;
xmedia_s32 pipe;
} bin_vi_info;
typedef struct vpss_info {
xmedia_s32 enable;
xmedia_s32 pipe;
} bin_vpss_info;
typedef struct mcf_info {
xmedia_s32 enable;
xmedia_s32 pipe;
xmedia_s32 ichn;
} bin_mcf_info;
typedef struct module_info {
bin_vi_info vi;
bin_vpss_info vpss;
bin_mcf_info mcf;
bin_isp_info ex;
} bin_module_info;
typedef enum opration_select {
PQ_BIN_EXPORT = 0,
PQ_BIN_IMPORT,
PQ_BIN_BUTT
} bin_ops;
extern xmedia_u32 g_isp_len;
extern xmedia_u32 g_isp_ex_len;
static const xmedia_u8 magic_isp[MAGIC_DATA_LEN] = "ISP_BIN";
static const xmedia_u8 magic_isp_ex[MAGIC_DATA_LEN] = "ISP_EX";
xmedia_u32 get_pq_bin_length(xmedia_u8 *para);
xmedia_s32 pq_bin_data_export(bin_module_info *module, xmedia_u8 *buffer, xmedia_u32 total_len);
xmedia_s32 pq_bin_data_import(bin_module_info *module, xmedia_u8 *buffer, xmedia_u32 total_len);
xmedia_s32 sample_comm_pq_bin_import(bin_module_info *module, xmedia_char *file_name);
xmedia_s32 sample_comm_pq_bin_export(bin_module_info *module, xmedia_u8 *buffer,
xmedia_u32 total_length, xmedia_char *file_name);
#endif // _SAMPLE_COMM_PQ_BIN_H_
sample/common/sample_comm_region.c
Executable
+1094
View File
File diff suppressed because it is too large Load Diff
sample/common/sample_comm_region.h
+29
View File
@@ -0,0 +1,29 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_REGION_H__
#define __SAMPLE_COMM_REGION_H__
#include "xmedia_type.h"
#include "xmedia_region.h"
#ifdef __cplusplus
extern "C" {
#endif
xmedia_s32 sample_comm_region_check_min(xmedia_s32 min_handle);
xmedia_s32 sample_comm_region_get_min_handle(xmedia_rgn_type type);
xmedia_s32 sample_comm_region_get_up_canvas(xmedia_u32 handle, const xmedia_char *bmp_path);
xmedia_s32 sample_comm_region_init(xmedia_void);
xmedia_void sample_comm_region_exit(xmedia_void);
xmedia_s32 sample_comm_region_create(xmedia_s32 handle_num, xmedia_rgn_type type);
xmedia_s32 sample_comm_region_attach_to_chn(xmedia_s32 handle_num, xmedia_rgn_type type, xmedia_chn_info *mpp_chn);
xmedia_s32 sample_comm_region_detach_frm_chn(xmedia_s32 handle_num, xmedia_rgn_type type, xmedia_chn_info *mpp_chn);
xmedia_s32 sample_comm_region_get_min_handle(xmedia_rgn_type type);
xmedia_s32 sample_comm_region_destroy(xmedia_s32 handle_num, xmedia_rgn_type type);
#ifdef __cplusplus
}
#endif
#endif /*__SAMPLE_COMM_REGION_H__*/
sample/common/sample_comm_sys.c
Executable
+803
View File
@@ -0,0 +1,803 @@
/*
* Copyright (c) Hunan xmedia,Chengdu xmedia,Shandong xmedia. 2021. All rights reserved.
*/
#include <stdio.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include "math_fun.h"
#include "sample_comm.h"
#include "xmedia_type.h"
#include "xmedia_sys.h"
#include "xmedia_vb.h"
#include "xmedia_vo.h"
#include "sample_comm_sys.h"
#include "xmedia_scene.h"
static sample_comm_npu_workspace_cfg g_npu_workspace_cfg = {0};
static xmedia_s32 g_mem_dev;
xmedia_s32 sample_comm_sys_init(sample_sys_config *sys_conifg)
{
CHECK_RET(xmedia_vb_exit(), "vb exit");
CHECK_RET(xmedia_sys_exit(), "sys exit");
CHECK_RET(xmedia_sys_init(&sys_conifg->sys_conf), "sys init");
CHECK_RET(xmedia_vb_init(&sys_conifg->vb_conf), "vb init");
#if 0
// setting scene capability if necessary
CHECK_RET(xmedia_scene_init(), "scene init");
xmedia_media_npu_load npu_load = XMEDIA_NPU_LOAD_LIGHT;
xmedia_scene_capability scene_capability = { 0 };
scene_capability.vpu_chn[0].vpu_chn_id = 0;
scene_capability.vpu_chn[0].capability.width = 3840;
scene_capability.vpu_chn[0].capability.height = 2160;
scene_capability.vpu_chn[0].capability.framerate = 30;
scene_capability.vpu_chn[1].vpu_chn_id = 1;
scene_capability.vpu_chn[1].capability.width = 1280;
scene_capability.vpu_chn[1].capability.height = 720;
scene_capability.vpu_chn[1].capability.framerate = 30;
CHECK_RET(xmedia_scene_config(npu_load, &scene_capability), "scene config");
#endif
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_cmp_init(sample_sys_config *sys_conifg)
{
CHECK_RET(xmedia_vb_exit(), "vb exit");
CHECK_RET(xmedia_sys_exit(), "sys exit");
CHECK_RET(xmedia_sys_init(&sys_conifg->sys_conf), "sys init");
CHECK_RET(xmedia_sys_set_compress_level(sys_conifg->compress_level), "set compress level");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vb_init(sample_sys_config *sys_conifg)
{
CHECK_RET(xmedia_vb_init(&sys_conifg->vb_conf), "vb init");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_exit(xmedia_void)
{
CHECK_RET(xmedia_vb_exit(), "vb exit");
CHECK_RET(xmedia_sys_exit(), "sys exit");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vi_bind_vo(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_vo_layer vo_layer,
xmedia_s32 vo_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VI;
src_chn.dev_id = vi_pipe;
src_chn.chn_id = vi_chn;
dst_chn.mod_id = MOD_ID_VO;
dst_chn.dev_id = vo_layer;
dst_chn.chn_id = vo_chn;
CHECK_RET(xmedia_sys_bind(&src_chn, &dst_chn), "xmedia_sys_bind(VI-VO)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vi_unbind_vo(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_vo_layer vo_layer,
xmedia_s32 vo_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VI;
src_chn.dev_id = vi_pipe;
src_chn.chn_id = vi_chn;
dst_chn.mod_id = MOD_ID_VO;
dst_chn.dev_id = vo_layer;
dst_chn.chn_id = vo_chn;
CHECK_RET(xmedia_sys_unbind(&src_chn, &dst_chn), "xmedia_sys_unbind(VI-VO)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vi_bind_vpss(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 vpss_pipe,
xmedia_s32 vpss_ichn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VI;
src_chn.dev_id = vi_pipe;
src_chn.chn_id = vi_chn;
dst_chn.mod_id = MOD_ID_VPSS;
dst_chn.dev_id = vpss_pipe;
dst_chn.chn_id = vpss_ichn;
CHECK_RET(xmedia_sys_bind(&src_chn, &dst_chn), "xmedia_sys_bind(VI-VPSS)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vi_unbind_vpss(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 vpss_pipe,
xmedia_s32 vpss_ichn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VI;
src_chn.dev_id = vi_pipe;
src_chn.chn_id = vi_chn;
dst_chn.mod_id = MOD_ID_VPSS;
dst_chn.dev_id = vpss_pipe;
dst_chn.chn_id = vpss_ichn;
CHECK_RET(xmedia_sys_unbind(&src_chn, &dst_chn), "xmedia_sys_unbind(VI-VPSS)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vi_bind_mcf(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 mcf_pipe,
xmedia_s32 mcf_ichn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VI;
src_chn.dev_id = vi_pipe;
src_chn.chn_id = vi_chn;
dst_chn.mod_id = MOD_ID_MCF;
dst_chn.dev_id = mcf_pipe;
dst_chn.chn_id = mcf_ichn;
CHECK_RET(xmedia_sys_bind(&src_chn, &dst_chn), "xmedia_sys_bind(VI-MCF)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vi_unbind_mcf(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 mcf_pipe,
xmedia_s32 mcf_ichn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VI;
src_chn.dev_id = vi_pipe;
src_chn.chn_id = vi_chn;
dst_chn.mod_id = MOD_ID_MCF;
dst_chn.dev_id = mcf_pipe;
dst_chn.chn_id = mcf_ichn;
CHECK_RET(xmedia_sys_unbind(&src_chn, &dst_chn), "xmedia_sys_unbind(VI-MCF)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vi_bind_venc(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 venc_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VI;
src_chn.dev_id = vi_pipe;
src_chn.chn_id = vi_chn;
dst_chn.mod_id = MOD_ID_VENC;
dst_chn.dev_id = 0;
dst_chn.chn_id = venc_chn;
CHECK_RET(xmedia_sys_bind(&src_chn, &dst_chn), "xmedia_sys_bind(VI-VENC)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vi_unbind_venc(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 venc_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VI;
src_chn.dev_id = vi_pipe;
src_chn.chn_id = vi_chn;
dst_chn.mod_id = MOD_ID_VENC;
dst_chn.dev_id = 0;
dst_chn.chn_id = venc_chn;
CHECK_RET(xmedia_sys_unbind(&src_chn, &dst_chn), "xmedia_sys_unbind(VI-VENC)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_mcf_bind_vpss(xmedia_s32 mcf_pipe, xmedia_s32 mcf_chn, xmedia_s32 vpss_pipe,
xmedia_s32 vpss_ichn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_MCF;
src_chn.dev_id = mcf_pipe;
src_chn.chn_id = mcf_chn;
dst_chn.mod_id = MOD_ID_VPSS;
dst_chn.dev_id = vpss_pipe;
dst_chn.chn_id = vpss_ichn;
CHECK_RET(xmedia_sys_bind(&src_chn, &dst_chn), "xmedia_sys_bind(MCF-VPSS)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_mcf_unbind_vpss(xmedia_s32 mcf_pipe, xmedia_s32 mcf_chn, xmedia_s32 vpss_pipe,
xmedia_s32 vpss_ichn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_MCF;
src_chn.dev_id = mcf_pipe;
src_chn.chn_id = mcf_chn;
dst_chn.mod_id = MOD_ID_VPSS;
dst_chn.dev_id = vpss_pipe;
dst_chn.chn_id = vpss_ichn;
CHECK_RET(xmedia_sys_unbind(&src_chn, &dst_chn), "xmedia_sys_unbind(MCF-VPSS)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vpss_bind_vo(xmedia_s32 vpss_pipe, xmedia_s32 vpss_ochn, xmedia_vo_layer vo_layer,
xmedia_s32 vo_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VPSS;
src_chn.dev_id = vpss_pipe;
src_chn.chn_id = vpss_ochn;
dst_chn.mod_id = MOD_ID_VO;
dst_chn.dev_id = vo_layer;
dst_chn.chn_id = vo_chn;
CHECK_RET(xmedia_sys_bind(&src_chn, &dst_chn), "xmedia_sys_bind(VPSS-VO)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vpss_unbind_vo(xmedia_s32 vpss_pipe, xmedia_s32 vpss_ochn, xmedia_vo_layer vo_layer,
xmedia_s32 vo_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VPSS;
src_chn.dev_id = vpss_pipe;
src_chn.chn_id = vpss_ochn;
dst_chn.mod_id = MOD_ID_VO;
dst_chn.dev_id = vo_layer;
dst_chn.chn_id = vo_chn;
CHECK_RET(xmedia_sys_unbind(&src_chn, &dst_chn), "xmedia_sys_unbind(VPSS-VO)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vpss_bind_venc(xmedia_s32 vpss_pipe, xmedia_s32 vpss_ochn, xmedia_s32 venc_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VPSS;
src_chn.dev_id = vpss_pipe;
src_chn.chn_id = vpss_ochn;
dst_chn.mod_id = MOD_ID_VENC;
dst_chn.dev_id = 0;
dst_chn.chn_id = venc_chn;
CHECK_RET(xmedia_sys_bind(&src_chn, &dst_chn), "xmedia_sys_bind(VPSS-VENC)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vpss_unbind_venc(xmedia_s32 vpss_pipe, xmedia_s32 vpss_ochn, xmedia_s32 venc_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VPSS;
src_chn.dev_id = vpss_pipe;
src_chn.chn_id = vpss_ochn;
dst_chn.mod_id = MOD_ID_VENC;
dst_chn.dev_id = 0;
dst_chn.chn_id = venc_chn;
CHECK_RET(xmedia_sys_unbind(&src_chn, &dst_chn), "xmedia_sys_unbind(VPSS-VENC)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vdec_bind_vpss(xmedia_s32 vdec_chn, xmedia_s32 vpss_pipe, xmedia_s32 vpss_ichn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VDEC;
src_chn.dev_id = 0;
src_chn.chn_id = vdec_chn;
dst_chn.mod_id = MOD_ID_VPSS;
dst_chn.dev_id = vpss_pipe;
dst_chn.chn_id = vpss_ichn;
CHECK_RET(xmedia_sys_bind(&src_chn, &dst_chn), "xmedia_sys_bind(VDEC-VPSS)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vdec_unbind_vpss(xmedia_s32 vdec_chn, xmedia_s32 vpss_pipe, xmedia_s32 vpss_ichn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VDEC;
src_chn.dev_id = 0;
src_chn.chn_id = vdec_chn;
dst_chn.mod_id = MOD_ID_VPSS;
dst_chn.dev_id = vpss_pipe;
dst_chn.chn_id = vpss_ichn;
CHECK_RET(xmedia_sys_unbind(&src_chn, &dst_chn), "xmedia_sys_unbind(VDEC-VPSS)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vdec_bind_vo(xmedia_vo_dev vo_dev, xmedia_vo_chn vo_chn, xmedia_s32 vdec_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VDEC;
src_chn.dev_id = 0;
src_chn.chn_id = vdec_chn;
dst_chn.mod_id = MOD_ID_VO;
dst_chn.dev_id = vo_dev;
dst_chn.chn_id = vo_chn;
CHECK_RET(xmedia_sys_bind(&src_chn, &dst_chn), "xmedia_sys_bind(VDEC-VO)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vdec_unbind_vo(xmedia_vo_dev vo_dev, xmedia_vo_chn vo_chn, xmedia_s32 vdec_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VDEC;
src_chn.dev_id = 0;
src_chn.chn_id = vdec_chn;
dst_chn.mod_id = MOD_ID_VO;
dst_chn.dev_id = vo_dev;
dst_chn.chn_id = vo_chn;
CHECK_RET(xmedia_sys_unbind(&src_chn, &dst_chn), "xmedia_sys_unbind(VDEC-VO)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vo_bind_venc(xmedia_vo_dev vo_dev, xmedia_s32 venc_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VO;
src_chn.dev_id = vo_dev;
src_chn.chn_id = 0;
dst_chn.mod_id = MOD_ID_VENC;
dst_chn.dev_id = 0;
dst_chn.chn_id = venc_chn;
CHECK_RET(xmedia_sys_bind(&src_chn, &dst_chn), "xmedia_sys_bind(VO-VENC)");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_vo_unbind_venc(xmedia_vo_dev vo_dev, xmedia_s32 venc_chn)
{
xmedia_chn_info src_chn;
xmedia_chn_info dst_chn;
src_chn.mod_id = MOD_ID_VO;
src_chn.dev_id = vo_dev;
src_chn.chn_id = 0;
dst_chn.mod_id = MOD_ID_VENC;
dst_chn.dev_id = 0;
dst_chn.chn_id = venc_chn;
CHECK_RET(xmedia_sys_unbind(&src_chn, &dst_chn), "xmedia_sys_unbind(VO-VENC)");
return XMEDIA_SUCCESS;
}
pic_size_e sample_comm_sys_get_picszie_by_wxh(xmedia_u32 width, xmedia_u32 height)
{
pic_size_e pic_size;
if ((width == 352) && (height == 288)) {
pic_size = PIC_CIF;
} else if ((width == 640) && (height == 360)) {
pic_size = PIC_360P;
} else if ((width == 640) && (height == 480)) {
pic_size = PIC_VGA;
} else if ((width == 640) && (height == 360)) {
pic_size = PIC_640x360;
} else if ((width == 720) && (height == 576)) {
pic_size = PIC_D1_PAL;
} else if ((width == 720) && (height == 480)) {
pic_size = PIC_D1_NTSC;
} else if ((width == 1280) && (height == 720)) {
pic_size = PIC_720P;
} else if ((width == 1920) && (height == 1080)) {
pic_size = PIC_1080P;
} else if ((width == 2304) && (height == 1296)) {
pic_size = PIC_2304x1296;
} else if ((width == 2560) && (height == 1440)) {
pic_size = PIC_2560x1440;
} else if ((width == 2560) && (height == 1920)) {
pic_size = PIC_2560x1920;
} else if ((width == 2592) && (height == 1520)) {
pic_size = PIC_2592x1520;
} else if ((width == 2592) && (height == 1944)) {
pic_size = PIC_2592x1944;
} else if ((width == 2592) && (height == 1536)) {
pic_size = PIC_2592x1536;
} else if ((width == 2688) && (height == 1520)) {
pic_size = PIC_2688x1520;
} else if ((width == 2716) && (height == 1524)) {
pic_size = PIC_2716x1524;
} else if ((width == 3840) && (height == 2160)) {
pic_size = PIC_3840x2160;
} else if ((width == 3000) && (height == 3000)) {
pic_size = PIC_3000x3000;
} else if ((width == 4000) && (height == 3000)) {
pic_size = PIC_4000x3000;
} else if ((width == 4096) && (height == 2160)) {
pic_size = PIC_4096x2160;
} else if ((width == 7680) && (height == 4320)) {
pic_size = PIC_7680x4320;
} else if ((width == 3840) && (height == 8640)) {
pic_size = PIC_3840x8640;
} else if ((width == 2688) && (height == 1536)) {
pic_size = PIC_2688x1536;
} else if ((width == 2688) && (height == 1944)) {
pic_size = PIC_2688x1944;
} else if ((width == 2880) && (height == 1620)) {
pic_size = PIC_2880x1620;
} else if ((width == 3072) && (height == 1728)) {
pic_size = PIC_3072x1728;
} else {
pic_size = PIC_BUTT;
}
return pic_size;
}
xmedia_s32 sample_comm_sys_get_buffer_size(xmedia_video_size pic_size, xmedia_video_format video_fmt,
xmedia_video_pixel_format pixel_fmt, xmedia_video_data_width data_width,
xmedia_video_compress_mode compress_mode)
{
xmedia_vb_base_info vb_base_info = { 0 };
xmedia_vb_cal_cfg vb_cfg = { 0 };
vb_base_info.width = pic_size.width;
vb_base_info.height = pic_size.height;
vb_base_info.video_fmt = video_fmt;
vb_base_info.pixel_fmt = pixel_fmt;
vb_base_info.bit_width = data_width;
vb_base_info.align = DEFAULT_ALIGN;
vb_base_info.cmp_mode = compress_mode;
xmedia_vb_get_buffer_config(&vb_base_info, &vb_cfg);
return vb_cfg.vb_size;
}
xmedia_s32 sample_comm_sys_get_wrap_buffer_size(xmedia_video_size pic_size, xmedia_video_format video_fmt,
xmedia_video_pixel_format pixel_fmt, xmedia_video_data_width data_width,
xmedia_video_compress_mode compress_mode, xmedia_u32 *wrap_buffer_line)
{
xmedia_vb_base_info vb_base_info = { 0 };
vb_base_info.width = pic_size.width;
vb_base_info.height = pic_size.height;
vb_base_info.video_fmt = XMEDIA_VIDEO_FMT_TILE_32x4;
vb_base_info.pixel_fmt = pixel_fmt;
vb_base_info.bit_width = XMEDIA_VIDEO_DATA_WIDTH_8;
vb_base_info.align = DEFAULT_ALIGN;
vb_base_info.cmp_mode = XMEDIA_VIDEO_COMPRESS_MODE_TILE_COMPACT;
*wrap_buffer_line = XM_ALIGN_DOWN(pic_size.height * 5 / 10, 8);
SAMPLE_PRT("wrap buffer line is %d \n", *wrap_buffer_line);
return xmedia_vb_get_wrap_buffer_size(&vb_base_info, *wrap_buffer_line);
}
xmedia_s32 sample_comm_sys_getchar_timeout(xmedia_u32 timeout_ms)
{
fd_set read_fds;
struct timeval timeout;
xmedia_s32 retval;
FD_ZERO(&read_fds);
FD_SET(STDIN_FILENO, &read_fds);
timeout.tv_sec = timeout_ms / 1000;
timeout.tv_usec = (timeout_ms % 1000) * 1000;
retval = select(STDIN_FILENO + 1, &read_fds, XMEDIA_NULL, XMEDIA_NULL, &timeout);
if (retval <= 0) {
return XMEDIA_FAILURE;
} else {
if (FD_ISSET(STDIN_FILENO, &read_fds)) {
retval = getchar();
return retval;
}
}
return XMEDIA_FAILURE;
}
xmedia_s32 sample_comm_sys_npu_acquire_workspace(sample_comm_npu_workspace_info *npu_info)
{
xmedia_s32 s32_ret = XMEDIA_FAILURE;
xmedia_s32 cl_err_code = 0;
xmedia_u32 cl_work_size = 0;
xmedia_u32 cl_weight_size = 0;
xmedia_u32 max_cl_work_size = 0;
CHECK_NULL_PTR(npu_info);
if (npu_info->npu_modle_num == 0) {
SAMPLE_ERR("acquire workspace fail model num 0 .\n");
return XMEDIA_FAILURE;
}
s32_ret = xmedia_cl_init();
if (s32_ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_init fail \n");
return s32_ret;
}
s32_ret = xmedia_cl_get_device_ids(XMEDIA_CL_DEVICE_ALL, XMEDIA_NULL, &g_npu_workspace_cfg.cl_device_num);
if (s32_ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_get_device_ids fail \n");
goto CL_ERR0;
}
g_npu_workspace_cfg.cl_device = (xmedia_cl_device_id *)calloc(g_npu_workspace_cfg.cl_device_num, sizeof(xmedia_cl_device_id));
if (g_npu_workspace_cfg.cl_device == XMEDIA_NULL) {
SAMPLE_ERR("cl device calloc fail\n");
goto CL_ERR0;
}
s32_ret = xmedia_cl_get_device_ids(XMEDIA_CL_DEVICE_ALL, g_npu_workspace_cfg.cl_device, &g_npu_workspace_cfg.cl_device_num);
if (s32_ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_get_device_ids sec fail \n");
goto CL_ERR1;
}
g_npu_workspace_cfg.cl_ctx = xmedia_cl_create_context(g_npu_workspace_cfg.cl_device_num, g_npu_workspace_cfg.cl_device, &cl_err_code);
if (cl_err_code != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_create_context fail\n");
goto CL_ERR2;
}
for (xmedia_s32 i = 0; i < npu_info->npu_modle_num; i++) {
s32_ret = xmedia_cl_graph_querysize_from_file(npu_info->npu_model_path[i], &cl_work_size, &cl_weight_size);
if (cl_err_code != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_graph_querysize_from_file fail\n");
goto CL_ERR3;
}
max_cl_work_size = (max_cl_work_size > cl_work_size) ? max_cl_work_size : cl_work_size;
}
g_npu_workspace_cfg.work_space_phyaddr = xmedia_mmz_alloc(XMEDIA_NULL, "AIworkspace", max_cl_work_size);
if (g_npu_workspace_cfg.work_space_phyaddr == XMEDIA_NULL) {
SAMPLE_ERR("xmedia_mmz_alloc fail\n");
goto CL_ERR3;
}
g_npu_workspace_cfg.work_space_viraddr = xmedia_mmz_map(g_npu_workspace_cfg.work_space_phyaddr, max_cl_work_size, 1);
if (g_npu_workspace_cfg.work_space_viraddr == XMEDIA_NULL) {
SAMPLE_ERR("xmedia_mmz_map fail\n");
goto CL_ERR4;
}
s32_ret = xmedia_cl_set_workspace_addr(g_npu_workspace_cfg.cl_ctx, g_npu_workspace_cfg.work_space_viraddr, max_cl_work_size);
if (s32_ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_mmz_map fail\n");
goto CL_ERR5;
}
return XMEDIA_SUCCESS;
CL_ERR5:
if (g_npu_workspace_cfg.work_space_viraddr != XMEDIA_NULL) {
xmedia_mmz_unmap(g_npu_workspace_cfg.work_space_viraddr);
}
CL_ERR4:
xmedia_mmz_free(g_npu_workspace_cfg.work_space_phyaddr);
CL_ERR3:
s32_ret = xmedia_cl_release_context(g_npu_workspace_cfg.cl_ctx);
if (s32_ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_release_context id fail \n");
}
CL_ERR2:
s32_ret = xmedia_cl_release_device_ids(g_npu_workspace_cfg.cl_device, &g_npu_workspace_cfg.cl_device_num);
if (s32_ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_release_device_ids id fail \n");
}
CL_ERR1:
free(g_npu_workspace_cfg.cl_device);
g_npu_workspace_cfg.cl_device = XMEDIA_NULL;
CL_ERR0:
s32_ret = xmedia_cl_uninit();
if (s32_ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_uninit fail \n");
return s32_ret;
}
return XMEDIA_FAILURE;
}
xmedia_s32 sample_comm_sys_npu_release_workspace()
{
xmedia_s32 s32_ret = XMEDIA_FAILURE;
if (g_npu_workspace_cfg.work_space_viraddr != XMEDIA_NULL) {
xmedia_mmz_unmap(g_npu_workspace_cfg.work_space_viraddr);
}
xmedia_mmz_free(g_npu_workspace_cfg.work_space_phyaddr);
s32_ret = xmedia_cl_release_context(g_npu_workspace_cfg.cl_ctx);
if (s32_ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_release_context id fail \n");
}
s32_ret = xmedia_cl_release_device_ids(g_npu_workspace_cfg.cl_device, &g_npu_workspace_cfg.cl_device_num);
if (s32_ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_release_device_ids id fail \n");
}
free(g_npu_workspace_cfg.cl_device);
g_npu_workspace_cfg.cl_device = XMEDIA_NULL;
s32_ret = xmedia_cl_uninit();
if (s32_ret != XMEDIA_SUCCESS) {
SAMPLE_ERR("xmedia_cl_uninit fail \n");
return s32_ret;
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_mem_open(xmedia_void)
{
if (g_mem_dev <= 0) {
g_mem_dev = open ("/dev/mem", O_CREAT | O_RDWR | O_SYNC);
if (g_mem_dev <= 0) {
return XMEDIA_FAILURE;
}
}
return XMEDIA_SUCCESS;
}
xmedia_void sample_comm_sys_mem_close(xmedia_void)
{
if (g_mem_dev > 0) {
close(g_mem_dev);
g_mem_dev = 0;
}
}
xmedia_void* sample_comm_sys_mem_map(xmedia_u32 phy_addr, xmedia_u32 size)
{
xmedia_u32 diff;
xmedia_u32 page_phy;
xmedia_u32 page_size;
xmedia_u8* page_addr;
page_phy = phy_addr & 0xfffff000;
diff = phy_addr - page_phy;
page_size = ((size + diff - 1) & 0xfffff000) + 0x1000;
page_addr = mmap((void *)0, page_size, PROT_READ|PROT_WRITE, MAP_SHARED, g_mem_dev, page_phy);
if (MAP_FAILED == page_addr) {
perror("mmap error\n");
return XMEDIA_NULL;
}
return (xmedia_void *) (page_addr + diff);
}
xmedia_void sample_comm_sys_mem_unmap(xmedia_void* vir_addr, xmedia_u32 size)
{
xmedia_u32 page_addr;
xmedia_u32 page_size;
xmedia_u32 diff;
page_addr = (((xmedia_u32)vir_addr) & 0xfffff000);
diff = (xmedia_u32)vir_addr - page_addr;
page_size = ((size + diff - 1) & 0xfffff000) + 0x1000;
munmap((xmedia_void*)page_addr, page_size);
}
xmedia_s32 sample_comm_sys_set_reg(xmedia_u32 addr, xmedia_u32 value)
{
xmedia_u32 *vir_addr = XMEDIA_NULL;
vir_addr = sample_comm_sys_mem_map(addr, sizeof(value));
if (vir_addr == XMEDIA_NULL) {
SAMPLE_PRT("sample sys mem map 0x%x failed\n", addr);
return XMEDIA_FAILURE;
}
*vir_addr = value;
sample_comm_sys_mem_unmap(vir_addr, sizeof(value));
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_sys_get_reg(xmedia_u32 addr, xmedia_u32 *value)
{
xmedia_u32 *vir_addr;
vir_addr = sample_comm_sys_mem_map(addr, sizeof(value));
if (vir_addr == XMEDIA_NULL) {
SAMPLE_PRT("sample sys mem map 0x%x failed\n", addr);
return XMEDIA_FAILURE;
}
*value = *vir_addr;
sample_comm_sys_mem_unmap(vir_addr, sizeof(value));
return XMEDIA_SUCCESS;
}
sample/common/sample_comm_sys.h
Executable
+102
View File
@@ -0,0 +1,102 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_SYS_H__
#define __SAMPLE_COMM_SYS_H__
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "xmedia_type.h"
#include "xmedia_sys.h"
#include "xmedia_vb.h"
#include "xmedia_vo.h"
#include "xmedia_mmz.h"
#include "xmedia_cl.h"
#include "sample_comm.h"
#ifdef __cplusplus
extern "C" {
#endif
#define NPU_WORKSPACE_MAX_MODEL_NUM 4//The maximum scenario may include up to 4 models
typedef struct sample_sys_config {
xmedia_sys_config sys_conf;
xmedia_vb_config vb_conf;
xmedia_sys_compress_level compress_level;
} sample_sys_config;
typedef struct sample_comm_npu_workspace_cfg {
xmedia_cl_context cl_ctx;
xmedia_u32 cl_device_num;
xmedia_cl_device_id *cl_device;
xmedia_u64 work_space_phyaddr;
xmedia_void *work_space_viraddr;
} sample_comm_npu_workspace_cfg;
typedef struct sample_comm_npu_workspace_info {
xmedia_s32 npu_modle_num;
xmedia_char *npu_model_path[NPU_WORKSPACE_MAX_MODEL_NUM];
} sample_comm_npu_workspace_info;
xmedia_s32 sample_comm_sys_init(sample_sys_config *sys_conifg);
xmedia_s32 sample_comm_sys_cmp_init(sample_sys_config *sys_conifg);
xmedia_s32 sample_comm_vb_init(sample_sys_config *sys_conifg);
xmedia_s32 sample_comm_sys_exit(xmedia_void);
xmedia_s32 sample_comm_sys_vi_bind_vo(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_vo_layer vo_layer,
xmedia_s32 vo_chn);
xmedia_s32 sample_comm_sys_vi_unbind_vo(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_vo_layer vo_layer,
xmedia_s32 vo_chn);
xmedia_s32 sample_comm_sys_vi_bind_vpss(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 vpss_pipe,
xmedia_s32 vpss_ichn);
xmedia_s32 sample_comm_sys_vi_unbind_vpss(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 vpss_pipe,
xmedia_s32 vpss_ichn);
xmedia_s32 sample_comm_sys_vi_bind_mcf(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 mcf_pipe,
xmedia_s32 mcf_ichn);
xmedia_s32 sample_comm_sys_vi_unbind_mcf(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 mcf_pipe,
xmedia_s32 mcf_ichn);
xmedia_s32 sample_comm_sys_vi_bind_venc(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 venc_chn);
xmedia_s32 sample_comm_sys_vi_unbind_venc(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 venc_chn);
xmedia_s32 sample_comm_sys_mcf_bind_vpss(xmedia_s32 mcf_pipe, xmedia_s32 mcf_chn, xmedia_s32 vpss_pipe,
xmedia_s32 vpss_ichn);
xmedia_s32 sample_comm_sys_mcf_unbind_vpss(xmedia_s32 mcf_pipe, xmedia_s32 mcf_chn, xmedia_s32 vpss_pipe,
xmedia_s32 vpss_ichn);
xmedia_s32 sample_comm_sys_vpss_bind_vo(xmedia_s32 vpss_pipe, xmedia_s32 vpss_ochn, xmedia_vo_layer vo_layer,
xmedia_s32 vo_chn);
xmedia_s32 sample_comm_sys_vpss_unbind_vo(xmedia_s32 vpss_pipe, xmedia_s32 vpss_ochn, xmedia_vo_layer vo_layer,
xmedia_s32 vo_chn);
xmedia_s32 sample_comm_sys_vpss_bind_venc(xmedia_s32 vpss_pipe, xmedia_s32 vpss_ochn, xmedia_s32 venc_chn);
xmedia_s32 sample_comm_sys_vpss_unbind_venc(xmedia_s32 vpss_pipe, xmedia_s32 vpss_ochn, xmedia_s32 venc_chn);
xmedia_s32 sample_comm_sys_vdec_bind_vpss(xmedia_s32 vdec_chn, xmedia_s32 vpss_pipe, xmedia_s32 vpss_ichn);
xmedia_s32 sample_comm_sys_vdec_unbind_vpss(xmedia_s32 vdec_chn, xmedia_s32 vpss_pipe, xmedia_s32 vpss_ichn);
xmedia_s32 sample_comm_sys_vdec_bind_vo(xmedia_vo_dev vo_dev, xmedia_vo_chn vo_chn, xmedia_s32 vdec_chn);
xmedia_s32 sample_comm_sys_vdec_unbind_vo(xmedia_vo_dev vo_dev, xmedia_vo_chn vo_chn, xmedia_s32 vdec_chn);
xmedia_s32 sample_comm_sys_vo_bind_venc(xmedia_vo_dev vo_dev, xmedia_s32 venc_chn);
xmedia_s32 sample_comm_sys_vo_unbind_venc(xmedia_vo_dev vo_dev, xmedia_s32 venc_chn);
pic_size_e sample_comm_sys_get_picszie_by_wxh(xmedia_u32 width, xmedia_u32 height);
xmedia_s32 sample_comm_sys_get_buffer_size(xmedia_video_size pic_size, xmedia_video_format video_fmt,
xmedia_video_pixel_format pixel_fmt, xmedia_video_data_width data_width,
xmedia_video_compress_mode compress_mode);
xmedia_s32 sample_comm_sys_get_wrap_buffer_size(xmedia_video_size pic_size, xmedia_video_format video_fmt,
xmedia_video_pixel_format pixel_fmt, xmedia_video_data_width data_width,
xmedia_video_compress_mode compress_mode, xmedia_u32 *wrap_buffer_line);
xmedia_s32 sample_comm_sys_getchar_timeout(xmedia_u32 timeout_ms);
xmedia_s32 sample_comm_sys_npu_acquire_workspace(sample_comm_npu_workspace_info *npu_info);
xmedia_s32 sample_comm_sys_npu_release_workspace();
xmedia_s32 sample_comm_sys_mem_open(xmedia_void);
xmedia_void sample_comm_sys_mem_close(xmedia_void);
xmedia_void* sample_comm_sys_mem_map(xmedia_u32 phy_addr, xmedia_u32 size);
xmedia_void sample_comm_sys_mem_unmap(xmedia_void* vir_addr, xmedia_u32 size);
xmedia_s32 sample_comm_sys_set_reg(xmedia_u32 addr, xmedia_u32 value);
xmedia_s32 sample_comm_sys_get_reg(xmedia_u32 addr, xmedia_u32 *value);
#ifdef __cplusplus
}
#endif
#endif
sample/common/sample_comm_thrd_pool.c
+155
View File
@@ -0,0 +1,155 @@
#include "sample_comm_thrd_pool.h"
// 线程池工作函数
xmedia_void *sample_comm_thrd_pool_worker(xmedia_void* arg)
{
thread_pool_t *pool = (thread_pool_t *)arg;
while (1) {
// 加锁
pthread_mutex_lock(&pool->mutex);
// 等待任务或关闭信号
while (pool->queue_size == 0 && !pool->shutdown) {
pthread_cond_wait(&pool->cond, &pool->mutex);
}
// 如果线程池要关闭，退出循环
if (pool->shutdown == XMEDIA_TRUE) {
pthread_mutex_unlock(&pool->mutex);
break;
}
// 取出任务
task_t task = pool->task_queue[pool->queue_front];
pool->queue_front = (pool->queue_front + 1) % pool->queue_capacity;
pool->queue_size--;
// 解锁
pthread_mutex_unlock(&pool->mutex);
// 执行任务
task.function(task.arg);
}
pthread_exit(NULL);
//return;
}
// 初始化线程池
thread_pool_t *sample_comm_thrd_pool_init(xmedia_s32 thread_count, xmedia_s32 queue_capacity)
{
thread_pool_t *pool = (thread_pool_t *)malloc(sizeof(thread_pool_t));
if (!pool) {
perror("thread pool malloc failed!");
return NULL;
}
// 初始化任务队列
pool->queue_capacity = queue_capacity;
pool->task_queue = (task_t *)malloc(sizeof(task_t) * queue_capacity);
if (!pool->task_queue) {
perror("task queue malloc failed!");
free(pool);
return NULL;
}
pool->queue_size = 0;
pool->queue_front = 0;
pool->queue_rear = 0;
// 初始化线程数组
pool->thread_count = thread_count;
pool->threads = (pthread_t *)malloc(sizeof(pthread_t) * thread_count);
if (!pool->threads) {
perror("thread handle malloc failed!");
free(pool->task_queue);
free(pool);
return NULL;
}
// 初始化互斥锁和条件变量
if (pthread_mutex_init(&pool->mutex, NULL) != 0 ||
pthread_cond_init(&pool->cond, NULL) != 0) {
perror("pthread_mutex_init or pthread_cond_init failed!");
free(pool->threads);
free(pool->task_queue);
free(pool);
return NULL;
}
pool->shutdown = XMEDIA_FALSE;
// 创建工作线程
for (int i = 0; i < thread_count; i++) {
if (pthread_create(&pool->threads[i], NULL, sample_comm_thrd_pool_worker, pool) != 0) {
perror("pthread_create failed!");
// 清理已创建的资源
pool->shutdown = XMEDIA_TRUE;
for (int j = 0; j < i; j++) {
pthread_join(pool->threads[j], NULL);
}
pthread_mutex_destroy(&pool->mutex);
pthread_cond_destroy(&pool->cond);
free(pool->threads);
free(pool->task_queue);
free(pool);
return NULL;
}
}
return pool;
}
// 向线程池提交任务
xmedia_s32 sample_comm_thrd_job_submit(thread_pool_t* pool, xmedia_void (*function)(xmedia_void*), xmedia_void* arg)
{
if (!pool || !function) return XMEDIA_FAILURE;
pthread_mutex_lock(&pool->mutex);
// 检查队列是否已满
if (pool->queue_size == pool->queue_capacity) {
pthread_mutex_unlock(&pool->mutex);
fprintf(stderr, "task queue is full,can not submit new task!\n");
return XMEDIA_FAILURE;
}
// 添加任务到队列
pool->task_queue[pool->queue_rear].function = function;
pool->task_queue[pool->queue_rear].arg = arg;
pool->queue_rear = (pool->queue_rear + 1) % pool->queue_capacity;
pool->queue_size++;
// 唤醒一个等待的线程
pthread_cond_signal(&pool->cond);
pthread_mutex_unlock(&pool->mutex);
return XMEDIA_SUCCESS;
}
// 销毁线程池
xmedia_void sample_comm_thrd_pool_destroy(thread_pool_t* pool)
{
if (!pool) return;
// 标记线程池为关闭状态
pthread_mutex_lock(&pool->mutex);
pool->shutdown = XMEDIA_TRUE;
pthread_mutex_unlock(&pool->mutex);
// 唤醒所有等待的线程
pthread_cond_broadcast(&pool->cond);
// 等待所有线程结束
for (int i = 0; i < pool->thread_count; i++) {
pthread_join(pool->threads[i], NULL);
}
// 释放资源
free(pool->threads);
free(pool->task_queue);
pthread_mutex_destroy(&pool->mutex);
pthread_cond_destroy(&pool->cond);
free(pool);
}
sample/common/sample_comm_thrd_pool.h
+37
View File
@@ -0,0 +1,37 @@
#ifndef __SAMPLE_COMM_THRD_POOL_H__
#define __SAMPLE_COMM_THRD_POOL_H__
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include "xmedia_type.h"
// 任务结构体
typedef struct {
xmedia_void (*function)(xmedia_void*); // 任务函数
xmedia_void *arg; // 任务参数
} task_t;
// 线程池结构体
typedef struct {
task_t *task_queue; // 任务队列
xmedia_s32 queue_capacity; // 队列容量
xmedia_s32 queue_size; // 当前任务数量
xmedia_s32 queue_front; // 队头索引
xmedia_s32 queue_rear; // 队尾索引
pthread_t *threads; // 线程数组
xmedia_s32 thread_count; // 线程数量
pthread_mutex_t mutex; // 互斥锁
pthread_cond_t cond; // 条件变量
xmedia_bool shutdown; // 线程池关闭标志
} thread_pool_t;
thread_pool_t *sample_comm_thrd_pool_init(xmedia_s32 thread_count, xmedia_s32 queue_capacity);
xmedia_s32 sample_comm_thrd_job_submit(thread_pool_t* pool, xmedia_void (*function)(xmedia_void*), xmedia_void* arg);
xmedia_void *sample_comm_thrd_pool_worker(xmedia_void* arg);
xmedia_void sample_comm_thrd_pool_destroy(thread_pool_t* pool);
#endif
sample/common/sample_comm_tp.c
Executable
+563
View File
@@ -0,0 +1,563 @@
#include <stdio.h>
#include "sample_comm_tp.h"
#include "sample_comm.h"
xmedia_s32 sample_comm_tp9963_decoder_init(tp9963_chn ch, tp9963_fmt fmt, tp9963_std std)
{
xmedia_u32 tmp;
const xmedia_uchar reg42_43[] = { 0x01, 0x02, 0x00, 0x00, 0x03 };
const xmedia_uchar mask42_43[] = { 0xfe, 0xfd, 0xff, 0xff, 0xfc };
sample_comm_tp_i2c_write(0x40, ch);
sample_comm_tp_i2c_write(0x06, 0x12); // default value
sample_comm_tp_i2c_write(0x50, 0x00); // VIN1/3
sample_comm_tp_i2c_write(0x51, 0x00); //
sample_comm_tp_i2c_write(0x54, 0x03);
if (fmt == TP_FMT_HD25) {
sample_comm_tp_i2c_read(0x42, &tmp);
tmp |= reg42_43[ch];
sample_comm_tp_i2c_write(0x42, tmp);
sample_comm_tp_i2c_read(0x43, &tmp);
tmp &= mask42_43[ch];
sample_comm_tp_i2c_write(0x43, tmp);
sample_comm_tp_i2c_write(0x02, 0x42);
sample_comm_tp_i2c_write(0x07, 0xc0);
sample_comm_tp_i2c_write(0x0b, 0xc0);
sample_comm_tp_i2c_write(0x0c, 0x13);
sample_comm_tp_i2c_write(0x0d, 0x50);
sample_comm_tp_i2c_write(0x15, 0x13);
sample_comm_tp_i2c_write(0x16, 0x15);
sample_comm_tp_i2c_write(0x17, 0x00);
sample_comm_tp_i2c_write(0x18, 0x19);
sample_comm_tp_i2c_write(0x19, 0xd0);
sample_comm_tp_i2c_write(0x1a, 0x25);
sample_comm_tp_i2c_write(0x1c, 0x07); // 1280*720, 25fps
sample_comm_tp_i2c_write(0x1d, 0xbc); // 1280*720, 25fps
sample_comm_tp_i2c_write(0x20, 0x30);
sample_comm_tp_i2c_write(0x21, 0x84);
sample_comm_tp_i2c_write(0x22, 0x36);
sample_comm_tp_i2c_write(0x23, 0x3c);
sample_comm_tp_i2c_write(0x2b, 0x60);
sample_comm_tp_i2c_write(0x2c, 0x2a);
sample_comm_tp_i2c_write(0x2d, 0x30);
sample_comm_tp_i2c_write(0x2e, 0x70);
sample_comm_tp_i2c_write(0x30, 0x48);
sample_comm_tp_i2c_write(0x31, 0xbb);
sample_comm_tp_i2c_write(0x32, 0x2e);
sample_comm_tp_i2c_write(0x33, 0x90);
sample_comm_tp_i2c_write(0x35, 0x25);
sample_comm_tp_i2c_write(0x39, 0x08);
if (std == TP_STD_HDA) {
sample_comm_tp_i2c_write(0x02, 0x46);
sample_comm_tp_i2c_write(0x0d, 0x71);
sample_comm_tp_i2c_write(0x18, 0x1b);
sample_comm_tp_i2c_write(0x20, 0x40);
sample_comm_tp_i2c_write(0x21, 0x46);
sample_comm_tp_i2c_write(0x25, 0xfe);
sample_comm_tp_i2c_write(0x26, 0x01);
sample_comm_tp_i2c_write(0x2c, 0x3a);
sample_comm_tp_i2c_write(0x2d, 0x5a);
sample_comm_tp_i2c_write(0x2e, 0x40);
sample_comm_tp_i2c_write(0x30, 0x9e);
sample_comm_tp_i2c_write(0x31, 0x20);
sample_comm_tp_i2c_write(0x32, 0x10);
sample_comm_tp_i2c_write(0x33, 0x90);
}
} else if (fmt == TP_FMT_HD30) {
sample_comm_tp_i2c_read(0x42, &tmp);
tmp |= reg42_43[ch];
sample_comm_tp_i2c_write(0x42, tmp);
sample_comm_tp_i2c_read(0x43, &tmp);
tmp &= mask42_43[ch];
sample_comm_tp_i2c_write(0x43, tmp);
sample_comm_tp_i2c_write(0x02, 0x42);
sample_comm_tp_i2c_write(0x07, 0xc0);
sample_comm_tp_i2c_write(0x0b, 0xc0);
sample_comm_tp_i2c_write(0x0c, 0x13);
sample_comm_tp_i2c_write(0x0d, 0x50);
sample_comm_tp_i2c_write(0x15, 0x13);
sample_comm_tp_i2c_write(0x16, 0x15);
sample_comm_tp_i2c_write(0x17, 0x00);
sample_comm_tp_i2c_write(0x18, 0x19);
sample_comm_tp_i2c_write(0x19, 0xd0);
sample_comm_tp_i2c_write(0x1a, 0x25);
sample_comm_tp_i2c_write(0x1c, 0x06); // 1280*720, 30fps
sample_comm_tp_i2c_write(0x1d, 0x72); // 1280*720, 30fps
sample_comm_tp_i2c_write(0x20, 0x30);
sample_comm_tp_i2c_write(0x21, 0x84);
sample_comm_tp_i2c_write(0x22, 0x36);
sample_comm_tp_i2c_write(0x23, 0x3c);
sample_comm_tp_i2c_write(0x2b, 0x60);
sample_comm_tp_i2c_write(0x2c, 0x2a);
sample_comm_tp_i2c_write(0x2d, 0x30);
sample_comm_tp_i2c_write(0x2e, 0x70);
sample_comm_tp_i2c_write(0x30, 0x48);
sample_comm_tp_i2c_write(0x31, 0xbb);
sample_comm_tp_i2c_write(0x32, 0x2e);
sample_comm_tp_i2c_write(0x33, 0x90);
sample_comm_tp_i2c_write(0x35, 0x25);
sample_comm_tp_i2c_write(0x39, 0x08);
if (std == TP_STD_HDA) {
sample_comm_tp_i2c_write(0x02, 0x46);
sample_comm_tp_i2c_write(0x0d, 0x70);
sample_comm_tp_i2c_write(0x18, 0x1b);
sample_comm_tp_i2c_write(0x20, 0x40);
sample_comm_tp_i2c_write(0x21, 0x46);
sample_comm_tp_i2c_write(0x25, 0xfe);
sample_comm_tp_i2c_write(0x26, 0x01);
sample_comm_tp_i2c_write(0x2c, 0x3a);
sample_comm_tp_i2c_write(0x2d, 0x5a);
sample_comm_tp_i2c_write(0x2e, 0x40);
sample_comm_tp_i2c_write(0x30, 0x9d);
sample_comm_tp_i2c_write(0x31, 0xca);
sample_comm_tp_i2c_write(0x32, 0x01);
sample_comm_tp_i2c_write(0x33, 0xd0);
}
} else if (fmt == TP_FMT_FHD25) {
sample_comm_tp_i2c_read(0x42, &tmp);
tmp &= mask42_43[ch];
sample_comm_tp_i2c_write(0x42, tmp);
sample_comm_tp_i2c_read(0x43, &tmp);
tmp &= mask42_43[ch];
sample_comm_tp_i2c_write(0x43, tmp);
sample_comm_tp_i2c_write(0x02, 0x40);
sample_comm_tp_i2c_write(0x07, 0xc0);
sample_comm_tp_i2c_write(0x0b, 0xc0);
sample_comm_tp_i2c_write(0x0c, 0x03);
sample_comm_tp_i2c_write(0x0d, 0x50);
sample_comm_tp_i2c_write(0x15, 0x03);
sample_comm_tp_i2c_write(0x16, 0xd2);
sample_comm_tp_i2c_write(0x17, 0x80);
sample_comm_tp_i2c_write(0x18, 0x29);
sample_comm_tp_i2c_write(0x19, 0x38);
sample_comm_tp_i2c_write(0x1a, 0x47);
sample_comm_tp_i2c_write(0x1c, 0x0a); // 1920*1080, 25fps
sample_comm_tp_i2c_write(0x1d, 0x50); //
sample_comm_tp_i2c_write(0x20, 0x30);
sample_comm_tp_i2c_write(0x21, 0x84);
sample_comm_tp_i2c_write(0x22, 0x36);
sample_comm_tp_i2c_write(0x23, 0x3c);
sample_comm_tp_i2c_write(0x2b, 0x60);
sample_comm_tp_i2c_write(0x2c, 0x2a);
sample_comm_tp_i2c_write(0x2d, 0x30);
sample_comm_tp_i2c_write(0x2e, 0x70);
sample_comm_tp_i2c_write(0x30, 0x48);
sample_comm_tp_i2c_write(0x31, 0xbb);
sample_comm_tp_i2c_write(0x32, 0x2e);
sample_comm_tp_i2c_write(0x33, 0x90);
sample_comm_tp_i2c_write(0x35, 0x05);
sample_comm_tp_i2c_write(0x39, 0x0C);
if (std == TP_STD_HDA) {
sample_comm_tp_i2c_write(0x02, 0x44);
sample_comm_tp_i2c_write(0x0d, 0x73);
sample_comm_tp_i2c_write(0x15, 0x01);
sample_comm_tp_i2c_write(0x16, 0xf0);
sample_comm_tp_i2c_write(0x18, 0x2a);
sample_comm_tp_i2c_write(0x20, 0x3c);
sample_comm_tp_i2c_write(0x21, 0x46);
sample_comm_tp_i2c_write(0x25, 0xfe);
sample_comm_tp_i2c_write(0x26, 0x0d);
sample_comm_tp_i2c_write(0x2c, 0x3a);
sample_comm_tp_i2c_write(0x2d, 0x54);
sample_comm_tp_i2c_write(0x2e, 0x40);
sample_comm_tp_i2c_write(0x30, 0xa5);
sample_comm_tp_i2c_write(0x31, 0x86);
sample_comm_tp_i2c_write(0x32, 0xfb);
sample_comm_tp_i2c_write(0x33, 0x60);
}
} else if (fmt == TP_FMT_FHD30) {
sample_comm_tp_i2c_read(0x42, &tmp);
tmp &= mask42_43[ch];
sample_comm_tp_i2c_write(0x42, tmp);
sample_comm_tp_i2c_read(0x43, &tmp);
tmp &= mask42_43[ch];
sample_comm_tp_i2c_write(0x43, tmp);
sample_comm_tp_i2c_write(0x02, 0x40);
sample_comm_tp_i2c_write(0x07, 0xc0);
sample_comm_tp_i2c_write(0x0b, 0xc0);
sample_comm_tp_i2c_write(0x0c, 0x03);
sample_comm_tp_i2c_write(0x0d, 0x50);
sample_comm_tp_i2c_write(0x15, 0x03);
sample_comm_tp_i2c_write(0x16, 0xd2);
sample_comm_tp_i2c_write(0x17, 0x80);
sample_comm_tp_i2c_write(0x18, 0x29);
sample_comm_tp_i2c_write(0x19, 0x38);
sample_comm_tp_i2c_write(0x1a, 0x47);
sample_comm_tp_i2c_write(0x1c, 0x08); // 1920*1080, 30fps
sample_comm_tp_i2c_write(0x1d, 0x98); //
sample_comm_tp_i2c_write(0x20, 0x30);
sample_comm_tp_i2c_write(0x21, 0x84);
sample_comm_tp_i2c_write(0x22, 0x36);
sample_comm_tp_i2c_write(0x23, 0x3c);
sample_comm_tp_i2c_write(0x2b, 0x60);
sample_comm_tp_i2c_write(0x2c, 0x2a);
sample_comm_tp_i2c_write(0x2d, 0x30);
sample_comm_tp_i2c_write(0x2e, 0x70);
sample_comm_tp_i2c_write(0x30, 0x48);
sample_comm_tp_i2c_write(0x31, 0xbb);
sample_comm_tp_i2c_write(0x32, 0x2e);
sample_comm_tp_i2c_write(0x33, 0x90);
sample_comm_tp_i2c_write(0x35, 0x05);
sample_comm_tp_i2c_write(0x39, 0x0C);
if (std == TP_STD_HDA) {
sample_comm_tp_i2c_write(0x02, 0x44);
sample_comm_tp_i2c_write(0x0d, 0x72);
sample_comm_tp_i2c_write(0x15, 0x01);
sample_comm_tp_i2c_write(0x16, 0xf0);
sample_comm_tp_i2c_write(0x18, 0x2a);
sample_comm_tp_i2c_write(0x20, 0x38);
sample_comm_tp_i2c_write(0x21, 0x46);
sample_comm_tp_i2c_write(0x25, 0xfe);
sample_comm_tp_i2c_write(0x26, 0x0d);
sample_comm_tp_i2c_write(0x2c, 0x3a);
sample_comm_tp_i2c_write(0x2d, 0x54);
sample_comm_tp_i2c_write(0x2e, 0x40);
sample_comm_tp_i2c_write(0x30, 0xa5);
sample_comm_tp_i2c_write(0x31, 0x95);
sample_comm_tp_i2c_write(0x32, 0xe0);
sample_comm_tp_i2c_write(0x33, 0x60);
}
} else if (fmt == TP_FMT_QHD25) {
sample_comm_tp_i2c_read(0x42, &tmp);
tmp &= mask42_43[ch];
sample_comm_tp_i2c_write(0x42, tmp);
sample_comm_tp_i2c_read(0x43, &tmp);
tmp &= mask42_43[ch];
sample_comm_tp_i2c_write(0x43, tmp);
sample_comm_tp_i2c_write(0x02, 0x50);
sample_comm_tp_i2c_write(0x07, 0xc0);
sample_comm_tp_i2c_write(0x0b, 0xc0);
sample_comm_tp_i2c_write(0x0c, 0x03);
sample_comm_tp_i2c_write(0x0d, 0x50);
sample_comm_tp_i2c_write(0x15, 0x23);
sample_comm_tp_i2c_write(0x16, 0x1b);
sample_comm_tp_i2c_write(0x17, 0x00);
sample_comm_tp_i2c_write(0x18, 0x38);
sample_comm_tp_i2c_write(0x19, 0xa0);
sample_comm_tp_i2c_write(0x1a, 0x5a);
sample_comm_tp_i2c_write(0x1c, 0x0f); //2560*1440, 25fps
sample_comm_tp_i2c_write(0x1d, 0x76); //
sample_comm_tp_i2c_write(0x20, 0x50);
sample_comm_tp_i2c_write(0x21, 0x84);
sample_comm_tp_i2c_write(0x22, 0x36);
sample_comm_tp_i2c_write(0x23, 0x3c);
sample_comm_tp_i2c_write(0x27, 0xad);
sample_comm_tp_i2c_write(0x2b, 0x60);
sample_comm_tp_i2c_write(0x2c, 0x2a);
sample_comm_tp_i2c_write(0x2d, 0x58);
sample_comm_tp_i2c_write(0x2e, 0x70);
sample_comm_tp_i2c_write(0x30, 0x74);
sample_comm_tp_i2c_write(0x31, 0x58);
sample_comm_tp_i2c_write(0x32, 0x9f);
sample_comm_tp_i2c_write(0x33, 0x60);
sample_comm_tp_i2c_write(0x35, 0x15);
sample_comm_tp_i2c_write(0x36, 0xdc);
sample_comm_tp_i2c_write(0x38, 0x40);
sample_comm_tp_i2c_write(0x39, 0x48);
if (std == TP_STD_HDA) {
sample_comm_tp_i2c_read(0x14, &tmp);
tmp &= 0x9f;
sample_comm_tp_i2c_write(0x14, tmp);
sample_comm_tp_i2c_write(0x13, 0x00);
sample_comm_tp_i2c_write(0x15, 0x23);
sample_comm_tp_i2c_write(0x16, 0x16);
sample_comm_tp_i2c_write(0x18, 0x32);
sample_comm_tp_i2c_write(0x1c, 0x8f);
sample_comm_tp_i2c_write(0x1d, 0x76);
sample_comm_tp_i2c_write(0x0d, 0x70);
sample_comm_tp_i2c_write(0x20, 0x80);
sample_comm_tp_i2c_write(0x21, 0x86);
sample_comm_tp_i2c_write(0x22, 0x36);
sample_comm_tp_i2c_write(0x2b, 0x60);
sample_comm_tp_i2c_write(0x2d, 0xa0);
sample_comm_tp_i2c_write(0x2e, 0x40);
sample_comm_tp_i2c_write(0x30, 0x48);
sample_comm_tp_i2c_write(0x31, 0x6f);
sample_comm_tp_i2c_write(0x32, 0xb5);
sample_comm_tp_i2c_write(0x33, 0x80);
sample_comm_tp_i2c_write(0x39, 0x40);
}
} else {
SAMPLE_PRT("Unsupported fmt %d\n", fmt);
return XMEDIA_FAILURE;
}
sample_comm_tp_i2c_read(0x06, &tmp);
tmp |= 0x80;
sample_comm_tp_i2c_write(0x06, tmp);
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_tp9963_set_mipi_mode(tp9963_mipi_mode mode)
{
// mipi setting
sample_comm_tp_i2c_write(0x40, TP_CH_MIPI_PAGE); // MIPI page
sample_comm_tp_i2c_write(0x02, 0x78);
sample_comm_tp_i2c_write(0x03, 0x70);
sample_comm_tp_i2c_write(0x04, 0x70);
sample_comm_tp_i2c_write(0x05, 0x70);
sample_comm_tp_i2c_write(0x06, 0x70);
sample_comm_tp_i2c_write(0x13, 0xef);
sample_comm_tp_i2c_write(0x20, 0x00);
sample_comm_tp_i2c_write(0x21, 0x22);
sample_comm_tp_i2c_write(0x22, 0x30);
sample_comm_tp_i2c_write(0x23, 0x9e);
// colorbar
// sample_comm_tp_i2c_write(0x20, 0x80); // TP_ENA, Test function to enable BT.1120 test pattern output to mipi module
if (mode == TP_MIPI_MODE_2CH2LANE_594M) {
sample_comm_tp_i2c_write(0x21, 0x22);
sample_comm_tp_i2c_write(0x14, 0x00);
sample_comm_tp_i2c_write(0x15, 0x01);
sample_comm_tp_i2c_write(0x2a, 0x08);
sample_comm_tp_i2c_write(0x2b, 0x08);
sample_comm_tp_i2c_write(0x2c, 0x10);
sample_comm_tp_i2c_write(0x2e, 0x0a);
sample_comm_tp_i2c_write(0x10, 0xa0);
sample_comm_tp_i2c_write(0x10, 0x20);
} else if (mode == TP_MIPI_MODE_1CH2LANE_594M) {
sample_comm_tp_i2c_write(0x21, 0x12);
sample_comm_tp_i2c_write(0x14, 0x00);
sample_comm_tp_i2c_write(0x15, 0x01);
sample_comm_tp_i2c_write(0x2a, 0x08);
sample_comm_tp_i2c_write(0x2b, 0x08);
sample_comm_tp_i2c_write(0x2c, 0x10);
sample_comm_tp_i2c_write(0x2e, 0x0a);
sample_comm_tp_i2c_write(0x10, 0xa0);
sample_comm_tp_i2c_write(0x10, 0x20);
} else if (mode == TP_MIPI_MODE_2CH2LANE_297M) {
sample_comm_tp_i2c_write(0x21, 0x22);
sample_comm_tp_i2c_write(0x14, 0x41);
sample_comm_tp_i2c_write(0x15, 0x02);
sample_comm_tp_i2c_write(0x2a, 0x04);
sample_comm_tp_i2c_write(0x2b, 0x03);
sample_comm_tp_i2c_write(0x2c, 0x09);
sample_comm_tp_i2c_write(0x2e, 0x02);
sample_comm_tp_i2c_write(0x10, 0xa0);
sample_comm_tp_i2c_write(0x10, 0x20);
} else if (mode == TP_MIPI_MODE_1CH2LANE_297M) {
sample_comm_tp_i2c_write(0x21, 0x12);
sample_comm_tp_i2c_write(0x14, 0x41);
sample_comm_tp_i2c_write(0x15, 0x02);
sample_comm_tp_i2c_write(0x2a, 0x04);
sample_comm_tp_i2c_write(0x2b, 0x03);
sample_comm_tp_i2c_write(0x2c, 0x09);
sample_comm_tp_i2c_write(0x2e, 0x02);
sample_comm_tp_i2c_write(0x10, 0xa0);
sample_comm_tp_i2c_write(0x10, 0x20);
} else if (mode == TP_MIPI_MODE_2CH4LANE_594M) {
sample_comm_tp_i2c_write(0x21, 0x24);
sample_comm_tp_i2c_write(0x14, 0x00);
sample_comm_tp_i2c_write(0x15, 0x00);
sample_comm_tp_i2c_write(0x2a, 0x08);
sample_comm_tp_i2c_write(0x2b, 0x08);
sample_comm_tp_i2c_write(0x2c, 0x10);
sample_comm_tp_i2c_write(0x2e, 0x0a);
sample_comm_tp_i2c_write(0x10, 0xa0);
sample_comm_tp_i2c_write(0x10, 0x20);
} else if (mode == TP_MIPI_MODE_2CH4LANE_297M) {
sample_comm_tp_i2c_write(0x21, 0x24);
sample_comm_tp_i2c_write(0x14, 0x41);
sample_comm_tp_i2c_write(0x15, 0x01);
sample_comm_tp_i2c_write(0x2a, 0x04);
sample_comm_tp_i2c_write(0x2b, 0x03);
sample_comm_tp_i2c_write(0x2c, 0x09);
sample_comm_tp_i2c_write(0x2e, 0x02);
sample_comm_tp_i2c_write(0x10, 0xa0);
sample_comm_tp_i2c_write(0x10, 0x20);
} else if (mode == TP_MIPI_MODE_1CH4LANE_297M) {
sample_comm_tp_i2c_write(0x21, 0x14);
sample_comm_tp_i2c_write(0x14, 0x41);
sample_comm_tp_i2c_write(0x15, 0x01);
sample_comm_tp_i2c_write(0x2a, 0x04);
sample_comm_tp_i2c_write(0x2b, 0x03);
sample_comm_tp_i2c_write(0x2c, 0x09);
sample_comm_tp_i2c_write(0x2e, 0x02);
sample_comm_tp_i2c_write(0x10, 0xa0);
sample_comm_tp_i2c_write(0x10, 0x20);
} else if (mode == TP_MIPI_MODE_2CH2LANE_432M) {
sample_comm_tp_i2c_write(0x21, 0x22);
sample_comm_tp_i2c_write(0x13, 0x0f);
sample_comm_tp_i2c_write(0x12, 0x5e);
sample_comm_tp_i2c_write(0x14, 0x00);
sample_comm_tp_i2c_write(0x15, 0x01);
sample_comm_tp_i2c_write(0x2a, 0x06);
sample_comm_tp_i2c_write(0x2b, 0x05);
sample_comm_tp_i2c_write(0x2c, 0x0d);
sample_comm_tp_i2c_write(0x2e, 0x0a);
sample_comm_tp_i2c_write(0x10, 0xa0);
sample_comm_tp_i2c_write(0x10, 0x20);
} else if (mode == TP_MIPI_MODE_2CH4LANE_216M) {
sample_comm_tp_i2c_write(0x21, 0x24);
sample_comm_tp_i2c_write(0x13, 0x0f);
sample_comm_tp_i2c_write(0x12, 0x5e);
sample_comm_tp_i2c_write(0x14, 0x41);
sample_comm_tp_i2c_write(0x15, 0x01);
sample_comm_tp_i2c_write(0x2a, 0x06);
sample_comm_tp_i2c_write(0x2b, 0x05);
sample_comm_tp_i2c_write(0x2c, 0x0d);
sample_comm_tp_i2c_write(0x2e, 0x0a);
sample_comm_tp_i2c_write(0x10, 0xa0);
sample_comm_tp_i2c_write(0x10, 0x20);
} else if (mode == TP_MIPI_MODE_2CH2LANE_445M) {
sample_comm_tp_i2c_write(0x21, 0x22);
sample_comm_tp_i2c_write(0x13, 0x07);
sample_comm_tp_i2c_write(0x12, 0x5f);
sample_comm_tp_i2c_write(0x14, 0x00);
sample_comm_tp_i2c_write(0x15, 0x01);
sample_comm_tp_i2c_write(0x2a, 0x06);
sample_comm_tp_i2c_write(0x2b, 0x05);
sample_comm_tp_i2c_write(0x2c, 0x0d);
sample_comm_tp_i2c_write(0x2e, 0x0a);
sample_comm_tp_i2c_write(0x10, 0xa0);
sample_comm_tp_i2c_write(0x10, 0x20);
} else {
SAMPLE_PRT("Unsupported mipi mode %d\n", mode);
return XMEDIA_FAILURE;
}
/* Enable MIPI CSI2 output */
sample_comm_tp_i2c_write(0x28, 0x02);
sample_comm_tp_i2c_write(0x28, 0x00);
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_tp9963_init(sample_comm_tp9963_cfg *cfg)
{
xmedia_s32 i;
xmedia_s32 ret;
ret = sample_comm_tp_i2c_init(cfg->i2c_dev);
if (ret != XMEDIA_SUCCESS) {
return ret;
}
for (i = 0; i < TP_MAX_CHN; i++) {
if (cfg->chn[i] != TP_CH_1 && cfg->chn[i] != TP_CH_2 && cfg->chn[i] != TP_CH_ALL) {
continue;
}
ret = sample_comm_tp9963_decoder_init(cfg->chn[i], cfg->fmt[i], cfg->std[i]);
if (ret != XMEDIA_SUCCESS) {
return ret;
}
}
ret = sample_comm_tp9963_set_mipi_mode(cfg->mipi_mode);
if (ret != XMEDIA_SUCCESS) {
return ret;
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_tp9963_deinit(xmedia_void)
{
/* Disable MIPI CSI2 output */
sample_comm_tp_i2c_write(0x40, TP_CH_MIPI_PAGE);
sample_comm_tp_i2c_write(0x28, 0x00);
sample_comm_tp_i2c_write(0x28, 0x02);
sample_comm_tp_i2c_exit();
return XMEDIA_SUCCESS;
}
sample/common/sample_comm_tp.h
Executable
+72
View File
@@ -0,0 +1,72 @@
#ifndef __TP9963_MIPI_H__
#define __TP9963_MIPI_H__
#include "xmedia_type.h"
#include "sample_comm_tp_i2c.h"
#define TP_MAX_CHN 2
typedef enum {
TP_CH_1 = 0,
TP_CH_2 = 1,
TP_CH_ALL = 4,
TP_CH_MIPI_PAGE = 8,
TP_CH_MAX,
} tp9963_chn;
typedef enum {
TP_FMT_PAL = 0, // 720x288i
TP_FMT_NTSC, // 720x240i
TP_FMT_HD25, // 1280x720
TP_FMT_HD30, // 1280x720
TP_FMT_FHD25, // 1920x1080
TP_FMT_FHD30, // 1920x1080
TP_FMT_QHD25, // 2560x1440
TP_FMT_QHD30, // 2560x1440
TP_FMT_QHD275, // 2560X1440 27.5fps
TP_FMT_FHD50, // 1920x1080
TP_FMT_FHD60, // 1920x1080
TP_FMT_5M20, //
TP_FMT_FHD275, // 1080P27.5
TP_FMT_FHD28, // 1920X1080, 2200X1205
TP_FMT_F_UVGA30, // FH 1280x960p30, must use with MIPI_2CH2LANE_432M
TP_FMT_QHD25_4A10, // total
TP_FMT_FHD59, // 1920x1080,Nonsatandard total 2200x1144
TP_FMT_UVGA30, // 1280x960p30, must use with MIPI_2CH2LANE_445M
TP_FMT_HD50,
TP_FMT_HD60,
TP_FMT_MAX,
} tp9963_fmt;
typedef enum {
TP_STD_TVI = 0, // TVI
TP_STD_HDA, // AHD
TP_STD_MAX,
} tp9963_std;
typedef enum {
TP_MIPI_MODE_2CH2LANE_594M = 0, // up to 2x1080p25/30
TP_MIPI_MODE_2CH2LANE_297M, // up to 2x720p25/30
TP_MIPI_MODE_2CH4LANE_594M, // up to 2x1080p50/60
TP_MIPI_MODE_2CH4LANE_297M, // up to 2x1080p25/30
TP_MIPI_MODE_2CH2LANE_432M, // only for 2xF_UVGA30
TP_MIPI_MODE_1CH2LANE_594M, // up to 1xQHD30
TP_MIPI_MODE_1CH2LANE_297M, // up to 1x1080P30
TP_MIPI_MODE_1CH4LANE_297M, // up to 1xQHD30
TP_MIPI_MODE_2CH4LANE_216M, // only for 2xF_UVGA30
TP_MIPI_MODE_2CH2LANE_445M, // only for 2xUVGA30
TP_MIPI_MODE_MAX,
} tp9963_mipi_mode;
typedef struct {
xmedia_u32 i2c_dev;
tp9963_chn chn[TP_MAX_CHN];
tp9963_fmt fmt[TP_MAX_CHN];
tp9963_std std[TP_MAX_CHN];
tp9963_mipi_mode mipi_mode;
} sample_comm_tp9963_cfg;
xmedia_s32 sample_comm_tp9963_init(sample_comm_tp9963_cfg *cfg);
xmedia_s32 sample_comm_tp9963_deinit(xmedia_void);
#endif
sample/common/sample_comm_tp_i2c.c
Executable
+147
View File
@@ -0,0 +1,147 @@
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/i2c-dev.h>
#include <linux/fb.h>
#include <sys/stat.h>
#include "osal.h"
#include "sample_comm_tp_i2c.h"
#include "sample_comm.h"
#include "xmedia_errcode.h"
#define TP9963_I2C_ADDR 0x88
#define TP9963_ADDR_BYTE 1
#define TP9963_DATA_BYTE 1
#define INVALID_FD (-1)
static xmedia_s32 g_i2c_fd = INVALID_FD;
xmedia_s32 sample_comm_tp_i2c_init(xmedia_u32 dev)
{
xmedia_s32 ret;
xmedia_char i2c_dev_file[16];
snprintf(i2c_dev_file, sizeof(i2c_dev_file), "/dev/i2c-%u", dev);
g_i2c_fd = open(i2c_dev_file, O_RDWR, S_IRUSR | S_IWUSR);
if (g_i2c_fd < 0) {
SAMPLE_PRT("Open /dev/i2c-%u error!\n", dev);
return XMEDIA_ERRCODE_OPEN_FAILED;
}
ret = ioctl(g_i2c_fd, I2C_SLAVE_FORCE, (TP9963_I2C_ADDR >> 1));
if (ret < 0) {
SAMPLE_PRT("I2C_SLAVE_FORCE error!\n");
close(g_i2c_fd);
g_i2c_fd = INVALID_FD;
return ret;
}
SAMPLE_PRT("====== i2c[%d] init success!=======\n", dev);
return XMEDIA_SUCCESS;
}
xmedia_void sample_comm_tp_i2c_exit(xmedia_void)
{
if (g_i2c_fd >= 0) {
close(g_i2c_fd);
g_i2c_fd = INVALID_FD;
}
}
xmedia_s32 sample_comm_tp_i2c_read(xmedia_u32 addr, xmedia_u32 *data)
{
xmedia_s32 ret;
xmedia_u8 recv_buf[4];
struct i2c_rdwr_ioctl_data ioctl_data;
struct i2c_msg msg[2];
xmedia_u32 i2c_addr = (TP9963_I2C_ADDR >> 1);
if (g_i2c_fd < 0) {
SAMPLE_PRT("i2c is not init!\n");
return XMEDIA_ERRCODE_NOT_INIT;
}
memset(recv_buf, 0x0, sizeof(recv_buf));
memset(&ioctl_data, 0x0, sizeof(ioctl_data));
memset(msg, 0x0, sizeof(msg[0]));
msg[0].addr = i2c_addr;
msg[0].flags = 0;
msg[0].len = TP9963_ADDR_BYTE;
msg[0].buf = recv_buf;
msg[1].addr = i2c_addr;
msg[1].flags = 0;
msg[1].flags |= I2C_M_RD;
msg[1].len = TP9963_DATA_BYTE;
msg[1].buf = recv_buf;
ioctl_data.msgs = &msg[0];
ioctl_data.nmsgs = 2;
if (TP9963_ADDR_BYTE == 2) {
recv_buf[0] = (addr >> 8) & 0xff;
recv_buf[1] = addr & 0xff;
} else {
recv_buf[0] = addr & 0xff;
}
ret = ioctl(g_i2c_fd, I2C_RDWR, &ioctl_data);
if (ret < 0) {
SAMPLE_PRT("tp9963 i2c read failed!\n");
return XMEDIA_FAILURE;
}
if (TP9963_DATA_BYTE == 2) {
*data = recv_buf[0] | (recv_buf[1] << 8);
} else {
*data = recv_buf[0];
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_tp_i2c_write(xmedia_u32 addr, xmedia_u32 data)
{
xmedia_u32 idx = 0;
xmedia_s32 ret;
xmedia_u8 buf[8];
if (g_i2c_fd < 0) {
SAMPLE_PRT("i2c is not init!\n");
return XMEDIA_ERRCODE_NOT_INIT;
}
if (TP9963_ADDR_BYTE == 2) {
buf[idx] = (addr >> 8) & 0xff;
idx++;
buf[idx] = addr & 0xff;
idx++;
} else {
buf[idx] = addr & 0xff;
idx++;
}
if (TP9963_DATA_BYTE == 2) {
buf[idx] = (data >> 8) & 0xff;
idx++;
buf[idx] = data & 0xff;
idx++;
} else {
buf[idx] = data & 0xff;
idx++;
}
ret = write(g_i2c_fd, buf, TP9963_ADDR_BYTE + TP9963_DATA_BYTE);
if (ret < 0) {
SAMPLE_PRT("tp9963 i2c write failed!\n");
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
sample/common/sample_comm_tp_i2c.h
Executable
+11
View File
@@ -0,0 +1,11 @@
#ifndef __TP_I2C_H__
#define __TP_I2C_H__
#include "xmedia_type.h"
xmedia_s32 sample_comm_tp_i2c_init(xmedia_u32 dev);
xmedia_void sample_comm_tp_i2c_exit(xmedia_void);
xmedia_s32 sample_comm_tp_i2c_read(xmedia_u32 addr, xmedia_u32 *data);
xmedia_s32 sample_comm_tp_i2c_write(xmedia_u32 addr, xmedia_u32 data);
#endif
sample/common/sample_comm_venc.c
Executable
+2134
View File
File diff suppressed because it is too large Load Diff
sample/common/sample_comm_venc.h
+225
View File
@@ -0,0 +1,225 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_VENC_H__
#define __SAMPLE_COMM_VENC_H__
#include "xmedia_type.h"
#include "xmedia_sys.h"
#include "xmedia_vb.h"
#include "xmedia_venc.h"
#include "xmedia_vpss.h"
#include "xmedia_mmz.h"
#ifdef __cplusplus
extern "C" {
#endif
#define VENC_FILE_PATH_SIZE (128)
#define VENC_JPEG_SPLICING_MAX_VER_CNT (8)
typedef union
{
/* Define the struct bits */
struct
{
xmedia_s32 weight1 : 4; /* [0:3] */
xmedia_s32 weight2 : 4; /* [4:7] */
} bits;
/* Define an unsigned member */
xmedia_u8 u8;
} skip_wight_value;
typedef struct
{
xmedia_bool thread_start;
xmedia_s32 vpss_pipe;
xmedia_s32 vpss_chn[VPSS_MAX_PHY_OCHN_NUM];
xmedia_s32 venc_chn[VENC_MAX_CHN_NUM];
xmedia_s32 chn_cnt;
xmedia_video_size size[VENC_MAX_CHN_NUM];
} sample_venc_qpmap_sendfrm_para;
typedef struct sample_venc_getstream_para
{
xmedia_bool thread_start;
xmedia_s32 venc_chn[VENC_MAX_CHN_NUM];
xmedia_s32 cnt;
xmedia_s32 save_stream;
xmedia_bool save_jpeg;
xmedia_char save_path[VENC_FILE_PATH_SIZE];
xmedia_u32 stream_timeout_cnt;
} sample_venc_getstream_para;
typedef struct sample_venc_jpeg_slice
{
xmedia_bool slice_enable;
xmedia_bool by_frame;
} sample_venc_jpeg_slice;
typedef struct sample_venc_vui_info
{
xmedia_bool vui_en;
xmedia_u32 stream_display_fps;
} sample_venc_vui_info;
typedef struct sample_venc_chn_info
{
xmedia_bool venc_en;
xmedia_s32 venc_chn;
xmedia_payload_type payload_type;
xmedia_u32 width;
xmedia_u32 height;
xmedia_venc_rc_mode rc_mode;
xmedia_u32 profile;
xmedia_venc_gop_attr venc_gop_attr;
xmedia_bool use_default_gop_attr;
xmedia_bool rcn_ref_share_buf;
xmedia_venc_attr_jpeg jpeg_attr;
xmedia_u32 src_frame_rate;
xmedia_u32 dst_frame_rate;
xmedia_bool support_dcf;
xmedia_u32 mpf_cnt;
sample_venc_jpeg_slice jpeg_slice;
sample_venc_vui_info vui_info;
xmedia_u32 str_buffer_size;
}sample_venc_chn_info;
typedef enum {
SAMPLE_RC_CBR = 0,
SAMPLE_RC_VBR,
SAMPLE_RC_AVBR,
SAMPLE_RC_QPMAP,
SAMPLE_RC_FIXQP,
} sample_rc;
typedef struct {
sample_venc_chn_info chn_info[VENC_MAX_CHN_NUM];
}sample_venc_config;
typedef struct {
xmedia_u32 src_width;
xmedia_u32 src_height;
xmedia_u32 dst_width;
xmedia_u32 dst_height;
xmedia_u32 enc_width;
xmedia_u32 enc_height;
xmedia_u32 row_cnt;
xmedia_u32 col_cnt;
xmedia_u32 vb_block;
xmedia_u32 vb_pool;
xmedia_u32 pool_id;
xmedia_u64 phy_addr;
xmedia_u8 *vir_addr;
xmedia_u32 vb_size;
xmedia_u32 tmp_data_start[VENC_JPEG_SPLICING_MAX_VER_CNT];
xmedia_u32 tmp_data_offset[VENC_JPEG_SPLICING_MAX_VER_CNT];
xmedia_u32 tmp_data_len[VENC_JPEG_SPLICING_MAX_VER_CNT];
xmedia_u8 *tmp_data[VENC_JPEG_SPLICING_MAX_VER_CNT];
xmedia_video_private_info priv_vb_info;
} sample_venc_splicing_info;
typedef struct
{
xmedia_s32 vpss_pipe;
xmedia_s32 vpss_chn;
xmedia_s32 venc_chn;
xmedia_char save_path[64];
sample_venc_splicing_info splicing_info;
} sample_venc_splicing_para;
typedef struct {
xmedia_u32 pool;
FILE *input_yuv[10];
pthread_t user_send_yuv_thread;
xmedia_video_pixel_format user_pixel_format;
xmedia_video_format user_video_format;
xmedia_video_compress_mode user_compress_mode;
xmedia_u32 max_send_yuv_cnt;
xmedia_u32 user_width;
xmedia_u32 user_height;
xmedia_u32 yuv_num; // YUV source file number
xmedia_char ch_yuv_path[128];
xmedia_char ch_yuv_name[10][128];
xmedia_u32 h264e_cnt;
xmedia_u32 h264e_chnl[VENC_MAX_CHN_NUM];
xmedia_u32 h265e_cnt;
xmedia_u32 h265e_chnl[VENC_MAX_CHN_NUM];
xmedia_u32 mjpeg_cnt;
xmedia_u32 mjpeg_chnl[VENC_MAX_CHN_NUM];
xmedia_u32 jpege_cnt;
xmedia_u32 jpege_chnl[VENC_MAX_CHN_NUM];
xmedia_u32 user_send_yuv_delay_ms;
}sample_venc_yuv_thread_para;
typedef struct {
xmedia_u32 block;
xmedia_u32 pool;
xmedia_u32 pool_id;
xmedia_u64 phy_addr;
xmedia_u8 *vir_addr;
xmedia_u32 size;
xmedia_s32 dev;
} sample_venc_mem_buf_info;
xmedia_s32 sample_comm_venc_get_file_post_fix(xmedia_payload_type payload, xmedia_char *file_post_fix);
xmedia_s32 sample_comm_venc_start_chn(xmedia_s32 venc_chn);
xmedia_s32 sample_comm_venc_stop_chn(xmedia_s32 venc_chn);
xmedia_s32 sample_comm_venc_get_default_gop_attr(xmedia_venc_gop_mode gop_mode, xmedia_venc_gop_attr *gop_attr);
xmedia_void sample_comm_venc_get_default_chn_info(xmedia_video_size res,xmedia_u32 framerate,sample_venc_chn_info *chn_info);
xmedia_s32 sample_comm_venc_set_rc_param(xmedia_s32 venc_chn);
xmedia_s32 sample_comm_venc_create_chn(sample_venc_chn_info *chn_param);
xmedia_s32 sample_comm_venc_destory_chn(xmedia_s32 venc_chn);
xmedia_s32 sample_comm_venc_start(sample_venc_config *venc_cfg);
xmedia_s32 sample_comm_venc_stop(sample_venc_config *venc_cfg);
xmedia_s32 sample_comm_venc_set_jpeg_exif(xmedia_s32 venc_chn);
xmedia_s32 sample_comm_venc_save_jpeg_stream(xmedia_s32 chn,FILE* fd, xmedia_venc_stream* pst_stream , xmedia_u32 recv_cnt, char *save_path);
xmedia_s32 sample_comm_venc_save_jpeg_thum(xmedia_char *result_path, xmedia_venc_stream* stream_pack, xmedia_u32 chn, xmedia_u32 recv_cnt);
xmedia_s32 sample_comm_venc_capture_jpeg(xmedia_s32 venc_chn, xmedia_s32 snap_cnt, xmedia_bool save_jpeg, xmedia_bool save_thumbnail, xmedia_char *save_path);
xmedia_s32 sample_comm_venc_start_get_stream(xmedia_s32 venc_chn[], xmedia_s32 cnt, xmedia_bool stream_no_save, xmedia_bool jpeg_no_save, xmedia_char *save_path);
xmedia_s32 sample_comm_venc_stop_get_stream(void);
xmedia_void *sample_comm_venc_user_send_thread(void *data);
xmedia_s32 sample_comm_venc_qpmap_sendfrm(xmedia_s32 pipe,xmedia_s32 vpss_chn[],xmedia_s32 venc_chn[],xmedia_s32 cnt, xmedia_video_size vpss_size[]);
xmedia_s32 sample_comm_venc_stop_send_qpmapfrm(xmedia_void);
xmedia_s32 sample_comm_venc_splicing_proc(sample_venc_splicing_para *splicing_para);
xmedia_s32 sample_comm_venc_set_roi(xmedia_s32 venc_chn[], xmedia_s32 chn_cnt);
xmedia_s32 sample_comm_venc_init(xmedia_void);
xmedia_s32 sample_comm_venc_exit(xmedia_void);
xmedia_s32 sample_comm_venc_set_fps_to_stream(sample_venc_chn_info *chn_param);
#ifdef __cplusplus
}
#endif
#endif
sample/common/sample_comm_vgs.c
Executable
+29
View File
@@ -0,0 +1,29 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "xmedia_type.h"
#include "xmedia_debug.h"
#include "xmedia_vgs.h"
#include "sample_comm.h"
xmedia_s32 sample_comm_vgs_init(xmedia_void)
{
return xmedia_vgs_init();
}
xmedia_void sample_comm_vgs_exit(xmedia_void)
{
xmedia_vgs_exit();
}
sample/common/sample_comm_vgs.h
Executable
+26
View File
@@ -0,0 +1,26 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_VGS_H__
#define __SAMPLE_COMM_VGS_H__
#include "xmedia_type.h"
#include "xmedia_sys.h"
#include "xmedia_vgs.h"
#ifdef __cplusplus
extern "C" {
#endif
xmedia_s32 sample_comm_vgs_init(xmedia_void);
xmedia_void sample_comm_vgs_exit(xmedia_void);
#ifdef __cplusplus
}
#endif
#endif
sample/common/sample_comm_vi.c
Executable
+1633
View File
File diff suppressed because it is too large Load Diff
sample/common/sample_comm_vi.h
Executable
+162
View File
@@ -0,0 +1,162 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_VI_H__
#define __SAMPLE_COMM_VI_H__
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "xmedia_sys.h"
#include "xmedia_type.h"
#include "xmedia_vi.h"
#include "xmedia_video_common.h"
#ifdef __cplusplus
extern "C" {
#endif
#define VI_DEV_BIND_PIPE_NUM 2
#define VI_ALIGN 16
#define VI_MAX_STITCH_WDR_PIPE_NUM 4
typedef struct {
xmedia_u32 width;
xmedia_u32 height;
xmedia_video_pixel_format pixel_format;
xmedia_video_wdr_mode wdr_mode;
xmedia_video_wdr_format wdr_format;
xmedia_video_data_width bit_width;
xmedia_intf_type intf_type;
xmedia_vi_mipi_lane_divide_mode lane_mode;
} vi_sensor_info;
typedef struct {
xmedia_s32 pipe[VI_DEV_BIND_PIPE_NUM];
} vi_dev_bind_pipe_info;
typedef struct {
xmedia_bool grp_en;
xmedia_s32 grp;
xmedia_vi_grp_config grp_config;
} vi_grp_info;
typedef struct {
xmedia_bool chn_en;
xmedia_s32 chn_no;
xmedia_vi_lowdelay_attr lowdelay_attr;
xmedia_vi_chn_config chn_config;
xmedia_vi_ext_chn_config ext_chn_config;
} vi_chn_info;
typedef struct {
xmedia_bool dev_en;
xmedia_bool dev_i2c_en;
xmedia_u32 dev_i2c_addr; // 多路相同sensor，设置的i2c地址
xmedia_s32 dev_no;
xmedia_u32 i2c_id; // sensor使用的i2c编号
xmedia_u32 sns_clk_id; // sensor使用的clk编号
xmedia_vi_dev_config dev_config;
xmedia_bool mipi_phy_en; // mipi phy手动速率配置使能
xmedia_vi_dev_mipi_phy_config mipi_phy_config;
sample_comm_sensor_type sensor_type;
} vi_dev_info;
typedef struct {
xmedia_bool pipe_en;
xmedia_bool vc_en;
xmedia_s32 pipe_no;
xmedia_u32 vc_num;
xmedia_vi_frame_dump_attr dump_attr;
xmedia_vi_pipe_config pipe_config;
xmedia_vi_lowdelay_attr lowdelay_attr;
vi_chn_info chn_info[VI_MAX_CHN_NUM];
xmedia_bool ainr_en;
xmedia_video_data_width ainr_model_bitwidth;
} vi_pipe_info;
typedef struct {
xmedia_s32 pipe;
xmedia_char *in_file_name[VI_MAX_WDR_NUM];
vi_sensor_info sensor_info;
xmedia_video_wdr_mode wdr_mode;
} vi_pipe_send_info;
typedef struct {
xmedia_s32 dev[VI_MAX_STITCH_NUM];
xmedia_s32 wdr_grp[VI_MAX_STITCH_NUM];
xmedia_bool stitch_en;
xmedia_s32 stitch_grp;
xmedia_s32 vi_pipe[VI_MAX_STITCH_WDR_PIPE_NUM];
xmedia_s32 vi_chn;
xmedia_bool gdc_en;
sample_comm_sensor_type sensor_type;
xmedia_video_wdr_mode wdr_mode;
} sample_vi_stitch_param;
typedef struct sample_vi_config {
vi_dev_info dev_info[VI_MAX_DEV_NUM];
vi_pipe_info pipe_info[VI_MAX_PIPE_NUM];
vi_dev_bind_pipe_info dev_bind_pipe[VI_MAX_DEV_NUM];
vi_grp_info grp_info[VI_MAX_GRP_NUM];
} sample_vi_config;
typedef struct {
xmedia_s32 vi_dev;
xmedia_s32 vi_pipe[VI_MAX_WDR_NUM];
xmedia_s32 vi_grp;
xmedia_s32 vi_chn;
xmedia_u32 cache_line;
sample_comm_sensor_type sensor_type;
xmedia_video_wdr_mode wdr_mode;
} sample_vi_wdr_param;
xmedia_s32 sample_comm_vi_get_sensor_info(sample_comm_sensor_type sensor_type, vi_sensor_info *sensor_info);
xmedia_s32 sample_comm_vi_get_default_dev_info(vi_sensor_info *sensor_info, xmedia_vi_dev_config *dev_cfg);
xmedia_void sample_comm_vi_get_default_chn_info(vi_sensor_info *sensor_info, xmedia_vi_chn_config *chn_config,
sample_comm_video_param *video_param);
xmedia_void sample_comm_vi_get_default_pipe_info(vi_sensor_info *sensor_info, xmedia_vi_pipe_config *pipe_config,
xmedia_video_compress_mode compress_mode);
xmedia_s32 sample_comm_vi_get_default_pipe_chn_info(xmedia_s32 dev, vi_sensor_info *sensor_info,
sample_vi_config *vi_cfg, sample_comm_video_param *video_parame);
xmedia_s32 sample_comm_vi_get_default_cfg(vi_sensor_info *sensor_info, sample_vi_config *vi_cfg,
sample_comm_video_param *video_param);
xmedia_s32 sample_comm_vi_get_framerate_by_sensor(sample_comm_sensor_type sensor_type, xmedia_u32 *framerate);
xmedia_s32 sample_comm_vi_get_def_dev_pipe_chn_by_sensor(sample_comm_sensor_type sensor_type,
xmedia_vi_dev_config *dev_cfg,
xmedia_vi_pipe_config *pipe_config,
xmedia_vi_chn_config *chn_config);
xmedia_s32 sample_comm_vi_start(sample_vi_config *vi_cfg, sample_comm_video_param *video_param);
xmedia_s32 sample_comm_vi_stop(sample_vi_config *vi_cfg);
xmedia_s32 sample_comm_vi_init(xmedia_void);
xmedia_s32 sample_comm_vi_exit(xmedia_void);
sample_comm_sensor_type sample_comm_vi_get_wdr_sensor_type(sample_comm_sensor_type sensor_type);
xmedia_void sample_comm_vi_sticth_config_linear_init(sample_vi_stitch_param *vi_stitch_param, sample_vi_config *vi_config);
xmedia_void sample_comm_vi_sticth_config_wdr_init(sample_vi_stitch_param *vi_stitch_param, sample_vi_config *vi_config);
xmedia_void sample_comm_vi_sticth_config_init(sample_vi_stitch_param *vi_stitch_param, sample_vi_config *vi_config);
xmedia_void sample_comm_vi_wdr_config_init(sample_vi_wdr_param *vi_wdr_param, sample_vi_config *vi_config);
#ifdef __cplusplus
}
#endif
#endif
sample/common/sample_comm_vo.c
Executable
+683
View File
@@ -0,0 +1,683 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>
#include <math.h>
#include <unistd.h>
#include <signal.h>
#include "sample_comm.h"
#include "sample_comm_vo.h"
typedef enum {
SAMMPLE_SCREEN_SYNC_TIMING_MIPI_800X1280_SAT935BO30I30R13 = 0,
SAMMPLE_SCREEN_SYNC_TIMING_MAX,
} sample_screen_sync_timing;
xmedia_vo_user_sync_timing sample_screen_user_sync_timing[SAMPLE_COMM_SCREEN_TYPE_INVALID] = {
{480, 23, 12, 800, 210, 46, 1, 1, 1, 1, 2, 1, 0, 0, 0, 0, 1, 1},
{1280, 24, 20, 800, 40, 40, 1, 1, 1, 1, 20, 4, 0, 0, 0, 0, 1, 1},
{1080, 41, 4, 1920, 192, 88, 1, 1, 1, 1, 44, 5, 0, 0, 0, 0, 1, 1},
{1280, 25, 16, 800, 88, 72, 1, 1, 1, 1, 24, 4, 0, 0, 0, 0, 1, 1},
{800, 23, 15, 1280, 88, 72, 1, 1, 1, 1, 24, 2, 0, 0, 0, 0, 1, 1},
{720, 25, 5, 1280, 260, 110,1, 1, 1, 1, 40, 5, 0, 0, 0, 0, 1, 1},
{720, 45, 22, 1920, 136, 40, 1, 1, 1, 1, 20, 20, 0, 0, 0, 0, 1, 1},
{1080, 41, 4, 1920, 192, 88, 1, 1, 1, 1, 44, 5, 0, 0, 0, 0, 1, 1},
{320, 8, 8, 240, 14, 15, 1, 1, 1, 1, 4, 2, 0, 0, 0, 0, 1, 1},
{2160, 0, 0, 3840, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{2160, 82, 8, 3840, 384, 176,1, 1, 1, 1, 88, 10, 0, 0, 0, 0, 1, 1},
{384, 8, 8, 1920, 27, 27, 1, 1, 1, 1, 13, 4, 1, 1, 1, 0, 1, 1},
{240, 8, 8, 320, 130, 38, 1, 1, 1, 1, 2, 1, 0, 0, 0, 0, 1, 1},
{480, 4, 8, 320, 8, 38, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1},
{240, 8, 8, 320, 293, 38, 1, 1, 1, 1, 2, 1, 0, 0, 0, 0, 1, 1},
{1080, 41, 4, 1920, 192, 88, 1, 1, 1, 1, 44, 5, 0, 0, 0, 0, 1, 1},
{720, 25, 5, 1280, 260, 110,1, 1, 1, 1, 40, 5, 0, 0, 0, 0, 1, 1},
{720, 25, 5, 1280, 260, 110,1, 1, 1, 1, 40, 5, 0, 0, 0, 0, 1, 1},
};
xmedia_s32 sample_comm_vo_get_syncinfo(xmedia_vo_intf_sync intf_sync, xmedia_u32 *pst_wdith,
xmedia_u32 *pst_height,xmedia_u32 *pst_freq)
{
xmedia_u32 freq, wdith, height;
switch (intf_sync) {
case XMEDIA_VO_INTF_SYNC_PAL:
wdith = 720;
height = 576;
freq = 25;
break;
case XMEDIA_VO_INTF_SYNC_NTSC:
wdith = 720;
height = 480;
freq = 30;
break;
case XMEDIA_VO_INTF_SYNC_1080P24:
wdith = 1920;
height = 1080;
freq = 24;
break;
case XMEDIA_VO_INTF_SYNC_1080P25:
wdith = 1920;
height = 1080;
freq = 25;
break;
case XMEDIA_VO_INTF_SYNC_1080P30:
wdith = 1920;
height = 1080;
freq = 30;
break;
case XMEDIA_VO_INTF_SYNC_1080I50:
wdith = 1920;
height = 1080;
freq = 50;
break;
case XMEDIA_VO_INTF_SYNC_1080I60:
wdith = 1920;
height = 1080;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_1080P50:
wdith = 1920;
height = 1080;
freq = 50;
break;
case XMEDIA_VO_INTF_SYNC_1080P60:
wdith = 1920;
height = 1080;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_720P60:
wdith = 1280;
height = 720;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_720P50:
wdith = 1280;
height = 720;
freq = 50;
break;
case XMEDIA_VO_INTF_SYNC_576P50:
wdith = 720;
height = 576;
freq = 50;
break;
case XMEDIA_VO_INTF_SYNC_480P60:
wdith = 720;
height = 480;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_800x600_60:
wdith = 800;
height = 600;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_1024x768_60:
wdith = 1024;
height = 768;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_1280x1024_60:
wdith = 1280;
height = 1024;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_1366x768_60:
wdith = 1366;
height = 768;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_1440x900_60:
wdith = 1440;
height = 900;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_1280x800_60:
wdith = 1280;
height = 800;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_1600x1200_60:
wdith = 1600;
height = 1200;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_1680x1050_60:
wdith = 1680;
height = 1050;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_1920x1200_60:
wdith = 1920;
height = 1200;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_640x480_60:
wdith = 640;
height = 480;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_960H_PAL:
wdith = 960;
height = 576;
freq = 25;
break;
case XMEDIA_VO_INTF_SYNC_960H_NTSC:
wdith = 960;
height = 480;
freq = 30;
break;
case XMEDIA_VO_INTF_SYNC_1920x2160_30:
wdith = 1920;
height = 2160;
freq = 30;
break;
case XMEDIA_VO_INTF_SYNC_2560x1440_30:
wdith = 2560;
height = 1440;
freq = 30;
break;
case XMEDIA_VO_INTF_SYNC_2560x1440_60:
wdith = 2560;
height = 1440;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_2560x1600_60:
wdith = 2560;
height = 1600;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_3840x2160_24:
wdith = 3840;
height = 2160;
freq = 24;
break;
case XMEDIA_VO_INTF_SYNC_3840x2160_25:
wdith = 3840;
height = 2160;
freq = 25;
break;
case XMEDIA_VO_INTF_SYNC_3840x2160_30:
wdith = 3840;
height = 2160;
freq = 30;
break;
case XMEDIA_VO_INTF_SYNC_3840x2160_50:
wdith = 3840;
height = 2160;
freq = 50;
break;
case XMEDIA_VO_INTF_SYNC_3840x2160_60:
wdith = 3840;
height = 2160;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_4096x2160_24:
wdith = 4096;
height = 2160;
freq = 24;
break;
case XMEDIA_VO_INTF_SYNC_4096x2160_25:
wdith = 4096;
height = 2160;
freq = 25;
break;
case XMEDIA_VO_INTF_SYNC_4096x2160_30:
wdith = 4096;
height = 2160;
freq = 30;
break;
case XMEDIA_VO_INTF_SYNC_4096x2160_50:
wdith = 4096;
height = 2160;
freq = 50;
break;
case XMEDIA_VO_INTF_SYNC_4096x2160_60:
wdith = 4096;
height = 2160;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_320x240_60:
wdith = 320;
height = 240;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_320x240_50:
wdith = 320;
height = 240;
freq = 50;
break;
case XMEDIA_VO_INTF_SYNC_240x320_50:
wdith = 240;
height = 320;
freq = 50;
break;
case XMEDIA_VO_INTF_SYNC_240x320_60:
wdith = 240;
height = 320;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_800x600_50:
wdith = 800;
height = 600;
freq = 50;
break;
case XMEDIA_VO_INTF_SYNC_800x480_50:
wdith = 800;
height = 480;
freq = 50;
break;
case XMEDIA_VO_INTF_SYNC_720x1280_60:
wdith = 720;
height = 1280;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_1080x1920_60:
wdith = 1080;
height = 1920;
freq = 60;
break;
case XMEDIA_VO_INTF_SYNC_7680x4320_30:
wdith = 7680;
height = 4320;
freq = 30;
break;
case XMEDIA_VO_INTF_SYNC_USER:
wdith = 720;
height = 576;
freq = 25;
break;
default:
return XMEDIA_FAILURE;
}
if (pst_wdith != XMEDIA_NULL) {
*pst_wdith = wdith;
}
if (pst_height != XMEDIA_NULL) {
*pst_height = height;
}
if (pst_freq != XMEDIA_NULL) {
*pst_freq = freq;
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vo_get_dev_config(xmedia_s32 screen_type, sample_vo_config *vo_config,
xmedia_u32 *pst_wdith, xmedia_u32 *pst_height,xmedia_u32 *pst_freq)
{
vo_config->dev_config.bg_color = 0x00;
switch(screen_type) {
case MICROTECH_MTF050_LCD_800X480:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_LCD;
vo_config->dev_config.intf_config.lcd_attr.data_mode = XMEDIA_VO_LCD_DATA_MODE_PARA;
vo_config->dev_config.intf_config.lcd_attr.data_seq = XMEDIA_INTF_LCD_DATA_SEQ_RGB;
vo_config->dev_config.intf_config.lcd_attr.data_type = XMEDIA_INTF_LCD_DATA_TYPE_RGB888_24BIT;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.clk_reverse_en = 0;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case SATOZ_SAT935_MIPI_800X1280_RGB8888_24BIT:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_MIPI_DSI;
vo_config->dev_config.intf_config.mipi_attr.data_type = XMEDIA_INTF_MIPI_DSI_DATA_TYPE_RGB888_24BIT;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[0] = XMEDIA_VO_MIPI_LANE_DATA0;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[1] = XMEDIA_VO_MIPI_LANE_DATA1;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[2] = XMEDIA_VO_MIPI_LANE_CLK;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[3] = XMEDIA_VO_MIPI_LANE_DATA2;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[4] = XMEDIA_VO_MIPI_LANE_DATA3;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[0] = 0;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[1] = 0;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[2] = 0;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[3] = 0;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[4] = 0;
vo_config->dev_config.intf_config.mipi_attr.mipi_htotal_adjust = 1;
vo_config->dev_config.intf_config.mipi_attr.mipi_vsync_adjust = 2;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.clk_reverse_en = 0;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case SIL9024_BT1120_1920X1080P60:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_BT1120;
vo_config->dev_config.intf_config.bt1120_attr.data_seq = XMEDIA_INTF_BT1120_DATA_SEQ_UVUV;
vo_config->dev_config.intf_config.bt1120_attr.data_type = XMEDIA_INTF_BT_DATA_TYPE_YUV422_8BIT;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_YUV;
vo_config->dev_config.user_sync_config.clk_reverse_en = 1;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case MICROTECH_MTF101_FT01_LVDS_800X1280_RGB666_18BIT:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_LVDS;
vo_config->dev_config.intf_config.lvds_attr.format = XMEDIA_INTF_LVDS_FORMAT_VESA;
vo_config->dev_config.intf_config.lvds_attr.data_type = XMEDIA_INTF_LVDS_DATA_TYPE_RGB666_18BIT;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[0] = XMEDIA_VO_LVDS_LANE_DATA0;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[1] = XMEDIA_VO_LVDS_LANE_DATA1;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[2] = XMEDIA_VO_LVDS_LANE_DATA2;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[3] = XMEDIA_VO_LVDS_LANE_CLK;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[4] = XMEDIA_VO_LVDS_LANE_DATA3;
vo_config->dev_config.intf_config.lvds_attr.lane_pn_swap[0] = 0;
vo_config->dev_config.intf_config.lvds_attr.lane_pn_swap[1] = 0;
vo_config->dev_config.intf_config.lvds_attr.lane_pn_swap[2] = 0;
vo_config->dev_config.intf_config.lvds_attr.lane_pn_swap[3] = 0;
vo_config->dev_config.intf_config.lvds_attr.lane_pn_swap[4] = 0;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.clk_reverse_en = 0;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case MICROTECH_MTF101_FS16_LVDS_1280X800_RGB888_24BIT:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_LVDS;
vo_config->dev_config.intf_config.lvds_attr.format = XMEDIA_INTF_LVDS_FORMAT_VESA;
vo_config->dev_config.intf_config.lvds_attr.data_type = XMEDIA_INTF_LVDS_DATA_TYPE_RGB888_24BIT;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[0] = XMEDIA_VO_LVDS_LANE_DATA0;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[1] = XMEDIA_VO_LVDS_LANE_DATA1;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[2] = XMEDIA_VO_LVDS_LANE_DATA2;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[3] = XMEDIA_VO_LVDS_LANE_CLK;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[4] = XMEDIA_VO_LVDS_LANE_DATA3;
vo_config->dev_config.intf_config.lvds_attr.lane_pn_swap[0] = 0;
vo_config->dev_config.intf_config.lvds_attr.lane_pn_swap[1] = 0;
vo_config->dev_config.intf_config.lvds_attr.lane_pn_swap[2] = 0;
vo_config->dev_config.intf_config.lvds_attr.lane_pn_swap[3] = 0;
vo_config->dev_config.intf_config.lvds_attr.lane_pn_swap[4] = 0;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.clk_reverse_en = 0;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case C3200B_EVB_BT656_1280X720_UYVY422:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_BT656;
vo_config->dev_config.intf_config.bt656_attr.data_seq = XMEDIA_INTF_BT601_BT656_DATA_SEQ_UYVY;
vo_config->dev_config.intf_config.bt656_attr.data_type = XMEDIA_INTF_BT_DATA_TYPE_YUV422_8BIT;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_YUV;
vo_config->dev_config.user_sync_config.clk_reverse_en = 0;
vo_config->dev_config.user_sync_config.frame_rate = 30;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case DEMO_LVDS_1920X720_RGB888_24BIT:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_LVDS;
vo_config->dev_config.intf_config.lvds_attr.format = XMEDIA_INTF_LVDS_FORMAT_VESA;
vo_config->dev_config.intf_config.lvds_attr.data_type = XMEDIA_INTF_LVDS_DATA_TYPE_RGB888_24BIT;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[0] = XMEDIA_VO_LVDS_LANE_DATA0;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[1] = XMEDIA_VO_LVDS_LANE_DATA1;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[2] = XMEDIA_VO_LVDS_LANE_DATA2;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[3] = XMEDIA_VO_LVDS_LANE_DATA3;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[4] = XMEDIA_VO_LVDS_LANE_CLK;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.clk_reverse_en = 0;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case MIPI_TO_HDMI_1920X1080_RGB888_24BIT:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_MIPI_DSI;
vo_config->dev_config.intf_config.mipi_attr.data_type = XMEDIA_INTF_MIPI_DSI_DATA_TYPE_RGB888_24BIT;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[0] = XMEDIA_VO_MIPI_LANE_DATA3;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[1] = XMEDIA_VO_MIPI_LANE_DATA2;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[2] = XMEDIA_VO_MIPI_LANE_CLK;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[3] = XMEDIA_VO_MIPI_LANE_DATA1;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[4] = XMEDIA_VO_MIPI_LANE_DATA0;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[0] = 1;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[1] = 1;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[2] = 1;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[3] = 1;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[4] = 1;
vo_config->dev_config.intf_config.mipi_attr.mipi_htotal_adjust = 0;
vo_config->dev_config.intf_config.mipi_attr.mipi_vsync_adjust = 0;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.clk_reverse_en = 0;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case MTF024QV33B_SLCD_240X320_18BIT:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_LCD;
vo_config->dev_config.intf_config.lcd_attr.data_mode = XMEDIA_VO_LCD_DATA_MODE_SERIAL;
vo_config->dev_config.intf_config.lcd_attr.data_seq = XMEDIA_INTF_LCD_DATA_SEQ_RGB;
vo_config->dev_config.intf_config.lcd_attr.data_type = XMEDIA_INTF_LCD_DATA_TYPE_RGB666_18BIT;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.clk_reverse_en = 1;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case VIRTUAL_SCREEN_MIPI_3840X2160P30:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_MIPI_DSI;
vo_config->dev_config.intf_config.mipi_attr.data_type = XMEDIA_INTF_MIPI_DSI_DATA_TYPE_RGB888_24BIT;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.clk_reverse_en = 0;
vo_config->dev_config.user_sync_config.frame_rate = 30;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case MIPI_TO_HDMI_3840X2160_RGB888_24BIT:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_MIPI_DSI;
vo_config->dev_config.intf_config.mipi_attr.data_type = XMEDIA_INTF_MIPI_DSI_DATA_TYPE_RGB888_24BIT;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[0] = XMEDIA_VO_MIPI_LANE_DATA3;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[1] = XMEDIA_VO_MIPI_LANE_DATA2;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[2] = XMEDIA_VO_MIPI_LANE_CLK;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[3] = XMEDIA_VO_MIPI_LANE_DATA1;
vo_config->dev_config.intf_config.mipi_attr.lane_sel[4] = XMEDIA_VO_MIPI_LANE_DATA0;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[0] = 1;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[1] = 1;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[2] = 1;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[3] = 1;
vo_config->dev_config.intf_config.mipi_attr.lane_pn_swap[4] = 1;
vo_config->dev_config.intf_config.mipi_attr.mipi_htotal_adjust = 0;
vo_config->dev_config.intf_config.mipi_attr.mipi_vsync_adjust = 0;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.clk_reverse_en = 0;
vo_config->dev_config.user_sync_config.frame_rate = 30;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case HX_M090P24349A_LVDS_VESA_1920X384_RGB888_24BIT:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_LVDS;
vo_config->dev_config.intf_config.lvds_attr.format = XMEDIA_INTF_LVDS_FORMAT_VESA;
vo_config->dev_config.intf_config.lvds_attr.data_type = XMEDIA_INTF_LVDS_DATA_TYPE_RGB888_24BIT;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[0] = XMEDIA_VO_LVDS_LANE_DATA0;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[1] = XMEDIA_VO_LVDS_LANE_DATA1;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[2] = XMEDIA_VO_LVDS_LANE_DATA2;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[3] = XMEDIA_VO_LVDS_LANE_DATA3;
vo_config->dev_config.intf_config.lvds_attr.lane_sel[4] = XMEDIA_VO_LVDS_LANE_CLK;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.clk_reverse_en = 1;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case MCU_KD026_320X240P6_4LINE_RGB565:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_MCU;
vo_config->dev_config.intf_config.mcu_attr.te_mode_en = XMEDIA_FALSE;
vo_config->dev_config.intf_config.mcu_attr.data_type = XMEDIA_VO_MCU_DATA_TYPE_4LINE_RGB565;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.frame_rate = 10;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case MCU_KD035_320X480P6_3LINE_RGB666_OPTION1:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_MCU;
vo_config->dev_config.intf_config.mcu_attr.te_mode_en = XMEDIA_FALSE;
vo_config->dev_config.intf_config.mcu_attr.data_type = XMEDIA_VO_MCU_DATA_TYPE_3LINE_RGB666_OPTION1;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.frame_rate = 6;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case MCU_KD026_320X240P60_18BIT_18BPP_RGB666_8080I:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_MCU;
vo_config->dev_config.intf_config.mcu_attr.te_mode_en = XMEDIA_FALSE;
vo_config->dev_config.intf_config.mcu_attr.data_type = XMEDIA_VO_MCU_DATA_TYPE_18BIT_18BPP_RGB666_8080I;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_RGB;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case SIL9024_BT1120_1920X1080P30:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_BT1120;
vo_config->dev_config.intf_config.bt1120_attr.data_seq = XMEDIA_INTF_BT1120_DATA_SEQ_UVUV;
vo_config->dev_config.intf_config.bt1120_attr.data_type = XMEDIA_INTF_BT_DATA_TYPE_YUV422_8BIT;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_YUV;
vo_config->dev_config.user_sync_config.clk_reverse_en = 1;
vo_config->dev_config.user_sync_config.frame_rate = 30;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case SIL9024_BT1120_1280X720P60:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_BT1120;
vo_config->dev_config.intf_config.bt1120_attr.data_seq = XMEDIA_INTF_BT1120_DATA_SEQ_UVUV;
vo_config->dev_config.intf_config.bt1120_attr.data_type = XMEDIA_INTF_BT_DATA_TYPE_YUV422_8BIT;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_YUV;
vo_config->dev_config.user_sync_config.clk_reverse_en = 1;
vo_config->dev_config.user_sync_config.frame_rate = 60;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
case SIL9024_BT656_1280X720P30_UYVY422:
vo_config->dev_config.intf_config.intf_type = XMEDIA_INTF_TYPE_BT656;
vo_config->dev_config.intf_config.bt656_attr.data_seq = XMEDIA_INTF_BT601_BT656_DATA_SEQ_UYVY;
vo_config->dev_config.intf_config.bt656_attr.data_type = XMEDIA_INTF_BT_DATA_TYPE_YUV422_8BIT;
vo_config->dev_csc.color_info.color_space = XMEDIA_VIDEO_COLOR_SPACE_YUV;
vo_config->dev_config.user_sync_config.clk_reverse_en = 1;
vo_config->dev_config.user_sync_config.frame_rate = 30;
vo_config->dev_config.intf_sync = XMEDIA_VO_INTF_SYNC_USER;
break;
default:
SAMPLE_PRT("screen_type err !\n");
return XMEDIA_FAILURE;
}
memcpy(&vo_config->dev_config.user_sync_config.timing_info, &sample_screen_user_sync_timing[screen_type],
sizeof(xmedia_vo_user_sync_timing));
*pst_wdith = sample_screen_user_sync_timing[screen_type].hact;
*pst_height = sample_screen_user_sync_timing[screen_type].vact;
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vo_get_default_config(sample_vo_config_input config_in, sample_vo_config *vo_config)
{
xmedia_u32 freq, width, height, j;
if (vo_config != XMEDIA_NULL) {
if (sample_comm_vo_get_dev_config(config_in.screen_type, vo_config, &width, &height, &freq) != XMEDIA_SUCCESS) {
SAMPLE_PRT("can not get dev config information!\n");
return XMEDIA_FAILURE;
}
//csc info
vo_config->dev_csc.color_info.color_gamut = XMEDIA_VIDEO_COLOR_GAMUT_BT709;
vo_config->dev_csc.color_info.quantify_range = XMEDIA_VIDEO_COLOR_FULL_RANGE;
vo_config->dev_csc.mode = XMEDIA_VO_DEV_MODE_VIDEO_GRAPHIC;
vo_config->dev_csc.hue = 50;
vo_config->dev_csc.luma = 50;
vo_config->dev_csc.saturation = 50;
vo_config->dev_csc.contrast = 50;
//layer info
vo_config->layer_config.img_size.width = width;
vo_config->layer_config.img_size.height = height;
vo_config->layer_config.pix_format = XMEDIA_VIDEO_PIXEL_FMT_YUV_SEMIPLANAR_420;
vo_config->layer_config.bit_width = XMEDIA_VIDEO_DATA_WIDTH_8;
vo_config->layer_config.part_mode = XMEDIA_VO_PARTITION_MODE_SINGLE;
vo_config->layer_config.disp_buf_len = 0;
//chn info
for (j = 0; j < (config_in.square_sort); j++) {
if (j == 0 ){
vo_config->chn_attr[j].out_rect.x = 0;
vo_config->chn_attr[j].out_rect.y = 0;
} else if (j == 1) {
vo_config->chn_attr[j].out_rect.x = width / 2;
vo_config->chn_attr[j].out_rect.y = 0;
} else if (j == 2) {
vo_config->chn_attr[j].out_rect.x = 0;
vo_config->chn_attr[j].out_rect.y = height / 2;
} else {
vo_config->chn_attr[j].out_rect.x = width / 2;
vo_config->chn_attr[j].out_rect.y = height / 2;
}
if (config_in.square_sort > 1) {
if (config_in.square_sort == 2) {
vo_config->chn_attr[j].out_rect.width = width / 2;
vo_config->chn_attr[j].out_rect.height = height;
} else {
vo_config->chn_attr[j].out_rect.width = width / 2;
vo_config->chn_attr[j].out_rect.height = height / 2;
}
} else {
vo_config->chn_attr[j].out_rect.width = width;
vo_config->chn_attr[j].out_rect.height = height;
}
vo_config->chn_attr[j].region_rect.x = vo_config->chn_attr[j].out_rect.x;
vo_config->chn_attr[j].region_rect.y = vo_config->chn_attr[j].out_rect.y;
vo_config->chn_attr[j].region_rect.width = vo_config->chn_attr[j].out_rect.width;
vo_config->chn_attr[j].region_rect.height = vo_config->chn_attr[j].out_rect.height;
vo_config->chn_attr[j].bg_color = 0xff;
vo_config->chn_attr[j].zorder = j;
}
}else {
SAMPLE_PRT("vo_config is null!\n");
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vo_start(xmedia_vo_dev dev, xmedia_vo_layer layer, xmedia_vo_chn chn[],xmedia_s32 chn_num,
xmedia_bool buf_len_set,sample_vo_config *vo_config)
{
xmedia_s32 i;
if (vo_config != XMEDIA_NULL) {
CHECK_RET(xmedia_vo_set_dev_config(dev, &(vo_config->dev_config)), "xmedia_vo_set_dev_config");
CHECK_RET(xmedia_vo_set_dev_csc(dev, &(vo_config->dev_csc)), "xmedia_vo_set_dev_csc");
CHECK_RET(xmedia_vo_enable_dev(dev), "xmedia_vo_enable_dev");
layer = (xmedia_vo_layer)dev;
if (buf_len_set) {
vo_config->layer_config.disp_buf_len = 3;
}
CHECK_RET(xmedia_vo_set_layer_config(layer, &(vo_config->layer_config)), "xmedia_vo_set_layer_config");
CHECK_RET(xmedia_vo_enable_layer(layer), "xmedia_vo_enable_layer");
for (i = 0; i < chn_num; i++) {
SAMPLE_PRT("dev:%d chn:%d chn_rect[%d-%d-%d-%d]\n", dev, chn[i], vo_config->chn_attr[i].out_rect.x,
vo_config->chn_attr[i].out_rect.y,
vo_config->chn_attr[i].out_rect.width, vo_config->chn_attr[i].out_rect.height);
if (vo_config->lowdelay_attr.enable == XMEDIA_TRUE) {
CHECK_RET(xmedia_vo_set_chn_low_delay(layer, chn[i], vo_config->lowdelay_attr.mode), "set chn rotate");
}
CHECK_RET(xmedia_vo_set_chn_attr(layer, chn[i], &(vo_config->chn_attr[i])), "xmedia_vo_set_chn_attr");
CHECK_RET(xmedia_vo_enable_chn(layer, chn[i]), "xmedia_vo_enable_chn");
}
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vo_stop(xmedia_vo_dev dev, xmedia_vo_layer layer, xmedia_vo_chn chn[], xmedia_s32 chn_num)
{
xmedia_s32 i;
for (i = 0; i < chn_num; i++){
CHECK_RET(xmedia_vo_disable_chn(layer, chn[i]), "xmedia_vo_disable_chn");
}
CHECK_RET(xmedia_vo_disable_layer(layer), "xmedia_vo_disable_layer");
CHECK_RET(xmedia_vo_disable_dev(dev), "xmedia_vo_disable_dev");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vo_init(xmedia_void)
{
return xmedia_vo_init();
}
xmedia_s32 sample_comm_vo_exit(xmedia_void)
{
return xmedia_vo_exit();
}
sample/common/sample_comm_vo.h
Executable
+90
View File
@@ -0,0 +1,90 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_VO_H__
#define __SAMPLE_COMM_VO_H__
#include <pthread.h>
#include "common.h"
#include "defines.h"
#include "xmedia_sys.h"
#include "xmedia_vb.h"
#include "xmedia_vo.h"
#include "xmedia_type.h"
#include "xmedia_mmz.h"
#include "math_fun.h"
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif /* End of #ifdef __cplusplus */
typedef struct{
xmedia_bool enable;
xmedia_vo_low_delay_mode mode;
}sample_vo_lowdelay_attr;
typedef struct{
xmedia_vo_intf_sync intf_sync;
xmedia_intf_type intf_type;
xmedia_s32 square_sort;
xmedia_s32 screen_type;
}sample_vo_config_input;
typedef struct{
xmedia_vo_dev_config dev_config;
xmedia_vo_layer_config layer_config;
xmedia_vo_chn_attr chn_attr[VO_MAX_CHN_NUM];
xmedia_vo_dev_csc dev_csc;
sample_vo_lowdelay_attr lowdelay_attr;
}sample_vo_config;
typedef enum {
MICROTECH_MTF050_LCD_800X480 = 0,
SATOZ_SAT935_MIPI_800X1280_RGB8888_24BIT,
SIL9024_BT1120_1920X1080P60,
MICROTECH_MTF101_FT01_LVDS_800X1280_RGB666_18BIT,
MICROTECH_MTF101_FS16_LVDS_1280X800_RGB888_24BIT,
C3200B_EVB_BT656_1280X720_UYVY422,
DEMO_LVDS_1920X720_RGB888_24BIT,
MIPI_TO_HDMI_1920X1080_RGB888_24BIT,
MTF024QV33B_SLCD_240X320_18BIT,
VIRTUAL_SCREEN_MIPI_3840X2160P30,
MIPI_TO_HDMI_3840X2160_RGB888_24BIT = 10,
HX_M090P24349A_LVDS_VESA_1920X384_RGB888_24BIT,
MCU_KD026_320X240P6_4LINE_RGB565,
MCU_KD035_320X480P6_3LINE_RGB666_OPTION1,
MCU_KD026_320X240P60_18BIT_18BPP_RGB666_8080I,
SIL9024_BT1120_1920X1080P30,
SIL9024_BT1120_1280X720P60,
SIL9024_BT656_1280X720P30_UYVY422,
SAMPLE_COMM_SCREEN_TYPE_INVALID,
} sample_comm_screen_type;
xmedia_s32 sample_comm_vo_get_dev_config(xmedia_s32 screen_type, sample_vo_config *vo_config, xmedia_u32 *pst_wdith,
xmedia_u32 *pst_height,xmedia_u32 *pst_freq);
xmedia_s32 sample_comm_vo_get_default_config(sample_vo_config_input config_in, sample_vo_config *vo_config);
xmedia_s32 sample_comm_vo_start(xmedia_vo_dev dev, xmedia_vo_layer layer, xmedia_vo_chn chn[],xmedia_s32 chn_num,
xmedia_bool buf_len_set,sample_vo_config *vo_config);
xmedia_s32 sample_comm_vo_stop(xmedia_vo_dev dev, xmedia_vo_layer layer, xmedia_vo_chn chn[], xmedia_s32 chn_num);
xmedia_s32 sample_comm_vo_init(xmedia_void);
xmedia_s32 sample_comm_vo_exit(xmedia_void);
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* End of #ifdef __cplusplus */
#endif /* End of #ifndef __SAMPLE_COMM_VO_H__ */
sample/common/sample_comm_vpss.c
+272
View File
@@ -0,0 +1,272 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "math_fun.h"
#include "xmedia_debug.h"
#include "sample_comm.h"
#include "sample_comm_vpss.h"
xmedia_s32 sample_comm_vpss_create_pipe(xmedia_s32 pipe_id, vpss_pipe_info* pipe_info)
{
xmedia_vpss_pipe_config pipe_cfg = {0};
memcpy(&pipe_cfg, &pipe_info->pipe_config, sizeof(xmedia_vpss_pipe_config));
CHECK_RET(xmedia_vpss_create_pipe(pipe_id, &pipe_cfg), "create vpss pipe");
if (pipe_info->crop_attr.enable == XMEDIA_TRUE) {
CHECK_RET(xmedia_vpss_set_pipe_crop(pipe_id, &pipe_info->crop_attr), "set pipe crop");
}
if ((pipe_info->stnr_attr.cnr_enable == XMEDIA_TRUE) ||
(pipe_info->stnr_attr.tnr_enable == XMEDIA_TRUE) ||
(pipe_info->stnr_attr.ynr_enable == XMEDIA_TRUE)) {
CHECK_RET(xmedia_vpss_set_pipe_stnr_attr(pipe_id, &pipe_info->stnr_attr), "set pipe stnr");
}
if (pipe_info->sharpen_attr.enable == XMEDIA_TRUE) {
CHECK_RET(xmedia_vpss_set_pipe_sharpen_attr(pipe_id, &pipe_info->sharpen_attr), "set pipe sharpen");
}
if (pipe_info->stitch_attr.stitch_en == XMEDIA_TRUE) {
CHECK_RET(xmedia_vpss_set_pipe_stitch_blend_attr(pipe_id, &pipe_info->stitch_attr.stitch_blend_attr), "set pipe stitch");
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vpss_destory_pipe(xmedia_s32 pipe_id)
{
CHECK_RET(xmedia_vpss_destroy_pipe(pipe_id), "destroy pipe");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vpss_set_chn_attr(xmedia_s32 pipe_id, xmedia_s32 chn_id, vpss_chn_info *chn_info)
{
xmedia_vpss_ochn_config ochn_cfg = {0};
memcpy(&ochn_cfg, &chn_info->chn_config, sizeof(xmedia_vpss_ochn_config));
CHECK_RET(xmedia_vpss_set_ochn_config(pipe_id, chn_id, &ochn_cfg), "set vpss channel attr");
if (chn_info->crop_attr.enable == XMEDIA_TRUE) {
CHECK_RET(xmedia_vpss_set_ochn_post_crop(pipe_id, chn_id, &chn_info->crop_attr), "set vpss channel crop");
}
if ((chn_info->rot_attr == XMEDIA_VIDEO_ROTATION_90) ||
(chn_info->rot_attr == XMEDIA_VIDEO_ROTATION_180) ||
(chn_info->rot_attr == XMEDIA_VIDEO_ROTATION_270)) {
CHECK_RET(xmedia_vpss_set_ochn_rotation(pipe_id, chn_id, chn_info->rot_attr), "set chn rotate");
}
if (chn_info->lowdelay_attr.enable == XMEDIA_TRUE) {
CHECK_RET(xmedia_vpss_set_ochn_low_delay_attr(pipe_id, chn_id, &chn_info->lowdelay_attr), "set chn rotate");
}
if ((chn_info->wrap_attr.enable == XMEDIA_TRUE)&&(chn_id == 0)) {
if (chn_info->wrap_attr.buf_line == 0) {
chn_info->wrap_attr.buf_line = XM_ALIGN_DOWN(chn_info->chn_config.height/2, 8);
}
xmedia_vb_base_info vb_info;
vb_info.width = chn_info->chn_config.width;
vb_info.height = chn_info->chn_config.height;
vb_info.align = 0; //auto
vb_info.bit_width = XMEDIA_VIDEO_DATA_WIDTH_8;
vb_info.cmp_mode = chn_info->chn_config.cmp_mode;
vb_info.pixel_fmt = chn_info->chn_config.pix_fmt;
vb_info.video_fmt = chn_info->chn_config.video_fmt;
chn_info->wrap_attr.buf_size = xmedia_vb_get_wrap_buffer_size(&vb_info, chn_info->wrap_attr.buf_line);
CHECK_RET(xmedia_vpss_set_ochn_wrap_attr(pipe_id, chn_id, &chn_info->wrap_attr), "set chn0 buffer wrap");
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vpss_pipe_chn_start(sample_vpss_config *vpss_cfg)
{
xmedia_s32 pipe_id, chn_id, ext_chn_id;
xmedia_s32 ext_base_chn_id = VPSS_MAX_PHY_OCHN_NUM;
for (pipe_id = 0; pipe_id < VPSS_MAX_PIPE_NUM; pipe_id++) {
for (chn_id = 0; chn_id < VPSS_MAX_PHY_OCHN_NUM; chn_id++) {
if (vpss_cfg->pipe_info[pipe_id].chn_info[chn_id].chn_en == XMEDIA_FALSE) {
continue;
}
CHECK_RET(xmedia_vpss_enable_ochn(pipe_id, chn_id), "enable channel");
}
for (ext_chn_id = 0; ext_chn_id < VPSS_MAX_EXT_OCHN_NUM; ext_chn_id++) {
if (vpss_cfg->pipe_info[pipe_id].ext_chn_info[ext_chn_id].ext_chn_en == XMEDIA_FALSE) {
continue;
}
CHECK_RET(xmedia_vpss_enable_ochn(pipe_id, ext_base_chn_id + ext_chn_id), "enable channel");
}
if (vpss_cfg->pipe_info[pipe_id].pipe_en == XMEDIA_TRUE) {
CHECK_RET(xmedia_vpss_start_pipe(pipe_id), "start vpss pipe");
}
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vpss_pipe_chn_stop(sample_vpss_config *vpss_cfg)
{
xmedia_s32 pipe_id, chn_id, ext_chn_id;
xmedia_s32 ext_base_chn_id = VPSS_MAX_PHY_OCHN_NUM;
for (pipe_id = 0; pipe_id < VPSS_MAX_PIPE_NUM; pipe_id++) {
if (vpss_cfg->pipe_info[pipe_id].pipe_en == XMEDIA_FALSE) {
continue;
}
CHECK_RET(xmedia_vpss_stop_pipe(pipe_id), "stop pipe");
for (ext_chn_id = 0; ext_chn_id < VPSS_MAX_EXT_OCHN_NUM; ext_chn_id++) {
if (vpss_cfg->pipe_info[pipe_id].ext_chn_info[ext_chn_id].ext_chn_en == XMEDIA_FALSE) {
continue;
}
CHECK_RET(xmedia_vpss_disable_ochn(pipe_id, ext_base_chn_id + ext_chn_id), "disable vpss ext channel");
}
for (chn_id = 0; chn_id < VPSS_MAX_PHY_OCHN_NUM; chn_id++) {
if (vpss_cfg->pipe_info[pipe_id].chn_info[chn_id].chn_en == XMEDIA_FALSE) {
continue;
}
CHECK_RET(xmedia_vpss_disable_ochn(pipe_id, chn_id), "disable vpss channel");
}
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vpss_get_default_pipe_cfg(xmedia_vpss_pipe_config *pipe_cfg, xmedia_video_size in_size,sample_comm_video_param *video_param)
{
CHECK_NULL_PTR(pipe_cfg);
pipe_cfg->max_w = in_size.width;
pipe_cfg->max_h = in_size.height;
pipe_cfg->pixel_fmt = video_param->pixel_fmt;
pipe_cfg->dync_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR;
pipe_cfg->frm_rate_ctrl.src_frm_rate = -1;
pipe_cfg->frm_rate_ctrl.dst_frm_rate = -1;
pipe_cfg->nr_attr.nr_en = XMEDIA_FALSE;
pipe_cfg->nr_attr.compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE;
pipe_cfg->stitch_blend_cfg.stitch_blend_en = XMEDIA_FALSE;
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vpss_get_default_ochn_cfg(xmedia_vpss_ochn_config *ochn_cfg, xmedia_video_size out_size, sample_comm_video_param *video_param)
{
CHECK_NULL_PTR(ochn_cfg);
ochn_cfg->mode = XMEDIA_VPSS_OCHN_MODE_USER;
ochn_cfg->scale_mode = XMEDIA_VIDEO_SCALE_MODE_NORMAL;
ochn_cfg->width = out_size.width;
ochn_cfg->height = out_size.height;
ochn_cfg->pix_fmt = video_param->pixel_fmt;
ochn_cfg->video_fmt = video_param->video_fmt;
ochn_cfg->cmp_mode = video_param->compress_mode;
ochn_cfg->dync_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR;
ochn_cfg->frm_rate_ctrl.src_frm_rate = -1;
ochn_cfg->frm_rate_ctrl.dst_frm_rate = -1;
ochn_cfg->mirror_en = XMEDIA_FALSE;
ochn_cfg->flip_en = XMEDIA_FALSE;
ochn_cfg->depth = 1;
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vpss_set_ochn_wrap(vpss_chn_info *ochn_info)
{
xmedia_vb_base_info vb_base_info = {0};
vb_base_info.width = ochn_info->chn_config.width;
vb_base_info.height = ochn_info->chn_config.height;
vb_base_info.pixel_fmt = ochn_info->chn_config.pix_fmt;
vb_base_info.video_fmt = ochn_info->chn_config.video_fmt;
vb_base_info.cmp_mode = ochn_info->chn_config.cmp_mode;
vb_base_info.bit_width = XMEDIA_VIDEO_DATA_WIDTH_8;
vb_base_info.align = DEFAULT_ALIGN;
ochn_info->wrap_attr.enable = XMEDIA_TRUE;
ochn_info->wrap_attr.buf_line = XM_ALIGN_DOWN(ochn_info->chn_config.height / 2, 8);
ochn_info->wrap_attr.buf_size = xmedia_vb_get_wrap_buffer_size(&vb_base_info, ochn_info->wrap_attr.buf_line);
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vpss_start(sample_vpss_config *vpss_cfg)
{
vpss_pipe_info *pipe_info = NULL;
vpss_chn_info *chn_info = NULL;
vpss_ext_chn_info *ext_chn_info = NULL;
xmedia_s32 pipe_id, chn_id, ext_chn_id;
xmedia_s32 ext_base_chn_id = VPSS_MAX_PHY_OCHN_NUM;
for (pipe_id = 0; pipe_id < VPSS_MAX_PIPE_NUM; pipe_id++) {
if(vpss_cfg->pipe_info[pipe_id].pipe_en == XMEDIA_FALSE) {
continue;
}
pipe_info = &vpss_cfg->pipe_info[pipe_id];
CHECK_RET(sample_comm_vpss_create_pipe(pipe_id, pipe_info), "create vpss pipe and set attr");
for (chn_id = 0; chn_id < VPSS_MAX_PHY_OCHN_NUM; chn_id++) {
if(vpss_cfg->pipe_info[pipe_id].chn_info[chn_id].chn_en == XMEDIA_FALSE) {
continue;
}
chn_info = &vpss_cfg->pipe_info[pipe_id].chn_info[chn_id];
CHECK_RET(sample_comm_vpss_set_chn_attr(pipe_id, chn_id, chn_info), "set vpss chn attr");
}
for (ext_chn_id = 0; ext_chn_id < VPSS_MAX_EXT_OCHN_NUM; ext_chn_id++) {
if (vpss_cfg->pipe_info[pipe_id].ext_chn_info[ext_chn_id].ext_chn_en == XMEDIA_FALSE) {
continue;
}
ext_chn_info = &vpss_cfg->pipe_info[pipe_id].ext_chn_info[ext_chn_id];
CHECK_RET(xmedia_vpss_set_ext_ochn_config(pipe_id, ext_base_chn_id + ext_chn_id, &ext_chn_info->ext_chn), "set extchn attr");
}
}
CHECK_RET(sample_comm_vpss_pipe_chn_start(vpss_cfg), "vpss module start");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vpss_stop(sample_vpss_config *vpss_cfg)
{
xmedia_s32 pipe_id;
sample_comm_vpss_pipe_chn_stop(vpss_cfg);
for (pipe_id = 0; pipe_id < VPSS_MAX_PIPE_NUM; pipe_id++) {
if (vpss_cfg->pipe_info[pipe_id].pipe_en == XMEDIA_FALSE) {
continue;
}
CHECK_RET(sample_comm_vpss_destory_pipe(pipe_id), "destroy pipe");
}
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_vpss_init(xmedia_void)
{
return xmedia_vpss_init();
}
xmedia_s32 sample_comm_vpss_exit(xmedia_void)
{
return xmedia_vpss_exit();
}
sample/common/sample_comm_vpss.h
+82
View File
@@ -0,0 +1,82 @@
/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#ifndef __SAMPLE_COMM_VPSS_H__
#define __SAMPLE_COMM_VPSS_H__
#include "xmedia_type.h"
#include "xmedia_sys.h"
#include "xmedia_vb.h"
#include "xmedia_vpss.h"
#include "xmedia_region.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
xmedia_bool ext_chn_en;
xmedia_vpss_ext_ochn_config ext_chn;
}vpss_ext_chn_info;
typedef struct {
xmedia_bool chn_en;
xmedia_s32 chn_no;
xmedia_vpss_ochn_config chn_config;
xmedia_video_crop_attr crop_attr;
xmedia_video_rotation rot_attr;
xmedia_vpss_low_delay_attr lowdelay_attr;
xmedia_video_wrap_attr wrap_attr;
}vpss_chn_info;
typedef struct {
xmedia_bool stitch_en;
xmedia_vpss_stitch_blend_attr stitch_blend_attr;
}vpss_pipe_stitch_info;
typedef struct {
xmedia_bool pipe_en;
xmedia_s32 pipe_no;
xmedia_vpss_pipe_config pipe_config;
vpss_chn_info chn_info[VPSS_MAX_PHY_OCHN_NUM];
xmedia_video_crop_attr crop_attr;
xmedia_isp_stnr_attr stnr_attr;
xmedia_isp_sharpen_attr sharpen_attr;
vpss_pipe_stitch_info stitch_attr;
vpss_ext_chn_info ext_chn_info[VPSS_MAX_EXT_OCHN_NUM];
} vpss_pipe_info;
typedef struct {
vpss_pipe_info pipe_info[VPSS_MAX_PIPE_NUM];
} sample_vpss_config;
xmedia_s32 sample_comm_vpss_create_pipe(xmedia_s32 pipe_id, vpss_pipe_info* pipe_info);
xmedia_s32 sample_comm_vpss_destory_pipe(xmedia_s32 pipe_id);
xmedia_s32 sample_comm_vpss_set_chn_attr(xmedia_s32 pipe_id, xmedia_s32 chn_id, vpss_chn_info *chn_info);
xmedia_s32 sample_comm_vpss_get_default_pipe_cfg(xmedia_vpss_pipe_config *pipe_cfg, xmedia_video_size in_size, sample_comm_video_param *video_param);
xmedia_s32 sample_comm_vpss_get_default_ochn_cfg(xmedia_vpss_ochn_config *ochn_cfg, xmedia_video_size out_size, sample_comm_video_param *video_param);
xmedia_s32 sample_comm_vpss_set_ochn_wrap(vpss_chn_info *ochn_info);
xmedia_s32 sample_comm_vpss_pipe_chn_start(sample_vpss_config *vpss_cfg);
xmedia_s32 sample_comm_vpss_pipe_chn_stop(sample_vpss_config *vpss_cfg);
xmedia_s32 sample_comm_vpss_start(sample_vpss_config *vpss_cfg);
xmedia_s32 sample_comm_vpss_stop(sample_vpss_config *vpss_cfg);
xmedia_s32 sample_comm_vpss_init();
xmedia_s32 sample_comm_vpss_exit();
#ifdef __cplusplus
}
#endif
#endif