678 lines
21 KiB
C
Executable File
678 lines
21 KiB
C
Executable File
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include "fh_common.h"
|
|
#include "fh_system_mpi.h"
|
|
#include "fh_vb_mpi.h"
|
|
#include "fh_defines.h"
|
|
#include "vmm_api.h"
|
|
#include "fh_vo_mpi.h"
|
|
#include "types/bufCtrl.h"
|
|
|
|
#include "common.h"
|
|
|
|
/*==========================================================================================================*/
|
|
|
|
#ifdef SAMPLE_VO_DEBUG
|
|
#define SAMPLE_VO_PRT(msg, ...) \
|
|
do {\
|
|
printf("[Func]:%s [Line]:%d: " msg "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
|
}while(0)
|
|
#else
|
|
#define SAMPLE_VO_PRT(msg, ...) do{}while(0)
|
|
#endif
|
|
|
|
#define SAMPLE_VO_CHECK(cond, msg, ...) \
|
|
if(cond) { \
|
|
printf("[Func]:%s [Line]:%d: " msg "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
|
} \
|
|
|
|
#define SAMPLE_VO_CHECK_GOTO(cond, label, msg, ...) \
|
|
if(cond) { \
|
|
printf("[Func]:%s [Line]:%d: " msg "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
|
goto label; \
|
|
} \
|
|
|
|
#define SAMPLE_PRT(fmt...) \
|
|
do {\
|
|
printf("[%s]-%d: ", __FUNCTION__, __LINE__);\
|
|
printf(fmt);\
|
|
}while(0)
|
|
|
|
#define ALIGN_BACK(x, a) ((a) * (((x) / (a))))
|
|
|
|
#define SAMPLE_VO_DEV_DHD0 0
|
|
#define SAMPLE_VO_LAYER_VHD0 0
|
|
#define SAMPLE_VO_LAYER_VPIP 3
|
|
#define SAMPLE_VO_DEV_DSD0 1
|
|
#define SAMPLE_VO_LAYER_VSD0 1
|
|
|
|
#define SAMPLE_PIXEL_FORMAT PIXEL_FMT_YUV_SEMIPLANAR_422
|
|
|
|
static FH_BOOL gs_bEnableLcd = FH_FALSE;
|
|
static FH_BOOL gs_bEnableVhd0Single = FH_FALSE;
|
|
static FH_BOOL gs_bEnableCompress = FH_FALSE;
|
|
static FH_UINT32 g_bEnablePIP = FH_FALSE;
|
|
|
|
/*==========================================================================================================*/
|
|
|
|
FH_SINT32 SAMPLE_COMM_VO_GetWH(VO_INTF_SYNC_E enIntfSync, FH_UINT32 *pu32W,FH_UINT32 *pu32H, FH_UINT32 *pu32Frm)
|
|
{
|
|
switch (enIntfSync)
|
|
{
|
|
case VO_OUTPUT_960H_NTSC : *pu32W = 480; *pu32H = 960; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_PAL : *pu32W = 720; *pu32H = 576; *pu32Frm = 25; break;
|
|
case VO_OUTPUT_NTSC : *pu32W = 720; *pu32H = 480; *pu32Frm = 30; break;
|
|
case VO_OUTPUT_576P50 : *pu32W = 720; *pu32H = 576; *pu32Frm = 50; break;
|
|
case VO_OUTPUT_480P60 : *pu32W = 720; *pu32H = 480; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_800x480_60: *pu32W = 800; *pu32H = 480; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_800x600_60: *pu32W = 800; *pu32H = 600; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_800x1280_60: *pu32W = 800; *pu32H = 1280; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_720P50 : *pu32W = 1280; *pu32H = 720; *pu32Frm = 50; break;
|
|
case VO_OUTPUT_720P60 : *pu32W = 1280; *pu32H = 720; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_1080I50 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 25; break;
|
|
case VO_OUTPUT_1080I60 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 30; break;
|
|
case VO_OUTPUT_1080P24 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 24; break;
|
|
case VO_OUTPUT_1080P25 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 25; break;
|
|
case VO_OUTPUT_1080P30 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 30; break;
|
|
case VO_OUTPUT_1080P50 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 50; break;
|
|
case VO_OUTPUT_1080P60 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_1024x600_60: *pu32W = 1024; *pu32H = 600; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_1024x768_60: *pu32W = 1024; *pu32H = 768; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_1280x1024_60: *pu32W = 1280; *pu32H = 1024; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_1366x768_60: *pu32W = 1366; *pu32H = 768; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_1440x900_60: *pu32W = 1440; *pu32H = 900; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_1280x800_60: *pu32W = 1280; *pu32H = 800; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_1600x1200_60: *pu32W = 1600; *pu32H = 1200; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_1680x1050_60: *pu32W = 1680; *pu32H = 1050; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_1920x1200_60: *pu32W = 1920; *pu32H = 1200; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_2560x1440_30: *pu32W = 2560; *pu32H = 1440; *pu32Frm = 30; break;
|
|
case VO_OUTPUT_2560x1440_60: *pu32W = 2560; *pu32H = 1440; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_3840x2160_30: *pu32W = 3840; *pu32H = 2160; *pu32Frm = 30; break;
|
|
case VO_OUTPUT_3840x2160_60: *pu32W = 3840; *pu32H = 2160; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_4096x2160_30: *pu32W = 4096; *pu32H = 2160; *pu32Frm = 30; break;
|
|
case VO_OUTPUT_640x480_60: *pu32W = 640; *pu32H = 480; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_240x320_60: *pu32W = 240; *pu32H = 320; *pu32Frm = 60; break;
|
|
case VO_OUTPUT_USER : *pu32W = 240; *pu32H = 320; *pu32Frm = 30; break;
|
|
default:
|
|
SAMPLE_PRT("vo enIntfSync not support!\n");
|
|
return FH_FAILURE;
|
|
}
|
|
return FH_SUCCESS;
|
|
}
|
|
FH_SINT32 SAMPLE_COMM_VO_GetChnRect(VO_CHN voChn, SAMPLE_VO_MODE_E enMode, FH_SIZE *pstSize, RECT_S* pstRect)
|
|
{
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
FH_UINT32 u32WndNum = 0;
|
|
FH_UINT32 u32Square = 0;
|
|
FH_UINT32 u32CellH = 0;
|
|
FH_UINT32 u32CellW = 0;
|
|
FH_SINT32 s32XO = 0, s32YO = 0;
|
|
|
|
if (NULL == pstSize || NULL == pstRect) {
|
|
s32Ret = FH_ERR_VO_NULL_PTR;
|
|
goto EXIT;
|
|
}
|
|
|
|
switch (enMode) {
|
|
case VO_MODE_1MUX:
|
|
u32WndNum = 1;
|
|
u32Square = 1;
|
|
break;
|
|
case VO_MODE_4MUX:
|
|
u32WndNum = 4;
|
|
u32Square = 2;
|
|
break;
|
|
case VO_MODE_9MUX:
|
|
u32WndNum = 9;
|
|
u32Square = 3;
|
|
break;
|
|
case VO_MODE_16MUX:
|
|
u32WndNum = 16;
|
|
u32Square = 4;
|
|
break;
|
|
case VO_MODE_1B_5S:
|
|
u32WndNum = 6;
|
|
u32Square = 3;
|
|
break;
|
|
case VO_MODE_1B_7S:
|
|
u32WndNum = 8;
|
|
u32Square = 4;
|
|
break;
|
|
case VO_MODE_1L_1R:
|
|
u32WndNum = 2;
|
|
u32Square = 2;
|
|
break;
|
|
case VO_MODE_25MUX:
|
|
u32WndNum = 25;
|
|
u32Square = 5;
|
|
break;
|
|
case VO_MODE_36MUX:
|
|
u32WndNum = 36;
|
|
u32Square = 6;
|
|
break;
|
|
case VO_MODE_49MUX:
|
|
u32WndNum = 49;
|
|
u32Square = 7;
|
|
break;
|
|
case VO_MODE_64MUX:
|
|
u32WndNum = 64;
|
|
u32Square = 8;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (VO_MODE_1L_1R == enMode) {
|
|
u32CellW = ALIGN_BACK(pstSize->u32Width/u32Square, 16);
|
|
u32CellH = ALIGN_BACK(pstSize->u32Height, 2);
|
|
s32XO = ALIGN_BACK((pstSize->u32Width - u32CellW*u32Square)/2, 2);
|
|
s32YO = ALIGN_BACK((pstSize->u32Height - u32CellH)/2, 2);
|
|
} else {
|
|
u32CellW = ALIGN_BACK(pstSize->u32Width/u32Square, 16);
|
|
u32CellH = ALIGN_BACK(pstSize->u32Height/u32Square, 2);
|
|
s32XO = ALIGN_BACK((pstSize->u32Width - u32CellW*u32Square)/2, 2);
|
|
s32YO = ALIGN_BACK((pstSize->u32Height - u32CellH*u32Square)/2, 2);
|
|
}
|
|
|
|
|
|
if (voChn < u32WndNum) {
|
|
if (VO_MODE_1L_1R == enMode) {
|
|
if (0 == voChn) {
|
|
pstRect->s32X = s32XO;
|
|
pstRect->s32Y = s32YO;
|
|
pstRect->u32Width = u32CellW;
|
|
pstRect->u32Height = u32CellH;
|
|
} else if (1 == voChn){
|
|
pstRect->s32X = s32XO + u32CellW;
|
|
pstRect->s32Y = s32YO;
|
|
pstRect->u32Width = u32CellW;
|
|
pstRect->u32Height = u32CellH;
|
|
}
|
|
} else {
|
|
if (VO_MODE_1B_5S == enMode || VO_MODE_1B_7S == enMode) {
|
|
if (0 == voChn) {
|
|
pstRect->s32X = s32XO;
|
|
pstRect->s32Y = s32YO;
|
|
} else if (voChn >= u32WndNum - u32Square) {
|
|
pstRect->s32X = u32CellW * (voChn + u32Square - u32WndNum) + s32XO;
|
|
pstRect->s32Y = u32CellH * (u32Square - 1) + s32YO;
|
|
} else {
|
|
pstRect->s32X = u32CellW * (u32Square - 1) + s32XO;
|
|
pstRect->s32Y = u32CellH * (voChn - 1) + s32YO;
|
|
}
|
|
} else {
|
|
pstRect->s32X = u32CellW * (voChn % u32Square) + s32XO;
|
|
pstRect->s32Y = u32CellH * (voChn / u32Square) + s32YO;
|
|
}
|
|
|
|
if ((0 == voChn) && (VO_MODE_1B_5S == enMode || VO_MODE_1B_7S == enMode)) {
|
|
pstRect->u32Width = u32CellW * (u32Square -1);
|
|
pstRect->u32Height = u32CellH * (u32Square -1);
|
|
} else {
|
|
pstRect->u32Width = u32CellW;
|
|
pstRect->u32Height = u32CellH;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
EXIT:
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
FH_SINT32 SAMPLE_COMM_VO_StartDev(VO_DEV VoDev, VO_PUB_ATTR_S *pstPubAttr)
|
|
{
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
|
|
s32Ret = FH_VO_SetPubAttr(VoDev, pstPubAttr);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
s32Ret = FH_VO_Enable(VoDev);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
FH_SINT32 SAMPLE_COMM_VO_StopDev(VO_DEV VoDev)
|
|
{
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
|
|
s32Ret = FH_VO_Disable(VoDev);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("VoDev:%d,failed with %#x!\n", VoDev,s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
return s32Ret;
|
|
}
|
|
|
|
FH_SINT32 SAMPLE_COMM_VO_StartLayer(VO_LAYER VoLayer,const VO_VIDEO_LAYER_ATTR_S *pstLayerAttr)
|
|
{
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
s32Ret = FH_VO_SetVideoLayerAttr(VoLayer, pstLayerAttr);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
s32Ret = FH_VO_EnableVideoLayer(VoLayer);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
FH_SINT32 SAMPLE_COMM_VO_StopLayer(VO_LAYER VoLayer)
|
|
{
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
|
|
s32Ret = FH_VO_DisableVideoLayer(VoLayer);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
return s32Ret;
|
|
}
|
|
|
|
FH_SINT32 SAMPLE_COMM_VO_StartCompressedLayer(VO_LAYER VoLayer,const VO_VIDEO_LAYER_ATTR_S *pstLayerAttr)
|
|
{
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
VO_COMPRESS_ATTR_S stCompressAttr = {.bSupportCompress = FH_TRUE,};
|
|
|
|
s32Ret = FH_VO_SetVideoLayerAttr(VoLayer, pstLayerAttr);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
s32Ret = FH_VO_SetVideoLayerCompressAttr(VoLayer, &stCompressAttr);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
s32Ret = FH_VO_EnableVideoLayer(VoLayer);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
return s32Ret;
|
|
}
|
|
FH_SINT32 SAMPLE_COMM_VO_StartSingleLayer(VO_LAYER VoLayer,const VO_VIDEO_LAYER_ATTR_S *pstLayerAttr, FH_BOOL isSingle)
|
|
{
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
VO_PART_MODE_E enPartMode = VO_PART_MODE_SINGLE;
|
|
VO_COMPRESS_ATTR_S stCompressAttr = {.bSupportCompress = FH_TRUE,};
|
|
|
|
s32Ret = FH_VO_SetVideoLayerAttr(VoLayer, pstLayerAttr);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
s32Ret = FH_VO_SetVideoLayerPartitionMode(VoLayer, enPartMode);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
s32Ret = FH_VO_SetVideoLayerCompressAttr(VoLayer, &stCompressAttr);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
s32Ret = FH_VO_EnableVideoLayer(VoLayer);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
FH_SINT32 SAMPLE_COMM_VO_StartChn(VO_LAYER VoLayer, SAMPLE_VO_MODE_E enMode)
|
|
{
|
|
FH_SINT32 i;
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
FH_UINT32 u32WndNum = 0;
|
|
VO_CHN_ATTR_S stChnAttr;
|
|
VO_VIDEO_LAYER_ATTR_S stLayerAttr;
|
|
FH_SINT32 s32ChnFrmRate;
|
|
|
|
switch (enMode)
|
|
{
|
|
case VO_MODE_1MUX:
|
|
u32WndNum = 1;
|
|
break;
|
|
case VO_MODE_4MUX:
|
|
u32WndNum = 4;
|
|
break;
|
|
case VO_MODE_9MUX:
|
|
u32WndNum = 9;
|
|
break;
|
|
case VO_MODE_16MUX:
|
|
u32WndNum = 16;
|
|
break;
|
|
case VO_MODE_25MUX:
|
|
u32WndNum = 25;
|
|
break;
|
|
case VO_MODE_36MUX:
|
|
u32WndNum = 36;
|
|
break;
|
|
case VO_MODE_49MUX:
|
|
u32WndNum = 49;
|
|
break;
|
|
case VO_MODE_64MUX:
|
|
u32WndNum = 64;
|
|
break;
|
|
case VO_MODE_1B_5S:
|
|
u32WndNum = 6;
|
|
break;
|
|
case VO_MODE_1B_7S:
|
|
u32WndNum = 8;
|
|
break;
|
|
case VO_MODE_1L_1R:
|
|
u32WndNum = 2;
|
|
break;
|
|
|
|
break;
|
|
default:
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
s32Ret = FH_VO_GetVideoLayerAttr(VoLayer, &stLayerAttr);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
if (stLayerAttr.u32DispFrmRt <= 0)
|
|
{
|
|
s32ChnFrmRate = 30;
|
|
}
|
|
else if (stLayerAttr.u32DispFrmRt > 30)
|
|
{
|
|
s32ChnFrmRate = stLayerAttr.u32DispFrmRt / 2;
|
|
}
|
|
else
|
|
{
|
|
s32ChnFrmRate = stLayerAttr.u32DispFrmRt;
|
|
}
|
|
|
|
FH_VO_SetAttrBegin(VoLayer);
|
|
|
|
for (i=0; i<u32WndNum; i++)
|
|
{
|
|
s32Ret = SAMPLE_COMM_VO_GetChnRect(i, enMode, &stLayerAttr.stImageSize, &stChnAttr.stRect);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
stChnAttr.u32Priority = 0;
|
|
stChnAttr.bDeflicker = FH_FALSE;
|
|
|
|
s32Ret = FH_VO_SetChnAttr(VoLayer, i, &stChnAttr);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
printf("%s(%d):failed with %#x!\n", __FUNCTION__, __LINE__, s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
s32Ret = FH_VO_SetChnFrameRate(VoLayer, i, s32ChnFrmRate);
|
|
if (FH_SUCCESS != s32Ret)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
s32Ret = FH_VO_EnableChn(VoLayer, i);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
}
|
|
|
|
FH_VO_SetAttrEnd(VoLayer);
|
|
|
|
return FH_SUCCESS;
|
|
}
|
|
FH_SINT32 SAMPLE_COMM_VO_StopChn(VO_LAYER VoLayer, SAMPLE_VO_MODE_E enMode)
|
|
{
|
|
FH_SINT32 i;
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
FH_UINT32 u32WndNum = 0;
|
|
|
|
switch (enMode)
|
|
{
|
|
case VO_MODE_1MUX:
|
|
u32WndNum = 1;
|
|
break;
|
|
case VO_MODE_4MUX:
|
|
u32WndNum = 4;
|
|
break;
|
|
case VO_MODE_9MUX:
|
|
u32WndNum = 9;
|
|
break;
|
|
case VO_MODE_16MUX:
|
|
u32WndNum = 16;
|
|
break;
|
|
case VO_MODE_1B_5S:
|
|
u32WndNum = 6;
|
|
break;
|
|
case VO_MODE_1B_7S:
|
|
u32WndNum = 8;
|
|
break;
|
|
case VO_MODE_1L_1R:
|
|
u32WndNum = 2;
|
|
break;
|
|
case VO_MODE_25MUX:
|
|
u32WndNum = 25;
|
|
break;
|
|
case VO_MODE_36MUX:
|
|
u32WndNum = 36;
|
|
break;
|
|
case VO_MODE_49MUX:
|
|
u32WndNum = 49;
|
|
break;
|
|
case VO_MODE_64MUX:
|
|
u32WndNum = 64;
|
|
break;
|
|
default:
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
|
|
for (i=0; i<u32WndNum; i++)
|
|
{
|
|
s32Ret = FH_VO_DisableChn(VoLayer, i);
|
|
if (s32Ret != FH_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("failed with %#x!\n", s32Ret);
|
|
return FH_FAILURE;
|
|
}
|
|
}
|
|
return s32Ret;
|
|
}
|
|
|
|
|
|
FH_SINT32 vo_test_init(int bIsHD, int _enIntf)
|
|
{
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
VO_DEV VoDev;
|
|
VO_LAYER VoLayer;
|
|
VO_PUB_ATTR_S stVoPubAttr;
|
|
VO_VIDEO_LAYER_ATTR_S stLayerAttr;
|
|
VO_INTF_SYNC_E enIntf = _enIntf;
|
|
|
|
if (bIsHD) {
|
|
SAMPLE_VO_PRT("start DHD0.");
|
|
VoDev = SAMPLE_VO_DEV_DHD0;
|
|
VoLayer = SAMPLE_VO_LAYER_VHD0;
|
|
|
|
stVoPubAttr.enIntfSync = enIntf;
|
|
if (gs_bEnableLcd == FH_TRUE) {
|
|
stVoPubAttr.enIntfType = VO_INTF_LCD;
|
|
}
|
|
else{
|
|
stVoPubAttr.enIntfType = VO_INTF_VGA|VO_INTF_HDMI;
|
|
}
|
|
stVoPubAttr.u32BgColor = 0; //0x00FFFFFF
|
|
s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stVoPubAttr);
|
|
SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartDev failed!");
|
|
|
|
memset(&(stLayerAttr), 0 , sizeof(VO_VIDEO_LAYER_ATTR_S));
|
|
s32Ret = SAMPLE_COMM_VO_GetWH(stVoPubAttr.enIntfSync, \
|
|
&stLayerAttr.stImageSize.u32Width, \
|
|
&stLayerAttr.stImageSize.u32Height, \
|
|
&stLayerAttr.u32DispFrmRt);
|
|
SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_GetWH failed!");
|
|
|
|
stLayerAttr.enPixFormat = SAMPLE_PIXEL_FORMAT;
|
|
stLayerAttr.stDispRect.s32X = 0;
|
|
stLayerAttr.stDispRect.s32Y = 0;
|
|
stLayerAttr.stDispRect.u32Width = stLayerAttr.stImageSize.u32Width;
|
|
stLayerAttr.stDispRect.u32Height = stLayerAttr.stImageSize.u32Height;
|
|
|
|
if (gs_bEnableVhd0Single) {
|
|
SAMPLE_VO_PRT("start single VHD0.");
|
|
s32Ret = SAMPLE_COMM_VO_StartSingleLayer(VoLayer, &stLayerAttr, FH_TRUE);
|
|
SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartSingleLayer failed!");
|
|
} else if (gs_bEnableCompress) {
|
|
SAMPLE_VO_PRT("start compressed VHD0.");
|
|
s32Ret = SAMPLE_COMM_VO_StartCompressedLayer(VoLayer, &stLayerAttr);
|
|
SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartCompressedLayer failed!");
|
|
} else {
|
|
SAMPLE_VO_PRT("start VHD0.");
|
|
s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr);
|
|
SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartLayer failed!");
|
|
}
|
|
|
|
if (g_bEnablePIP) { //ENABLE_PIP
|
|
SAMPLE_VO_PRT("start PIP.");
|
|
VoDev = SAMPLE_VO_DEV_DHD0;
|
|
VoLayer = SAMPLE_VO_LAYER_VPIP;
|
|
|
|
stLayerAttr.stDispRect.s32X = 200;
|
|
stLayerAttr.stDispRect.s32Y = 200;
|
|
stLayerAttr.stDispRect.u32Width = 320;
|
|
stLayerAttr.stDispRect.u32Height = 240;
|
|
|
|
stLayerAttr.stImageSize.u32Width = 320;
|
|
stLayerAttr.stImageSize.u32Height = 320;
|
|
|
|
SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr);
|
|
SAMPLE_COMM_VO_StartChn(VoLayer, VO_MODE_1MUX);
|
|
}
|
|
|
|
} else {
|
|
SAMPLE_VO_PRT("start DSD0.");
|
|
VoDev = SAMPLE_VO_DEV_DSD0;
|
|
VoLayer = SAMPLE_VO_LAYER_VSD0;
|
|
|
|
stVoPubAttr.enIntfSync = enIntf/*VO_OUTPUT_PAL*/;
|
|
stVoPubAttr.enIntfType = VO_INTF_CVBS;
|
|
stVoPubAttr.u32BgColor = 0;
|
|
s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stVoPubAttr);
|
|
SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartDev failed!");
|
|
|
|
memset(&(stLayerAttr), 0 , sizeof(VO_VIDEO_LAYER_ATTR_S));
|
|
s32Ret = SAMPLE_COMM_VO_GetWH(stVoPubAttr.enIntfSync, \
|
|
&stLayerAttr.stImageSize.u32Width, \
|
|
&stLayerAttr.stImageSize.u32Height, \
|
|
&stLayerAttr.u32DispFrmRt);
|
|
SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_GetWH failed!");
|
|
|
|
SAMPLE_VO_PRT("start VSD0.");
|
|
stLayerAttr.enPixFormat = PIXEL_FMT_YUV_SEMIPLANAR_420;
|
|
stLayerAttr.stDispRect.s32X = 0;
|
|
stLayerAttr.stDispRect.s32Y = 0;
|
|
stLayerAttr.stDispRect.u32Width = stLayerAttr.stImageSize.u32Width;
|
|
stLayerAttr.stDispRect.u32Height = stLayerAttr.stImageSize.u32Height;
|
|
s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr);
|
|
SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartLayer failed!");
|
|
}
|
|
|
|
|
|
EXIT:
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
FH_SINT32 vo_test_exit(FH_BOOL bIsHD)
|
|
{
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
VO_DEV VoDev;
|
|
VO_LAYER VoLayer;
|
|
|
|
|
|
if (g_bEnablePIP) {
|
|
SAMPLE_VO_PRT("stop PIP.");
|
|
VoLayer = SAMPLE_VO_LAYER_VPIP;
|
|
SAMPLE_COMM_VO_StopLayer(VoLayer);
|
|
|
|
SAMPLE_VO_PRT("stop PIP.");
|
|
//VoDev = SAMPLE_VO_DEV_DHD0;
|
|
//SAMPLE_COMM_VO_StopDev(VoDev);
|
|
}
|
|
|
|
if (bIsHD) {
|
|
SAMPLE_VO_PRT("stop VHD0.");
|
|
VoLayer = SAMPLE_VO_LAYER_VHD0;
|
|
SAMPLE_COMM_VO_StopLayer(VoLayer);
|
|
|
|
SAMPLE_VO_PRT("stop DHD0.");
|
|
VoDev = SAMPLE_VO_DEV_DHD0;
|
|
SAMPLE_COMM_VO_StopDev(VoDev);
|
|
} else {
|
|
SAMPLE_VO_PRT("stop VSD0.");
|
|
VoLayer = SAMPLE_VO_LAYER_VSD0;
|
|
SAMPLE_COMM_VO_StopLayer(VoLayer);
|
|
|
|
SAMPLE_VO_PRT("stop DSD0.");
|
|
VoDev = SAMPLE_VO_DEV_DSD0;
|
|
SAMPLE_COMM_VO_StopDev(VoDev);
|
|
}
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
int vo_test_startlayer(int layer, int enMode)
|
|
{
|
|
FH_SINT32 s32Ret = FH_SUCCESS;
|
|
|
|
s32Ret = SAMPLE_COMM_VO_StartChn(layer,enMode);
|
|
return s32Ret;
|
|
} |