payton/nt9856x
Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
500637db5b
nt9856x/code/application/source/cardv/SrcCode/UIApp/AppDisp_PBView.c
xiaojiazhu 4640033758 Merge code of ding.
2023-11-15 11:16:56 +08:00

1860 lines
62 KiB
C
Executable File
Raw Blame History

#include "SysCommon.h"
#include "AppDisp_PBView.h"
#include "PlaybackTsk.h"
#include "vf_gfx.h"
#include "GxVideo.h"
#include <kwrap/error_no.h>
#include <kwrap/util.h>
#include "exif/Exif.h"
#include "exif/ExifDef.h"
#include "SizeConvert.h"
#include "kwrap/perf.h"
#include "PlaybackTsk.h"
#include "GxVideoFile.h"
#include "sys_mempool.h"
#include "UIWnd/UIFlow.h"
#include "lfqueue/lfqueue.h"
///////////////////////////////////////////////////////////////////////////////
#define __MODULE__ PBVIEW
#define __DBGLVL__ 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER
#define __DBGFLT__ "*" //*=All, [mark]=CustomClass
#include <kwrap/debug.h>
///////////////////////////////////////////////////////////////////////////////
#define COLOR_RGB_BLACK 0x00000000
static USIZE aspect_ratio;
static ER (*gfpDrawCb)(HD_VIDEO_FRAME *pHdDecVdoFrame, PUSIZE dst_ratio);
static UINT32 gPbState = PB_VIEW_STATE_NONE;
static HD_VIDEO_FRAME g_LastVdoFrm = {0}; //keep last disp screen
#if PLAY_THUMB_AND_MOVIE // play thumbnail and movie together
static HD_VIDEO_FRAME g_DispTmpFrm = {0}; // display tmp frame
static HD_VIDEO_FRAME g_ThumbFrm[FLOWPB_THUMB_H_NUM2*FLOWPB_THUMB_V_NUM2] = {0}; // thumbnail frame
#endif
static const char pbview_videoout_task_name[] = "PBView_Vout_Task";
typedef struct {
THREAD_HANDLE id;
UINT run;
UINT is_running;
lfqueue_t lfqueue;
} PBView_videoout_task_param;
typedef struct {
HD_PATH_ID path_id;
HD_VIDEO_FRAME push_in_frame;
/* buffers need to be released after frame pushed */
PBVIEW_HD_COM_BUF relesse_view_buf;
PBVIEW_HD_COM_BUF release_2pass_buf;
} lfqueue_videoout_param;
PBView_videoout_task_param* get_videoout_task_param(void)
{
static PBView_videoout_task_param* param = NULL;
if(param == NULL){
DBG_DUMP("init lfqueue\r\n");
param = (PBView_videoout_task_param*) malloc(sizeof(PBView_videoout_task_param));
memset(param, 0, sizeof(PBView_videoout_task_param));
lfqueue_init(&param->lfqueue);
}
return param;
}
THREAD_RETTYPE _PBView_videoout_task(void)
{
HD_RESULT ret = HD_OK;
PBView_videoout_task_param* task_param = NULL;
lfqueue_videoout_param* lfqueue_param = NULL;
UINT empty_queue_delay_ms = 1;
THREAD_ENTRY();
task_param = get_videoout_task_param();
while(task_param->run)
{
if(!task_param->is_running)
task_param->is_running = 1;
/* sleep when queue is empty */
if((lfqueue_param = lfqueue_deq(&task_param->lfqueue)) == NULL){
vos_util_delay_ms(empty_queue_delay_ms);
continue;
}
ret = hd_videoout_push_in_buf(
lfqueue_param->path_id,
&lfqueue_param->push_in_frame,
NULL,
0);
if (ret != HD_OK && ret != HD_ERR_OVERRUN){
DBG_ERR("failed to push in buf of videoout\r\n");
}
if(lfqueue_param->relesse_view_buf.blk && lfqueue_param->relesse_view_buf.blk!= HD_COMMON_MEM_VB_INVALID_BLK){
hd_common_mem_munmap((void *)lfqueue_param->relesse_view_buf.va, lfqueue_param->relesse_view_buf.blk_size);
ret = hd_common_mem_release_block(lfqueue_param->relesse_view_buf.blk);
if (ret != HD_OK){
DBG_ERR("release blk(0x%x) failed\r\n", lfqueue_param->relesse_view_buf.blk);
}
}
if (lfqueue_param->release_2pass_buf.blk && lfqueue_param->release_2pass_buf.blk!= HD_COMMON_MEM_VB_INVALID_BLK) {
hd_common_mem_munmap((void *)lfqueue_param->release_2pass_buf.va, lfqueue_param->release_2pass_buf.blk_size);
ret = hd_common_mem_release_block(lfqueue_param->release_2pass_buf.blk);
if (ret != HD_OK){
DBG_ERR("release 2-pass blk(0x%x) failed\r\n", lfqueue_param->release_2pass_buf.blk);
}
}
if(lfqueue_param){
free(lfqueue_param);
lfqueue_param = NULL;
}
}
task_param->is_running = 0;
THREAD_RETURN(0);
}
ER PBView_videoout_task_create(void)
{
ER ret = E_OK;
const char* task_name = pbview_videoout_task_name;
const int priority = 9;
const int stack_size = 2048;
PBView_videoout_task_param* task_param = get_videoout_task_param();
if(!task_param->id){
if ((task_param->id = vos_task_create(_PBView_videoout_task, 0, task_name, priority, stack_size)) == 0) {
DBG_ERR("%s create failed.\r\n", pbview_videoout_task_name);
ret |= E_SYS;
} else {
DBG_DUMP("%s created\r\n", task_name);
task_param->run = 1;
vos_task_resume(task_param->id);
}
}
return ret;
}
void PBView_videoout_task_destroy(void)
{
const UINT timeout = 500;
const UINT delay_ms = 1;
UINT cnt = 0;
PBView_videoout_task_param* task_param = get_videoout_task_param();
task_param->run = 0;
while(task_param->is_running && (cnt++ < timeout))
{
vos_util_delay_ms(delay_ms);
}
if(cnt >= timeout){
DBG_ERR("wait PBView_videoout_task finish timeout(over %s ms)\r\n", timeout*delay_ms);
vos_task_destroy(task_param->id);
}
task_param->id = 0;
DBG_DUMP("%s destroyed\r\n", pbview_videoout_task_name);
}
UINT32 PBView_get_hd_phy_addr(void *va)
{
if (va) {
HD_COMMON_MEM_VIRT_INFO vir_meminfo = {0};
vir_meminfo.va = va;
if (hd_common_mem_get(HD_COMMON_MEM_PARAM_VIRT_INFO, &vir_meminfo) == HD_OK) {
return vir_meminfo.pa;
}
}
return 0;
}
HD_RESULT PBView_get_hd_common_buf(PPBVIEW_HD_COM_BUF p_hd_view_buf)
{
// get memory
p_hd_view_buf->blk = hd_common_mem_get_block(HD_COMMON_MEM_COMMON_POOL, p_hd_view_buf->blk_size, DDR_ID0); // Get block from mem pool
if (p_hd_view_buf->blk == HD_COMMON_MEM_VB_INVALID_BLK) {
DBG_ERR("config_vdo_frm: get blk fail, blk(0x%x)\n", p_hd_view_buf->blk );
return HD_ERR_SYS;
}
p_hd_view_buf->pa = hd_common_mem_blk2pa(p_hd_view_buf->blk); // get physical addr
if (p_hd_view_buf->pa == 0) {
DBG_ERR("config_vdo_frm: blk2pa fail, blk(0x%x)\n", p_hd_view_buf->blk);
return HD_ERR_SYS;
}
p_hd_view_buf->va = (UINT32)hd_common_mem_mmap(HD_COMMON_MEM_MEM_TYPE_CACHE, p_hd_view_buf->pa, p_hd_view_buf->blk_size);
if (p_hd_view_buf->va == 0) {
DBG_ERR("Convert to VA failed for file buffer for decoded buffer!\r\n");
return HD_ERR_SYS;
}
return HD_OK;
}
static void PBView_2PassScale(HD_VIDEO_FRAME *pVdoSrc, HD_VIDEO_FRAME *pVdo2PassSrc)
{
VF_GFX_SCALE gfx_scale = {0};
memcpy((void *)&gfx_scale.src_img, (void *)pVdoSrc, sizeof(HD_VIDEO_FRAME));
memcpy((void *)&gfx_scale.dst_img, (void *)pVdo2PassSrc, sizeof(HD_VIDEO_FRAME));
gfx_scale.src_region.x = 0;
gfx_scale.src_region.y = 0;
gfx_scale.src_region.w = pVdoSrc->dim.w;
gfx_scale.src_region.h = pVdoSrc->dim.h;
gfx_scale.dst_region.x = 0;
gfx_scale.dst_region.y = 0;
gfx_scale.dst_region.w = pVdo2PassSrc->dim.w;
gfx_scale.dst_region.h = pVdo2PassSrc->dim.h;
gfx_scale.quality = HD_GFX_SCALE_QUALITY_BILINEAR;
vf_gfx_scale(&gfx_scale, 0);
}
#if PLAY_THUMB_AND_MOVIE // play thumbnail and movie together
void PBView_DrawSingleView(HD_VIDEO_FRAME *pVdoSrc)
{
HD_RESULT ret = HD_OK;
PBVIEW_HD_COM_BUF hd_view_buf = {0};
PBVIEW_HD_COM_BUF hd_2pass_buf = {0};
VF_GFX_SCALE gfx_scale = {0};
HD_VIDEOOUT_IN video_out_param = {0};
HD_VIDEOOUT_WIN_ATTR video_out_win = {0};
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
HD_PATH_ID video_out_path = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_PATH);
HD_VIDEO_FRAME Vdo2PassSrc = {0}, *pVdoNewSrc = NULL;
UINT32 disp_rotate = GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_SWAPXY);
ISIZE disp_size = GxVideo_GetDeviceSize(DOUT1);
USIZE dst_aspect_ratio = GxVideo_GetDeviceAspect(DOUT1);
ISIZE img_size;
BOOL scale_2pass = FALSE;
disp_size.w /= 2; // single view only on the right half part of display
dst_aspect_ratio.w /= 2; // single view only on the right half part of display
// set scaling image info by original image and display aspect ratio
if ((pVdoSrc->dim.w * dst_aspect_ratio.h) > (dst_aspect_ratio.w * pVdoSrc->dim.h)) {
if ((pVdoSrc->dim.h / 2) > (UINT32)disp_size.h) {
scale_2pass = TRUE;
img_size.w = pVdoSrc->dim.w / 2;
img_size.h = pVdoSrc->dim.h / 2;
} else {
img_size.w = pVdoSrc->dim.w;
img_size.h = pVdoSrc->dim.h;
}
gfx_scale.engine = 0;
gfx_scale.src_region.w = ALIGN_CEIL_4((img_size.h * dst_aspect_ratio.w) / dst_aspect_ratio.h);
gfx_scale.src_region.h = img_size.h;
gfx_scale.src_region.x = (img_size.w - gfx_scale.src_region.w) / 2;
gfx_scale.src_region.y = 0;
gfx_scale.dst_region.w = disp_size.w;
gfx_scale.dst_region.h = disp_size.h;
gfx_scale.dst_region.x = 0;
gfx_scale.dst_region.y = 0;
gfx_scale.quality = HD_GFX_SCALE_QUALITY_BILINEAR;
} else {
if ((pVdoSrc->dim.w / 2) > (UINT32)disp_size.w) {
scale_2pass = TRUE;
img_size.w = pVdoSrc->dim.w / 2;
img_size.h = pVdoSrc->dim.h / 2;
} else {
img_size.w = pVdoSrc->dim.w;
img_size.h = pVdoSrc->dim.h;
}
gfx_scale.engine = 0;
gfx_scale.src_region.w = img_size.w;
gfx_scale.src_region.h = ALIGN_CEIL_4((img_size.w * dst_aspect_ratio.h) / dst_aspect_ratio.w);
gfx_scale.src_region.x = 0;
gfx_scale.src_region.y = (img_size.h - gfx_scale.src_region.h) / 2;
gfx_scale.dst_region.w = disp_size.w;
gfx_scale.dst_region.h = disp_size.h;
gfx_scale.dst_region.x = disp_size.w; // single view is on the right side of display
gfx_scale.dst_region.y = 0;
gfx_scale.quality = HD_GFX_SCALE_QUALITY_BILINEAR;
}
// do 2-pass scaling if necessary
if (scale_2pass) {
hd_2pass_buf.blk_size = img_size.w * img_size.h * 3 / 2;
PBView_get_hd_common_buf(&hd_2pass_buf);
pVdoNewSrc = &Vdo2PassSrc;
loff[0] = img_size.w;
addr[0] = hd_2pass_buf.pa;
loff[1] = img_size.w;
addr[1] = ALIGN_CEIL_4(addr[0] + img_size.w * img_size.h);
ret = vf_init_ex(pVdoNewSrc, img_size.w, img_size.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex: 2-pass src failed\r\n");
return;
}
pVdoNewSrc->blk = hd_2pass_buf.blk;
PBView_2PassScale(pVdoSrc, pVdoNewSrc);
} else {
pVdoNewSrc = pVdoSrc;
}
// scale image to display size
disp_size.w *= 2; // recall original display width
hd_view_buf.blk_size = disp_size.w * disp_size.h * 3 / 2;
PBView_get_hd_common_buf(&hd_view_buf);
loff[0] = disp_size.w;
addr[0] = hd_view_buf.pa;
loff[1] = disp_size.w;
addr[1] = ALIGN_CEIL_4(addr[0] + disp_size.w * disp_size.h);
ret = vf_init_ex(&gfx_scale.dst_img, disp_size.w, disp_size.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex dst failed\r\n");
return;
}
#if 0 // clear buffer
VF_GFX_DRAW_RECT draw_rect = {0};
memcpy((void *)&draw_rect.dst_img, (void *)&gfx_scale.dst_img, sizeof(HD_VIDEO_FRAME));
draw_rect.color = COLOR_RGB_BLACK;
draw_rect.rect.x = 0;
draw_rect.rect.y = 0;
draw_rect.rect.w = disp_size.w;
draw_rect.rect.h = disp_size.h;
draw_rect.type = HD_GFX_RECT_SOLID;
draw_rect.thickness = 0; //Don't care for HD_GFX_RECT_SOLID
draw_rect.engine = 0;
vf_gfx_draw_rect(&draw_rect);
#endif
memcpy((void *)&gfx_scale.src_img, (void *)pVdoNewSrc, sizeof(HD_VIDEO_FRAME));
vf_gfx_scale(&gfx_scale, 1);
gfx_scale.dst_img.blk = hd_view_buf.blk; //must for HD_VIDEOOUT
#if 1
// copy left part of display tmp buffer (thumbnail layout) to display buffer
VF_GFX_COPY gfx_copy;
gfx_copy.src_img = g_DispTmpFrm;
gfx_copy.dst_img = gfx_scale.dst_img;
//if ((ret = vf_init(&gfx_copy.dst_img, gfx_scale.dst_img.dim.w, gfx_scale.dst_img.dim.h, gfx_scale.dst_img.pxlfmt, gfx_scale.dst_img.loff[0], hd_view_buf.pa, hd_view_buf.blk_size)) != HD_OK) {
// DBG_ERR("vf_init fail(%d)\r\n", ret);
//}
gfx_copy.src_region.x = 0;
gfx_copy.src_region.y = 0;
gfx_copy.src_region.w = gfx_scale.dst_img.dim.w/2;
gfx_copy.src_region.h = gfx_scale.dst_img.dim.h;
gfx_copy.dst_pos.x = 0;
gfx_copy.dst_pos.y = 0;
gfx_copy.colorkey = 0;
gfx_copy.alpha = 255;
gfx_copy.engine = 0;
if ((ret = vf_gfx_copy(&gfx_copy)) != HD_OK) {
DBG_ERR("vf_gfx_copy fail(%d)\r\n", ret);
}
#endif
// set video out parameter
video_out_param.dim.w = disp_size.w;
video_out_param.dim.h = disp_size.h;
video_out_param.pxlfmt = HD_VIDEO_PXLFMT_YUV420;
video_out_param.dir = SysVideo_GetDirbyID(0);
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN, &video_out_param);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_set: HD_VIDEOOUT_PARAM_IN failed\r\n");
return;
}
// set video out window
video_out_win.visible = TRUE;
video_out_win.layer = HD_LAYER1;
video_out_win.rect.x = 0;
video_out_win.rect.y = 0;
if (disp_rotate) {
video_out_win.rect.w = disp_size.h;
video_out_win.rect.h = disp_size.w;
} else {
video_out_win.rect.w = disp_size.w;
video_out_win.rect.h = disp_size.h;
}
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN_WIN_ATTR, &video_out_win);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_set: HD_VIDEOOUT_PARAM_IN_WIN_ATTR fail\r\n");
}
ret = hd_videoout_start(video_out_path);
if(ret != HD_OK){
DBG_ERR("hd_videoout_start failed\r\n");
return;
}
// push in and release buffer
ret = hd_videoout_push_in_buf(video_out_path, &gfx_scale.dst_img, NULL, 0); // only support non-blocking mode now
if (ret != HD_OK) {
DBG_ERR("failed to push in buf of videoout\r\n");
} else {
hd_common_mem_munmap((void *)hd_view_buf.va, hd_view_buf.blk_size);
ret = hd_common_mem_release_block(hd_view_buf.blk);
if (ret != HD_OK) {
DBG_ERR("release blk(0x%x) failed\r\n", hd_view_buf.blk);
}
memcpy((void *)&g_LastVdoFrm, (void *)&gfx_scale.dst_img, sizeof(HD_VIDEO_FRAME));
}
// release 2-pass scaling buffer if necessary
if (hd_2pass_buf.blk) {
hd_common_mem_munmap((void *)hd_2pass_buf.va, hd_2pass_buf.blk_size);
ret = hd_common_mem_release_block(hd_2pass_buf.blk);
if (ret != HD_OK) {
DBG_ERR("release 2-pass blk(0x%x) failed\r\n", hd_2pass_buf.blk);
}
}
}
#elif PLAY_FULL_DISP // image crop for full display
void PBView_DrawSingleView(HD_VIDEO_FRAME *pVdoSrc)
{
HD_RESULT ret = HD_OK;
PBVIEW_HD_COM_BUF hd_view_buf = {0};
PBVIEW_HD_COM_BUF hd_2pass_buf = {0};
VF_GFX_SCALE gfx_scale = {0};
HD_VIDEOOUT_IN video_out_param = {0};
HD_VIDEOOUT_WIN_ATTR video_out_win = {0};
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
HD_PATH_ID video_out_path = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_PATH);
HD_VIDEO_FRAME Vdo2PassSrc = {0}, *pVdoNewSrc = NULL;
UINT32 disp_rotate = GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_SWAPXY);
ISIZE disp_size = GxVideo_GetDeviceSize(DOUT1);
USIZE dst_aspect_ratio = GxVideo_GetDeviceAspect(DOUT1);
ISIZE img_size;
BOOL scale_2pass = FALSE;
// set scaling image info by original image and display aspect ratio
if ((pVdoSrc->dim.w * dst_aspect_ratio.h) > (dst_aspect_ratio.w * pVdoSrc->dim.h)) {
if ((pVdoSrc->dim.h / 2) > (UINT32)disp_size.h) {
scale_2pass = TRUE;
img_size.w = pVdoSrc->dim.w / 2;
img_size.h = pVdoSrc->dim.h / 2;
} else {
img_size.w = pVdoSrc->dim.w;
img_size.h = pVdoSrc->dim.h;
}
gfx_scale.engine = 0;
gfx_scale.src_region.w = ALIGN_CEIL_4((img_size.h * dst_aspect_ratio.w) / dst_aspect_ratio.h);
gfx_scale.src_region.h = img_size.h;
gfx_scale.src_region.x = (img_size.w - gfx_scale.src_region.w) / 2;
gfx_scale.src_region.y = 0;
gfx_scale.dst_region.w = disp_size.w;
gfx_scale.dst_region.h = disp_size.h;
gfx_scale.dst_region.x = 0;
gfx_scale.dst_region.y = 0;
gfx_scale.quality = HD_GFX_SCALE_QUALITY_BILINEAR;
} else {
if ((pVdoSrc->dim.w / 2) > (UINT32)disp_size.w) {
scale_2pass = TRUE;
img_size.w = pVdoSrc->dim.w / 2;
img_size.h = pVdoSrc->dim.h / 2;
} else {
img_size.w = pVdoSrc->dim.w;
img_size.h = pVdoSrc->dim.h;
}
gfx_scale.engine = 0;
gfx_scale.src_region.w = img_size.w;
gfx_scale.src_region.h = ALIGN_CEIL_4((img_size.w * dst_aspect_ratio.h) / dst_aspect_ratio.w);
gfx_scale.src_region.x = 0;
gfx_scale.src_region.y = (img_size.h - gfx_scale.src_region.h) / 2;
gfx_scale.dst_region.w = disp_size.w;
gfx_scale.dst_region.h = disp_size.h;
gfx_scale.dst_region.x = 0;
gfx_scale.dst_region.y = 0;
gfx_scale.quality = HD_GFX_SCALE_QUALITY_BILINEAR;
}
// do 2-pass scaling if necessary
if (scale_2pass) {
hd_2pass_buf.blk_size = img_size.w * img_size.h * 3 / 2;
PBView_get_hd_common_buf(&hd_2pass_buf);
pVdoNewSrc = &Vdo2PassSrc;
loff[0] = img_size.w;
addr[0] = hd_2pass_buf.pa;
loff[1] = img_size.w;
addr[1] = ALIGN_CEIL_4(addr[0] + img_size.w * img_size.h);
ret = vf_init_ex(pVdoNewSrc, img_size.w, img_size.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex: 2-pass src failed\r\n");
return;
}
pVdoNewSrc->blk = hd_2pass_buf.blk;
PBView_2PassScale(pVdoSrc, pVdoNewSrc);
} else {
pVdoNewSrc = pVdoSrc;
}
// scale image to display size
hd_view_buf.blk_size = disp_size.w * disp_size.h * 3 / 2;
PBView_get_hd_common_buf(&hd_view_buf);
loff[0] = disp_size.w;
addr[0] = hd_view_buf.pa;
loff[1] = disp_size.w;
addr[1] = ALIGN_CEIL_4(addr[0] + disp_size.w * disp_size.h);
ret = vf_init_ex(&gfx_scale.dst_img, disp_size.w, disp_size.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex dst failed\r\n");
return;
}
memcpy((void *)&gfx_scale.src_img, (void *)pVdoNewSrc, sizeof(HD_VIDEO_FRAME));
vf_gfx_scale(&gfx_scale, 1);
gfx_scale.dst_img.blk = hd_view_buf.blk; //must for HD_VIDEOOUT
// set video out parameter
video_out_param.dim.w = disp_size.w;
video_out_param.dim.h = disp_size.h;
video_out_param.pxlfmt = HD_VIDEO_PXLFMT_YUV420;
video_out_param.dir = SysVideo_GetDirbyID(0);
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN, &video_out_param);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_set: HD_VIDEOOUT_PARAM_IN failed\r\n");
return;
}
// set video out window
video_out_win.visible = TRUE;
video_out_win.layer = HD_LAYER1;
video_out_win.rect.x = 0;
video_out_win.rect.y = 0;
if (disp_rotate) {
video_out_win.rect.w = disp_size.h;
video_out_win.rect.h = disp_size.w;
} else {
video_out_win.rect.w = disp_size.w;
video_out_win.rect.h = disp_size.h;
}
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN_WIN_ATTR, &video_out_win);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_set: HD_VIDEOOUT_PARAM_IN_WIN_ATTR fail\r\n");
}
ret = hd_videoout_start(video_out_path);
if(ret != HD_OK){
DBG_ERR("hd_videoout_start failed\r\n");
return;
}
// push in and release buffer
ret = hd_videoout_push_in_buf(video_out_path, &gfx_scale.dst_img, NULL, 0); // only support non-blocking mode now
if (ret != HD_OK) {
DBG_ERR("failed to push in buf of videoout\r\n");
} else {
hd_common_mem_munmap((void *)hd_view_buf.va, hd_view_buf.blk_size);
ret = hd_common_mem_release_block(hd_view_buf.blk);
if (ret != HD_OK) {
DBG_ERR("release blk(0x%x) failed\r\n", hd_view_buf.blk);
}
memcpy((void *)&g_LastVdoFrm, (void *)&gfx_scale.dst_img, sizeof(HD_VIDEO_FRAME));
}
// release 2-pass scaling buffer if necessary
if (hd_2pass_buf.blk) {
hd_common_mem_munmap((void *)hd_2pass_buf.va, hd_2pass_buf.blk_size);
ret = hd_common_mem_release_block(hd_2pass_buf.blk);
if (ret != HD_OK) {
DBG_ERR("release 2-pass blk(0x%x) failed\r\n", hd_2pass_buf.blk);
}
}
}
#else // image full view
//PB_GetParam(PBPRMID_INFO_IMG, (UINT32 *)&hd_vdoframe_info);
void PBView_Zoom(
HD_VIDEO_FRAME *pVdoSrc,
HD_IPOINT* target_pos,
UINT8 ratio
)
{
HD_RESULT rst;
VF_GFX_COPY vf_gfx_copy_param;
UINT32 x_diff, y_diff;
HD_VIDEO_FRAME dst = {0};
UINT32 pb_zoom_pa = 0;
void* pb_zoom_va = 0;
INT32 diff_tmp;
if(target_pos->x < 0){
DBG_WRN("target x can't be negative, fix to zero\n");
target_pos->x = 0;
}
if(target_pos->y < 0){
DBG_WRN("target y can't be negative, fix to zero\n");
target_pos->y = 0;
}
memcpy(&vf_gfx_copy_param.src_img, pVdoSrc, sizeof(HD_VIDEO_FRAME));
vf_gfx_copy_param.alpha = 255;
x_diff = (vf_gfx_copy_param.src_img.dim.w * ratio) / 100;
y_diff = (vf_gfx_copy_param.src_img.dim.h * ratio) / 100;
vf_gfx_copy_param.src_region.w = vf_gfx_copy_param.src_img.dim.w - x_diff;
vf_gfx_copy_param.src_region.h = vf_gfx_copy_param.src_img.dim.h - y_diff;
diff_tmp = (target_pos->x + vf_gfx_copy_param.src_region.w) - vf_gfx_copy_param.src_img.dim.w;
DBG_DUMP("diff x = %d\n", diff_tmp);
if(diff_tmp > 0){
target_pos->x -= diff_tmp;
}
diff_tmp = (target_pos->y + vf_gfx_copy_param.src_region.h) - vf_gfx_copy_param.src_img.dim.h;
DBG_DUMP("diff y = %d\n", diff_tmp);
if(diff_tmp > 0){
target_pos->y -= diff_tmp;
}
vf_gfx_copy_param.src_region.x = target_pos->x;
vf_gfx_copy_param.src_region.y = target_pos->y;
DBG_DUMP("x = %d y = %d w = %lu h = %lu\n", target_pos->x, target_pos->y, vf_gfx_copy_param.src_region.w, vf_gfx_copy_param.src_region.h);
UINT32 size = (vf_gfx_copy_param.src_region.w * vf_gfx_copy_param.src_region.h * 1.5);
if(hd_common_mem_alloc("PBZoom", &pb_zoom_pa, &pb_zoom_va, size, DDR_ID0) != HD_OK){
DBG_ERR("get common mem failed\n");
}
DBG_DUMP("pa = %lx va = %lx\n", pb_zoom_pa, pb_zoom_va);
rst = vf_init(
&dst,
vf_gfx_copy_param.src_region.w,
vf_gfx_copy_param.src_region.h,
vf_gfx_copy_param.src_img.pxlfmt,
vf_gfx_copy_param.src_region.w,
pb_zoom_pa,
size
);
if(rst != HD_OK){
return;
}
memcpy(&vf_gfx_copy_param.dst_img, &dst, sizeof(HD_VIDEO_FRAME));
vf_gfx_copy_param.dst_pos.x = 0;
vf_gfx_copy_param.dst_pos.y = 0;
rst = vf_gfx_copy(&vf_gfx_copy_param);
if(rst != HD_OK){
return;
}
PBView_DrawSingleView(&vf_gfx_copy_param.dst_img);
hd_common_mem_free(pb_zoom_pa, pb_zoom_va);
}
void PBView_DrawSingleView(HD_VIDEO_FRAME *pVdoSrc)
{
HD_RESULT ret = HD_OK;
PBVIEW_HD_COM_BUF hd_view_buf = {0};
PBVIEW_HD_COM_BUF hd_2pass_buf = {0};
HD_VIDEOOUT_SYSCAPS video_out_syscaps;
HD_VIDEOOUT_SYSCAPS *p_video_out_syscaps = &video_out_syscaps;
VF_GFX_SCALE gfx_scale = {0};
HD_VIDEOOUT_IN video_out_param={0};
HD_VIDEOOUT_WIN_ATTR video_out_win = {0};
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
HD_PATH_ID video_out_path = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_PATH);
HD_PATH_ID video_out_ctrl = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_CTRLPATH);
HD_VIDEO_FRAME Vdo2PassSrc = {0}, *pVdoNewSrc = NULL;
float SrcImgRatio, Img2PassRatio;
UINT32 New2PassImgW, New2PassImgH= 0;
SIZECONVERT_INFO CovtInfo = {0};
HD_URECT DstDispRect = {0};
UINT32 disp_rotate = GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_SWAPXY);
USIZE dst_aspect_ratio = GxVideo_GetDeviceAspect(DOUT1);
Img2PassRatio = (float)PBVIEW_2PASS_W/(float)PBVIEW_2PASS_H;
Img2PassRatio = (INT32)(Img2PassRatio*100);
SrcImgRatio = (float)pVdoSrc->dim.w/(float)pVdoSrc->dim.h;
SrcImgRatio = (INT32)(SrcImgRatio*100);
if (SrcImgRatio > Img2PassRatio){ //Source image is 16:9
New2PassImgW = PBVIEW_2PASS_W;
New2PassImgH = ALIGN_CEIL_4(PBVIEW_2PASS_W*9/16);
}else{
New2PassImgW = PBVIEW_2PASS_W;
New2PassImgH = PBVIEW_2PASS_H;
}
if ((pVdoSrc->dim.w > New2PassImgW) && (pVdoSrc->dim.h > New2PassImgH)){
hd_2pass_buf.blk_size = New2PassImgW*New2PassImgH*3/2;
if(PBView_get_hd_common_buf(&hd_2pass_buf) != HD_OK)
{
goto RELEASE_BLK;
}
pVdoNewSrc = &Vdo2PassSrc;
loff[0] = New2PassImgW; //Besides rotate panel, the display device don't consider the line offset.
addr[0] = hd_2pass_buf.pa;
loff[1] = New2PassImgW; //Besides rotate panel, the display device don't consider the line offset.
addr[1] = ALIGN_CEIL_4(addr[0] + New2PassImgW*New2PassImgH);
ret = vf_init_ex(pVdoNewSrc, New2PassImgW, New2PassImgH, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex: 2-pass src failed\r\n");
return;
}
pVdoNewSrc->blk = hd_2pass_buf.blk;
PBView_2PassScale(pVdoSrc, pVdoNewSrc);
}else{
pVdoNewSrc = pVdoSrc;
}
ret = hd_videoout_get(video_out_ctrl, HD_VIDEOOUT_PARAM_SYSCAPS, p_video_out_syscaps);
if (ret != HD_OK) {
DBG_ERR("get video_out_syscaps failed\r\n");
return;
}
CovtInfo.uiSrcWidth = pVdoNewSrc->dim.w;
CovtInfo.uiSrcHeight = pVdoNewSrc->dim.h;
if (disp_rotate) {
CovtInfo.uiDstWidth = p_video_out_syscaps->output_dim.h;
CovtInfo.uiDstHeight = p_video_out_syscaps->output_dim.w;
} else {
CovtInfo.uiDstWidth = p_video_out_syscaps->output_dim.w;
CovtInfo.uiDstHeight = p_video_out_syscaps->output_dim.h;
}
CovtInfo.uiDstWRatio = dst_aspect_ratio.w;
CovtInfo.uiDstHRatio = dst_aspect_ratio.h;
CovtInfo.alignType = SIZECONVERT_ALIGN_FLOOR_32;
DisplaySizeConvert(&CovtInfo);
if (CovtInfo.uiOutWidth && CovtInfo.uiOutHeight) {
if (disp_rotate) {
CovtInfo.uiOutWidth = ALIGN_CEIL_8(CovtInfo.uiOutWidth);
CovtInfo.uiOutHeight = ALIGN_CEIL_8(CovtInfo.uiOutHeight);
CovtInfo.uiOutX = (p_video_out_syscaps->output_dim.h - CovtInfo.uiOutWidth)>>1;
CovtInfo.uiOutY = (p_video_out_syscaps->output_dim.w - CovtInfo.uiOutHeight)>>1;
}
DstDispRect.x = CovtInfo.uiOutX;
DstDispRect.y = CovtInfo.uiOutY;
DstDispRect.w = CovtInfo.uiOutWidth;
DstDispRect.h = CovtInfo.uiOutHeight;
} else {
DstDispRect.x = 0;
DstDispRect.y = 0;
DstDispRect.w = p_video_out_syscaps->output_dim.w;
DstDispRect.h = p_video_out_syscaps->output_dim.h;
}
hd_view_buf.blk_size = DstDispRect.w*DstDispRect.h*3/2;
if(PBView_get_hd_common_buf(&hd_view_buf) != HD_OK)
{
goto RELEASE_BLK;
}
loff[0] = DstDispRect.w; //Besides rotate panel, the display device don't consider the line offset.
addr[0] = hd_view_buf.pa;
loff[1] = DstDispRect.w; //Besides rotate panel, the display device don't consider the line offset.
addr[1] = ALIGN_CEIL_4(addr[0] + DstDispRect.w*DstDispRect.h);
ret = vf_init_ex(&gfx_scale.dst_img, DstDispRect.w, DstDispRect.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex dst failed\r\n");
return;
}
memcpy((void *)&gfx_scale.src_img, (void *)pVdoNewSrc, sizeof(HD_VIDEO_FRAME));
gfx_scale.engine = 0;
gfx_scale.src_region.x = 0;
gfx_scale.src_region.y = 0;
gfx_scale.src_region.w = pVdoSrc->dim.w;
gfx_scale.src_region.h = pVdoSrc->dim.h;
gfx_scale.dst_region.x = 0; // dst frame buffer rather than IDE window.
gfx_scale.dst_region.y = 0; // dst frame buffer rather than IDE window.
gfx_scale.dst_region.w = DstDispRect.w;
gfx_scale.dst_region.h = DstDispRect.h;
gfx_scale.quality = HD_GFX_SCALE_QUALITY_BILINEAR;
vf_gfx_scale(&gfx_scale, 0);
gfx_scale.dst_img.blk = hd_view_buf.blk; //must for HD_VIDEOOUT
video_out_param.dim.w = DstDispRect.w;
video_out_param.dim.h = DstDispRect.h;
video_out_param.pxlfmt = HD_VIDEO_PXLFMT_YUV420;
video_out_param.dir = SysVideo_GetDirbyID(0);
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN, &video_out_param);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_set: HD_VIDEOOUT_PARAM_IN failed\r\n");
return;
}
#if 0
memset((void *)&video_out_param,0,sizeof(HD_VIDEOOUT_IN));
ret = hd_videoout_get(video_out_path, HD_VIDEOOUT_PARAM_IN, &video_out_param);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_get: HD_VIDEOOUT_PARAM_IN failed\r\n");
return;
}
#endif
video_out_win.visible = TRUE;
if (disp_rotate) {
video_out_win.rect.x = DstDispRect.y;
video_out_win.rect.y = DstDispRect.x;
video_out_win.rect.w = DstDispRect.h;
video_out_win.rect.h = DstDispRect.w;
} else {
video_out_win.rect.x = DstDispRect.x;
video_out_win.rect.y = DstDispRect.y;
video_out_win.rect.w = DstDispRect.w;
video_out_win.rect.h = DstDispRect.h;
}
video_out_win.layer = HD_LAYER1;
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN_WIN_ATTR, &video_out_win);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_set: HD_VIDEOOUT_PARAM_IN_WIN_ATTR fail\r\n");
}
ret = hd_videoout_start(video_out_path);
if(ret != HD_OK){
DBG_ERR("hd_videoout_start failed\r\n");
return;
}
#if 0
DBG_ERR("MAKEFOURCC('V','F','R','M') = %d\r\n", MAKEFOURCC('V','F','R','M'));
DBG_ERR("gfx_scale.dst_img.sign = %d\r\n", gfx_scale.dst_img.sign);
DBG_ERR("gfx_scale.dst_img.ddr_id = %d\r\n", gfx_scale.dst_img.ddr_id);
DBG_ERR("gfx_scale.dst_img.pxlfmt = 0x%x\r\n", gfx_scale.dst_img.pxlfmt);
DBG_ERR("gfx_scale.dst_img.dim.w = %d\r\n", gfx_scale.dst_img.dim.w);
DBG_ERR("gfx_scale.dst_img.dim.h = %d\r\n", gfx_scale.dst_img.dim.h);
DBG_ERR("gfx_scale.dst_img.count = %d\r\n", gfx_scale.dst_img.count);
DBG_ERR("gfx_scale.dst_img.timestamp = %d\r\n", gfx_scale.dst_img.timestamp);
DBG_ERR("gfx_scale.dst_img.pw[HD_VIDEO_PINDEX_Y] = %d\r\n", gfx_scale.dst_img.pw[HD_VIDEO_PINDEX_Y]);
DBG_ERR("gfx_scale.dst_img.pw[HD_VIDEO_PINDEX_UV] = %d\r\n", gfx_scale.dst_img.pw[HD_VIDEO_PINDEX_UV]);
DBG_ERR("gfx_scale.dst_img.ph[HD_VIDEO_PINDEX_Y] = %d\r\n", gfx_scale.dst_img.ph[HD_VIDEO_PINDEX_Y]);
DBG_ERR("gfx_scale.dst_img.ph[HD_VIDEO_PINDEX_UV] = %d\r\n", gfx_scale.dst_img.ph[HD_VIDEO_PINDEX_UV]);
DBG_ERR("gfx_scale.dst_img.loff[HD_VIDEO_PINDEX_Y] = %d\r\n", gfx_scale.dst_img.loff[HD_VIDEO_PINDEX_Y]);
DBG_ERR("gfx_scale.dst_img.loff[HD_VIDEO_PINDEX_UV] = %d\r\n", gfx_scale.dst_img.loff[HD_VIDEO_PINDEX_UV]);
DBG_ERR("gfx_scale.dst_img.phy_addr[HD_VIDEO_PINDEX_Y] = 0x%x\r\n", gfx_scale.dst_img.phy_addr[HD_VIDEO_PINDEX_Y]);
DBG_ERR("gfx_scale.dst_img.phy_addr[HD_VIDEO_PINDEX_UV] = 0x%x\r\n", gfx_scale.dst_img.phy_addr[HD_VIDEO_PINDEX_UV]);
DBG_ERR("gfx_scale.dst_img.blk = %d\r\n", gfx_scale.dst_img.blk);
#endif
PBView_videoout_task_param* task_param = get_videoout_task_param();
if(task_param->is_running){
lfqueue_videoout_param* lfqueue_param = (lfqueue_videoout_param*) malloc(sizeof(lfqueue_videoout_param));
memset(lfqueue_param, 0, sizeof(lfqueue_videoout_param));
lfqueue_param->path_id = video_out_path;
lfqueue_param->push_in_frame = gfx_scale.dst_img;
lfqueue_param->relesse_view_buf = hd_view_buf;
lfqueue_param->release_2pass_buf = hd_2pass_buf;
while (lfqueue_enq(&task_param->lfqueue, lfqueue_param) == -1) {
DBG_ERR("ENQ Full ?\r\n");
}
}
else{
// push in and release buffer
ret = hd_videoout_push_in_buf(video_out_path, &gfx_scale.dst_img, NULL, 0); // only support non-blocking mode now
if (ret != HD_OK) {
DBG_ERR("failed to push in buf of videoout\r\n");
}
else{
memcpy((void *)&g_LastVdoFrm, (void *)&gfx_scale.dst_img, sizeof(HD_VIDEO_FRAME));
}
RELEASE_BLK:
if(hd_view_buf.blk && hd_view_buf.blk != HD_COMMON_MEM_VB_INVALID_BLK){
hd_common_mem_munmap((void *)hd_view_buf.va, hd_view_buf.blk_size);
ret = hd_common_mem_release_block(hd_view_buf.blk);
if (ret != HD_OK) {
DBG_ERR("release blk(0x%x) failed\r\n", hd_view_buf.blk);
}
}
// release 2-pass scaling buffer if necessary
if (hd_2pass_buf.blk && hd_2pass_buf.blk != HD_COMMON_MEM_VB_INVALID_BLK) {
hd_common_mem_munmap((void *)hd_2pass_buf.va, hd_2pass_buf.blk_size);
ret = hd_common_mem_release_block(hd_2pass_buf.blk);
if (ret != HD_OK) {
DBG_ERR("release 2-pass blk(0x%x) failed\r\n", hd_2pass_buf.blk);
}
}
}
}
#endif
static ER PBView_DrawMethod(HD_VIDEO_FRAME *pHdDecVdoFrame, PUSIZE dst_aspect_ratio)
{
//--------------------Customer Draw Begin-------------------------------
PBView_DrawSingleView(pHdDecVdoFrame);
//--------------------Customer Draw End---------------------------------
PB_SetPBFlag(PB_SET_FLG_DRAW_END);
return E_OK;
}
static ER PBView_OnSingleDraw(HD_VIDEO_FRAME *pHdDecVdoFrame, PUSIZE dst_aspect_ratio)
{
return PBView_DrawMethod(pHdDecVdoFrame, dst_aspect_ratio);
}
static void PBView_DrawThumbView(UINT32 i, HD_VIDEO_FRAME *pVdoSrc, HD_VIDEO_FRAME *pVdoDstDisp, PUSIZE dst_ratio)
{
UINT32 SrcWidth, SrcHeight; //SrcStart_X, SrcStart_Y
UINT32 DstWidth, DstHeight, DstX, DstY;
UINT8 ucOrientation;
HD_IRECT DstRegion = {0};
PURECT idx_view;
UINT32 width_array, height_array;
BOOL dec_err_array;
BOOL dec_err=TRUE, exif_exist;
UINT32 exif_orient = 0;
VF_GFX_DRAW_RECT DrawRectDst = {0};
VF_GFX_DRAW_RECT *pDrawRectDst = &DrawRectDst;
VF_GFX_SCALE gfx_scale = {0};
HD_VIDEO_FRAME Vdo2PassSrc = {0}, *pVdoNewSrc = NULL;
//INT32 i32VdoDstBlk = pVdoDst->blk;
PBVIEW_HD_COM_BUF hd_2pass_buf = {0};
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
HD_RESULT ret = HD_OK;
PB_GetParam(PBPRMID_THUMB_RECT, (UINT32 *) &idx_view);
PB_GetParam(PBPRMID_THUMB_WIDTH_ARRAY, (UINT32 *) &width_array);
PB_GetParam(PBPRMID_THUMB_HEIGHT_ARRAY, (UINT32 *) &height_array);
PB_GetParam(PBPRMID_THUMB_DEC_ARRAY, (UINT32 *) &dec_err_array);
PB_GetParam(PBPRMID_EXIF_EXIST, (UINT32 *) &exif_exist);
PB_GetParam(PBPRMID_EXIF_ORIENT, (UINT32 *) &exif_orient);
dec_err = *((((BOOL *)dec_err_array) + i));
SrcWidth = *((((UINT32 *)width_array) + i));
SrcHeight = *((((UINT32 *)height_array) + i));
//SrcStart_X = 0;
//SrcStart_Y = 0;
DstWidth = (idx_view + i)->w;
DstHeight = (idx_view + i)->h;
DstX = (idx_view + i)->x;
DstY = (idx_view + i)->y;
// clear BG
if (i == 0) {
memcpy((void *)&pDrawRectDst->dst_img, (void *)pVdoDstDisp, sizeof(HD_VIDEO_FRAME));
pDrawRectDst->color = COLOR_RGB_BLACK;
pDrawRectDst->rect.x = 0;
pDrawRectDst->rect.y = 0;
pDrawRectDst->rect.w = pVdoDstDisp->dim.w;
pDrawRectDst->rect.h = pVdoDstDisp->dim.h;
pDrawRectDst->type = HD_GFX_RECT_SOLID;
pDrawRectDst->thickness = 0; //Don't care for HD_GFX_RECT_SOLID
pDrawRectDst->engine = 0;
vf_gfx_draw_rect(pDrawRectDst);
}
DstRegion.x = DstX;
DstRegion.y = DstY;
DstRegion.w = DstWidth;
DstRegion.h = DstHeight;
// decode error
if (dec_err == TRUE) {
memcpy((void *)&pDrawRectDst->rect, (void *)&DstRegion, sizeof(HD_IRECT));
pDrawRectDst->rect.x = DstX;
pDrawRectDst->rect.y = DstY;
pDrawRectDst->rect.w = DstWidth;
pDrawRectDst->rect.h = DstHeight;
pDrawRectDst->color = COLOR_RGB_BLACK;
pDrawRectDst->type = HD_GFX_RECT_SOLID;
pDrawRectDst->thickness = 0; //Don't care for HD_GFX_RECT_SOLID
pDrawRectDst->engine = 0;
vf_gfx_draw_rect(pDrawRectDst);
}
// decode ok
else {
UINT16 usPBDisplayWidth = pVdoDstDisp->dim.w;
PB_KEEPAR ImageRatioTrans;
if ((SrcWidth == DstWidth) && (SrcHeight == DstHeight)) {
ImageRatioTrans = PB_KEEPAR_NONE;
} else {
ImageRatioTrans = PB_GetImageRatioTrans(SrcWidth, SrcHeight, DstWidth*dst_ratio->w*pVdoDstDisp->dim.h/pVdoDstDisp->dim.w/dst_ratio->h, DstHeight);
}
if (ImageRatioTrans == PB_KEEPAR_LETTERBOXING) {
UINT32 uiTmpHeight;
UINT32 temp;
// Clear buffer..
memcpy((void *)&pDrawRectDst->dst_img, (void *)pVdoDstDisp, sizeof(HD_VIDEO_FRAME));
pDrawRectDst->rect.x = DstX;
pDrawRectDst->rect.y = DstY;
pDrawRectDst->rect.w = DstWidth;
pDrawRectDst->rect.h = DstHeight;
pDrawRectDst->color = COLOR_RGB_BLACK;
pDrawRectDst->type = HD_GFX_RECT_SOLID;
pDrawRectDst->thickness = 0; //Don't care for HD_GFX_RECT_SOLID
pDrawRectDst->engine = 0;
vf_gfx_draw_rect(pDrawRectDst);
uiTmpHeight = DstWidth * SrcHeight / SrcWidth * pVdoDstDisp->dim.h / usPBDisplayWidth * dst_ratio->w / dst_ratio->h;
temp = ((DstHeight - uiTmpHeight) + 1) & 0xFFFFFFFE;
DstHeight = uiTmpHeight;
DstRegion.y = DstRegion.y + (temp >> 1);
}
if (exif_exist) {
ucOrientation = exif_orient;
} else {
ucOrientation = JPEG_EXIF_ORI_DEFAULT;
}
if (ucOrientation != JPEG_EXIF_ORI_DEFAULT) {
if (ucOrientation != JPEG_EXIF_ORI_ROTATE_180) {
UINT32 ulTmpWidth;
ulTmpWidth = DstHeight * SrcHeight / SrcWidth * usPBDisplayWidth / pVdoDstDisp->dim.h * dst_ratio->h / dst_ratio->w;
if (ulTmpWidth > DstWidth) {
// Prevent user from setting strange-ratio thumbnail window
ulTmpWidth = DstWidth / 2;
}
DstRegion.x += ((DstWidth - ulTmpWidth) >> 1);
DstRegion.w = ulTmpWidth;
DstRegion.h = DstHeight;
} else {
DstRegion.w = DstWidth;
DstRegion.h = DstHeight;
}
} else {
DstRegion.w = DstWidth;
DstRegion.h = DstHeight;
}
if ((pVdoSrc->dim.w > PBVIEW_2PASS_W) && (pVdoSrc->dim.h > PBVIEW_2PASS_H)){
hd_2pass_buf.blk_size = PBVIEW_2PASS_W*PBVIEW_2PASS_H*3/2;
PBView_get_hd_common_buf(&hd_2pass_buf);
pVdoNewSrc = &Vdo2PassSrc;
loff[0] = PBVIEW_2PASS_W; //Besides rotate panel, the display device don't consider the line offset.
addr[0] = hd_2pass_buf.pa;
loff[1] = PBVIEW_2PASS_W; //Besides rotate panel, the display device don't consider the line offset.
addr[1] = ALIGN_CEIL_4(addr[0] + PBVIEW_2PASS_W*PBVIEW_2PASS_H);
//ret = vf_init_ex(pVdoNewSrc, PBVIEW_2PASS_W, PBVIEW_2PASS_H, HD_VIDEO_PXLFMT_YUV420, loff, addr);
ret = vf_init_ex(pVdoNewSrc, PBVIEW_2PASS_W, (pVdoSrc->dim.h*PBVIEW_2PASS_W)/pVdoSrc->dim.w, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex dst failed\r\n");
}
pVdoNewSrc->blk = hd_2pass_buf.blk;
PBView_2PassScale(pVdoSrc, pVdoNewSrc);
}else{
pVdoNewSrc = pVdoSrc;
}
memcpy((void *)&gfx_scale.src_img, (void *)pVdoNewSrc, sizeof(HD_VIDEO_FRAME));
memcpy((void *)&gfx_scale.dst_img, (void *)pVdoDstDisp, sizeof(HD_VIDEO_FRAME)); // display device
gfx_scale.src_region.x = 0;
gfx_scale.src_region.y = 0;
gfx_scale.src_region.w = pVdoNewSrc->dim.w;
gfx_scale.src_region.h = pVdoNewSrc->dim.h;
gfx_scale.dst_region.x = DstRegion.x;
gfx_scale.dst_region.y = DstRegion.y;
gfx_scale.dst_region.w = ALIGN_CEIL_4(DstRegion.w);
gfx_scale.dst_region.h = ALIGN_CEIL_4(DstRegion.h);
gfx_scale.quality = HD_GFX_SCALE_QUALITY_BILINEAR;
vf_gfx_scale(&gfx_scale, 1);
#if PLAY_THUMB_AND_MOVIE // play thumbnail and movie together
// copy thumbnail image to thumbnail frame buffer
VF_GFX_COPY gfx_copy;
gfx_copy.src_img = gfx_scale.src_img;
//memcpy((void *)&gfx_copy.src_img, (void *)&gfx_scale.src_img, sizeof(HD_VIDEO_FRAME));
if ((ret = vf_init(&gfx_copy.dst_img, gfx_scale.src_img.dim.w, gfx_scale.src_img.dim.h, gfx_scale.src_img.pxlfmt, gfx_scale.src_img.loff[0], mempool_thumb_frame[i], POOL_SIZE_THUMB_FRAME)) != HD_OK) {
DBG_ERR("vf_init fail(%d)\r\n", ret);
}
gfx_copy.src_region.x = 0;
gfx_copy.src_region.y = 0;
gfx_copy.src_region.w = gfx_scale.src_img.dim.w;
gfx_copy.src_region.h = gfx_scale.src_img.dim.h;
gfx_copy.dst_pos.x = 0;
gfx_copy.dst_pos.y = 0;
gfx_copy.colorkey = 0;
gfx_copy.alpha = 255;
gfx_copy.engine = 0;
if ((ret = vf_gfx_copy(&gfx_copy)) != HD_OK) {
DBG_ERR("vf_gfx_copy fail(%d)\r\n", ret);
}
memcpy((void *)&g_ThumbFrm[i], (void *)&gfx_copy.dst_img, sizeof(HD_VIDEO_FRAME));
#endif
if (hd_2pass_buf.blk != 0){
ret = hd_common_mem_munmap((void *)hd_2pass_buf.va, hd_2pass_buf.blk_size);
if (ret != HD_OK){
DBG_ERR("failed to memory munmap\r\n");
}
ret = hd_common_mem_release_block(hd_2pass_buf.blk);
if (ret != HD_OK){
DBG_ERR("release blk(0x%x) failed\r\n", hd_2pass_buf.blk);
}
}
}
}
#if PLAY_FULL_DISP // image crop for full display
void PBView_DrawErrorView(void)
{
HD_RESULT ret = HD_OK;
PBVIEW_HD_COM_BUF hd_view_buf = {0};
HD_VIDEOOUT_SYSCAPS video_out_syscaps;
HD_VIDEOOUT_SYSCAPS *p_video_out_syscaps = &video_out_syscaps;
HD_PATH_ID video_out_path = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_PATH);
HD_PATH_ID video_out_ctrl = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_CTRLPATH);
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
HD_VIDEO_FRAME VdoDstDisp = {0}; //Display size
VF_GFX_DRAW_RECT DrawRectDst = {0};
VF_GFX_DRAW_RECT *pDrawRectDst = &DrawRectDst;
UINT32 disp_rotate = GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_SWAPXY);
UINT32 swap_w_h=0;
ret = hd_videoout_get(video_out_ctrl, HD_VIDEOOUT_PARAM_SYSCAPS, p_video_out_syscaps);
if (ret != HD_OK) {
DBG_ERR("get video_out_syscaps failed\r\n");
}
//#NT#2021/1/28#Philex Lin-begin
// swap Width/Height if panel is rotated
if (disp_rotate)
{
// swap w/h
swap_w_h=p_video_out_syscaps->output_dim.w;
p_video_out_syscaps->output_dim.w=p_video_out_syscaps->output_dim.h;
p_video_out_syscaps->output_dim.h=swap_w_h;
}
//#NT#2021/1/28#Philex Lin-end
hd_view_buf.blk_size = p_video_out_syscaps->output_dim.w*p_video_out_syscaps->output_dim.h*3/2; //YUV420
PBView_get_hd_common_buf(&hd_view_buf);
loff[0] = p_video_out_syscaps->output_dim.w; //Besides rotate panel, the display device don't consider the line offset.
addr[0] = hd_view_buf.pa;
loff[1] = p_video_out_syscaps->output_dim.w; //Besides rotate panel, the display device don't consider the line offset.
addr[1] = ALIGN_CEIL_4(addr[0] + p_video_out_syscaps->output_dim.w*p_video_out_syscaps->output_dim.h);
ret = vf_init_ex(&VdoDstDisp, p_video_out_syscaps->output_dim.w, p_video_out_syscaps->output_dim.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex dst failed\r\n");
}
VdoDstDisp.blk = hd_view_buf.blk;
memcpy((void *)&pDrawRectDst->dst_img, (void *)&VdoDstDisp, sizeof(HD_VIDEO_FRAME));
pDrawRectDst->color = COLOR_RGB_BLACK;
pDrawRectDst->rect.x = 0;
pDrawRectDst->rect.y = 0;
pDrawRectDst->rect.w = VdoDstDisp.dim.w;
pDrawRectDst->rect.h = VdoDstDisp.dim.h;
pDrawRectDst->type = HD_GFX_RECT_SOLID;
pDrawRectDst->thickness = 0; //Don't care for HD_GFX_RECT_SOLID
pDrawRectDst->engine = 0;
vf_gfx_draw_rect(pDrawRectDst);
ret = hd_videoout_start(video_out_path);
if(ret != HD_OK){
DBG_ERR("hd_videoout_start failed\r\n");
return;
}
ret = hd_videoout_push_in_buf(video_out_path, &VdoDstDisp, NULL, 0); // only support non-blocking mode now
if (ret != HD_OK){
DBG_ERR("failed to push in buf of videoout\r\n");
}
ret = hd_common_mem_munmap((void *)hd_view_buf.va, hd_view_buf.blk_size);
if (ret != HD_OK){
DBG_ERR("failed to memory munmap\r\n");
}
ret = hd_common_mem_release_block(hd_view_buf.blk);
if (ret != HD_OK){
DBG_ERR("release blk(0x%x) failed\r\n", hd_view_buf.blk);
}
}
#else
void PBView_DrawErrorView(void)
{
HD_RESULT ret = HD_OK;
PBVIEW_HD_COM_BUF hd_view_buf = {0};
HD_VIDEOOUT_SYSCAPS video_out_syscaps;
HD_VIDEOOUT_SYSCAPS *p_video_out_syscaps = &video_out_syscaps;
HD_PATH_ID video_out_path = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_PATH);
HD_PATH_ID video_out_ctrl = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_CTRLPATH);
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
HD_VIDEO_FRAME VdoDstDisp = {0}; //Display size
VF_GFX_DRAW_RECT DrawRectDst = {0};
VF_GFX_DRAW_RECT *pDrawRectDst = &DrawRectDst;
UINT32 disp_rotate = GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_SWAPXY);
USIZE dst_aspect_ratio = GxVideo_GetDeviceAspect(DOUT1);
SIZECONVERT_INFO CovtInfo = {0};
HD_URECT DstDispRect = {0};
ret = hd_videoout_get(video_out_ctrl, HD_VIDEOOUT_PARAM_SYSCAPS, p_video_out_syscaps);
if (ret != HD_OK) {
DBG_ERR("get video_out_syscaps failed\r\n");
}
CovtInfo.uiSrcWidth = 2560; //hard code
CovtInfo.uiSrcHeight = 1440;
if (disp_rotate) {
CovtInfo.uiDstWidth = p_video_out_syscaps->output_dim.h;
CovtInfo.uiDstHeight = p_video_out_syscaps->output_dim.w;
} else {
CovtInfo.uiDstWidth = p_video_out_syscaps->output_dim.w;
CovtInfo.uiDstHeight = p_video_out_syscaps->output_dim.h;
}
CovtInfo.uiDstWRatio = dst_aspect_ratio.w;
CovtInfo.uiDstHRatio = dst_aspect_ratio.h;
CovtInfo.alignType = SIZECONVERT_ALIGN_FLOOR_32;
DisplaySizeConvert(&CovtInfo);
if (CovtInfo.uiOutWidth && CovtInfo.uiOutHeight) {
DstDispRect.x = CovtInfo.uiOutX;
DstDispRect.y = CovtInfo.uiOutY;
DstDispRect.w = CovtInfo.uiOutWidth;
DstDispRect.h = CovtInfo.uiOutHeight;
} else {
DstDispRect.x = 0;
DstDispRect.y = 0;
DstDispRect.w = p_video_out_syscaps->output_dim.w;
DstDispRect.h = p_video_out_syscaps->output_dim.h;
}
hd_view_buf.blk_size = DstDispRect.w*DstDispRect.h*3/2; //YUV420
PBView_get_hd_common_buf(&hd_view_buf);
loff[0] = DstDispRect.w; //Besides rotate panel, the display device don't consider the line offset.
addr[0] = hd_view_buf.pa;
loff[1] = DstDispRect.w; //Besides rotate panel, the display device don't consider the line offset.
addr[1] = ALIGN_CEIL_4(addr[0] + DstDispRect.w*DstDispRect.h);
ret = vf_init_ex(&VdoDstDisp, DstDispRect.w, DstDispRect.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex dst failed\r\n");
}
VdoDstDisp.blk = hd_view_buf.blk;
memcpy((void *)&pDrawRectDst->dst_img, (void *)&VdoDstDisp, sizeof(HD_VIDEO_FRAME));
pDrawRectDst->color = COLOR_RGB_BLACK;
pDrawRectDst->rect.x = 0;
pDrawRectDst->rect.y = 0;
pDrawRectDst->rect.w = VdoDstDisp.dim.w;
pDrawRectDst->rect.h = VdoDstDisp.dim.h;
pDrawRectDst->type = HD_GFX_RECT_SOLID;
pDrawRectDst->thickness = 0; //Don't care for HD_GFX_RECT_SOLID
pDrawRectDst->engine = 0;
vf_gfx_draw_rect(pDrawRectDst);
ret = hd_videoout_start(video_out_path);
if(ret != HD_OK){
DBG_ERR("hd_videoout_start failed\r\n");
return;
}
ret = hd_videoout_push_in_buf(video_out_path, &VdoDstDisp, NULL, 0); // only support non-blocking mode now
if (ret != HD_OK){
DBG_ERR("failed to push in buf of videoout\r\n");
}
ret = hd_common_mem_munmap((void *)hd_view_buf.va, hd_view_buf.blk_size);
if (ret != HD_OK){
DBG_ERR("failed to memory munmap\r\n");
}
ret = hd_common_mem_release_block(hd_view_buf.blk);
if (ret != HD_OK){
DBG_ERR("release blk(0x%x) failed\r\n", hd_view_buf.blk);
}
}
#endif
//#NT#2023/11/14#Eric - begin
//#NT#Support IVOT_N12144_CO-148_A
void PBView_DrawNoFile(void)
{
HD_RESULT ret = HD_OK;
PBVIEW_HD_COM_BUF hd_view_buf = {0};
HD_VIDEOOUT_SYSCAPS video_out_syscaps;
HD_VIDEOOUT_SYSCAPS *p_video_out_syscaps = &video_out_syscaps;
HD_PATH_ID video_out_path = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_PATH);
HD_PATH_ID video_out_ctrl = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_CTRLPATH);
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
HD_VIDEO_FRAME VdoDstDisp = {0}; //Display size
VF_GFX_DRAW_RECT DrawRectDst = {0};
VF_GFX_DRAW_RECT *pDrawRectDst = &DrawRectDst;
UINT32 disp_rotate = GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_SWAPXY);
USIZE dst_aspect_ratio = GxVideo_GetDeviceAspect(DOUT1);
ISIZE disp_size = GxVideo_GetDeviceSize(DOUT1);
SIZECONVERT_INFO CovtInfo = {0};
HD_URECT DstDispRect = {0};
ret = hd_videoout_get(video_out_ctrl, HD_VIDEOOUT_PARAM_SYSCAPS, p_video_out_syscaps);
if (ret != HD_OK) {
DBG_ERR("get video_out_syscaps failed\r\n");
}
CovtInfo.uiSrcWidth = 2560; //hard code
CovtInfo.uiSrcHeight = 1440;
if (disp_rotate) {
CovtInfo.uiDstWidth = p_video_out_syscaps->output_dim.h;
CovtInfo.uiDstHeight = p_video_out_syscaps->output_dim.w;
} else {
CovtInfo.uiDstWidth = p_video_out_syscaps->output_dim.w;
CovtInfo.uiDstHeight = p_video_out_syscaps->output_dim.h;
}
CovtInfo.uiDstWRatio = dst_aspect_ratio.w;
CovtInfo.uiDstHRatio = dst_aspect_ratio.h;
CovtInfo.alignType = SIZECONVERT_ALIGN_FLOOR_32;
DisplaySizeConvert(&CovtInfo);
if (CovtInfo.uiOutWidth && CovtInfo.uiOutHeight) {
DstDispRect.x = CovtInfo.uiOutX;
DstDispRect.y = CovtInfo.uiOutY;
DstDispRect.w = CovtInfo.uiOutWidth;
DstDispRect.h = CovtInfo.uiOutHeight;
} else {
DstDispRect.x = 0;
DstDispRect.y = 0;
DstDispRect.w = p_video_out_syscaps->output_dim.w;
DstDispRect.h = p_video_out_syscaps->output_dim.h;
}
///hard code
DstDispRect.w = disp_size.w;
DstDispRect.h = disp_size.h;
hd_view_buf.blk_size = DstDispRect.w*DstDispRect.h*3/2; //YUV420
PBView_get_hd_common_buf(&hd_view_buf);
loff[0] = DstDispRect.w; //Besides rotate panel, the display device don't consider the line offset.
addr[0] = hd_view_buf.pa;
loff[1] = DstDispRect.w; //Besides rotate panel, the display device don't consider the line offset.
addr[1] = ALIGN_CEIL_4(addr[0] + DstDispRect.w*DstDispRect.h);
ret = vf_init_ex(&VdoDstDisp, DstDispRect.w, DstDispRect.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex dst failed\r\n");
}
VdoDstDisp.blk = hd_view_buf.blk;
memcpy((void *)&pDrawRectDst->dst_img, (void *)&VdoDstDisp, sizeof(HD_VIDEO_FRAME));
pDrawRectDst->color = COLOR_RGB_BLACK;
pDrawRectDst->rect.x = 0;
pDrawRectDst->rect.y = 0;
pDrawRectDst->rect.w = VdoDstDisp.dim.w;
pDrawRectDst->rect.h = VdoDstDisp.dim.h;
pDrawRectDst->type = HD_GFX_RECT_SOLID;
pDrawRectDst->thickness = 0; //Don't care for HD_GFX_RECT_SOLID
pDrawRectDst->engine = 0;
vf_gfx_draw_rect(pDrawRectDst);
ret = hd_videoout_start(video_out_path);
if(ret != HD_OK){
DBG_ERR("hd_videoout_start failed\r\n");
return;
}
ret = hd_videoout_push_in_buf(video_out_path, &VdoDstDisp, NULL, 0); // only support non-blocking mode now
if (ret != HD_OK){
DBG_ERR("failed to push in buf of videoout\r\n");
}
ret = hd_common_mem_munmap((void *)hd_view_buf.va, hd_view_buf.blk_size);
if (ret != HD_OK){
DBG_ERR("failed to memory munmap\r\n");
}
ret = hd_common_mem_release_block(hd_view_buf.blk);
if (ret != HD_OK){
DBG_ERR("release blk(0x%x) failed\r\n", hd_view_buf.blk);
}
}
//#NT#2023/11/14#Eric - end
#if PLAY_THUMB_AND_MOVIE // play thumbnail and movie together
void PBView_DrawThumbFrame(UINT32 idx, UINT32 mode)
{
HD_RESULT ret = HD_OK;
PBVIEW_HD_COM_BUF hd_view_buf = {0};
HD_PATH_ID video_out_path = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_PATH);
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
ISIZE disp_size = GxVideo_GetDeviceSize(DOUT1);
USIZE dst_aspect_ratio = GxVideo_GetDeviceAspect(DOUT1);
UINT32 thumb_w, thumb_h, buff_addr;
VF_GFX_SCALE gfx_scale = {0};
VF_GFX_COPY gfx_copy;
thumb_w = g_ThumbFrm[idx].dim.w;
thumb_h = g_ThumbFrm[idx].dim.h;
disp_size.w /= 2; // single view only on the right half part of display
dst_aspect_ratio.w /= 2; // single view only on the right half part of display
// scale and crop image from thumbnail frame to right side of display buffer
// the method should be the same as PBView_DrawSingleView except 2 pass scaling
if ((thumb_w * dst_aspect_ratio.h) > (dst_aspect_ratio.w * thumb_h)) {
gfx_scale.engine = 0;
gfx_scale.src_region.w = ALIGN_CEIL_4((thumb_h * dst_aspect_ratio.w) / dst_aspect_ratio.h);
gfx_scale.src_region.h = thumb_h;
gfx_scale.src_region.x = (thumb_w - gfx_scale.src_region.w) / 2;
gfx_scale.src_region.y = 0;
gfx_scale.dst_region.w = disp_size.w;
gfx_scale.dst_region.h = disp_size.h;
gfx_scale.dst_region.x = 0;
gfx_scale.dst_region.y = 0;
gfx_scale.quality = HD_GFX_SCALE_QUALITY_BILINEAR;
} else {
gfx_scale.engine = 0;
gfx_scale.src_region.w = thumb_w;
gfx_scale.src_region.h = ALIGN_CEIL_4((thumb_w * dst_aspect_ratio.h) / dst_aspect_ratio.w);
gfx_scale.src_region.x = 0;
gfx_scale.src_region.y = (thumb_h - gfx_scale.src_region.h) / 2;
gfx_scale.dst_region.w = disp_size.w;
gfx_scale.dst_region.h = disp_size.h;
gfx_scale.dst_region.x = disp_size.w; // single view is on the right side of display
gfx_scale.dst_region.y = 0;
gfx_scale.quality = HD_GFX_SCALE_QUALITY_BILINEAR;
}
disp_size.w *= 2; // recall original display width
// get new display buffer
hd_view_buf.blk_size = disp_size.w * disp_size.h * 3 / 2;
PBView_get_hd_common_buf(&hd_view_buf);
if (mode == THUMB_DRAW_TMP_BUFFER) { // use display tmp buffer
// scale image to display tmp buffer firstly, then copy to new display buffer
buff_addr = mempool_disp_tmp;
} else { // use new display buffer
// scale image to new display buffer directly
buff_addr = hd_view_buf.pa;
}
// scale image to display buffer
loff[0] = disp_size.w;
addr[0] = buff_addr;
loff[1] = disp_size.w;
addr[1] = ALIGN_CEIL_4(addr[0] + disp_size.w * disp_size.h);
ret = vf_init_ex(&gfx_scale.dst_img, disp_size.w, disp_size.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex dst failed\r\n");
//return;
}
memcpy((void *)&gfx_scale.src_img, (void *)&g_ThumbFrm[idx], sizeof(HD_VIDEO_FRAME));
vf_gfx_scale(&gfx_scale, 1);
if (mode == THUMB_DRAW_TMP_BUFFER) { // use display tmp buffer
// copy whole image from display tmp buffer to new display buffer then push in
gfx_copy.src_img = g_DispTmpFrm;
if ((ret = vf_init(&gfx_copy.dst_img, disp_size.w, disp_size.h, g_DispTmpFrm.pxlfmt, disp_size.w, hd_view_buf.pa, (disp_size.w*disp_size.h*3)/2)) != HD_OK) {
DBG_ERR("vf_init fail(%d)\r\n", ret);
}
gfx_copy.src_region.w = disp_size.w; // copy whole image
} else { // use new display buffer
// copy left part of last video frame buffer (thumbnail layout) to new display buffer
gfx_copy.src_img = g_LastVdoFrm;
if ((ret = vf_init(&gfx_copy.dst_img, disp_size.w, disp_size.h, g_LastVdoFrm.pxlfmt, disp_size.w, hd_view_buf.pa, (disp_size.w*disp_size.h*3)/2)) != HD_OK) {
DBG_ERR("vf_init fail(%d)\r\n", ret);
}
gfx_copy.src_region.w = disp_size.w/2; // copy half image
}
gfx_copy.src_region.x = 0;
gfx_copy.src_region.y = 0;
gfx_copy.src_region.h = disp_size.h;
gfx_copy.dst_pos.x = 0;
gfx_copy.dst_pos.y = 0;
gfx_copy.colorkey = 0;
gfx_copy.alpha = 255;
gfx_copy.engine = 0;
if ((ret = vf_gfx_copy(&gfx_copy)) != HD_OK) {
DBG_ERR("vf_gfx_copy fail(%d)\r\n", ret);
}
ret = hd_videoout_start(video_out_path);
if (ret != HD_OK){
DBG_ERR("hd_videoout_start failed\r\n");
//return;
}
// push in and release buffer
gfx_copy.dst_img.blk = hd_view_buf.blk;
ret = hd_videoout_push_in_buf(video_out_path, &gfx_copy.dst_img, NULL, 0); // only support non-blocking mode now
if (ret != HD_OK) {
DBG_ERR("failed to push in buf of videoout, %d\r\n", ret);
} else {
hd_common_mem_munmap((void *)hd_view_buf.va, hd_view_buf.blk_size);
ret = hd_common_mem_release_block(hd_view_buf.blk);
if (ret != HD_OK) {
DBG_ERR("release blk(0x%x) failed\r\n", hd_view_buf.blk);
}
memcpy((void *)&g_LastVdoFrm, (void *)&gfx_copy.dst_img, sizeof(HD_VIDEO_FRAME));
}
}
#endif
#if PLAY_THUMB_AND_MOVIE // play thumbnail and movie together
ER PBView_OnThumbDraw(HD_VIDEO_FRAME *pHdDecVdoFrame, PUSIZE dst_ratio)
{
ER er;
UINT32 uiIdx;
UINT32 i, thumb_num=0;
HD_RESULT ret = HD_OK;
HD_VIDEOOUT_SYSCAPS video_out_syscaps;
HD_VIDEOOUT_SYSCAPS *p_video_out_syscaps = &video_out_syscaps;
HD_VIDEO_FRAME VdoSrc = {0};
HD_VIDEO_FRAME VdoDstDisp = {0}; //Display size
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
HD_PATH_ID video_out_path = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_PATH);
HD_PATH_ID video_out_ctrl = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_CTRLPATH);
HD_URECT DstDispRect = {0};
UINT32 disp_rotate = GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_SWAPXY);
ret = hd_videoout_get(video_out_ctrl, HD_VIDEOOUT_PARAM_SYSCAPS, p_video_out_syscaps);
if (ret != HD_OK) {
DBG_ERR("get video_out_syscaps failed\r\n");
}
DstDispRect.x = 0;
DstDispRect.y = 0;
if (disp_rotate) {
DstDispRect.w = p_video_out_syscaps->output_dim.h;
DstDispRect.h = p_video_out_syscaps->output_dim.w;
} else {
DstDispRect.w = p_video_out_syscaps->output_dim.w;
DstDispRect.h = p_video_out_syscaps->output_dim.h;
}
loff[0] = DstDispRect.w; //Besides rotate panel, the display device don't consider the line offset.
addr[0] = mempool_disp_tmp;
loff[1] = DstDispRect.w; //Besides rotate panel, the display device don't consider the line offset.
addr[1] = ALIGN_CEIL_4(addr[0] + DstDispRect.w * DstDispRect.h);
ret = vf_init_ex(&VdoDstDisp, DstDispRect.w, DstDispRect.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex dst failed\r\n");
}
PB_GetParam(PBPRMID_THUMB_CURR_NUM, (UINT32 *) &thumb_num);
for (i = 0; i < thumb_num; i++) {
uiIdx = (i & 0x1);
if ((er = PB_LockThumb(uiIdx)) != E_OK) {
//locked fail indicate skip this draw
PB_SetPBFlag(PB_SET_FLG_BROWSER_END);
return er;
}
PB_GetParam(PBPRMID_INFO_IMG, (UINT32 *)&VdoSrc);
PBView_DrawThumbView(i, &VdoSrc, &VdoDstDisp, dst_ratio);
uiIdx = ((i+1) & 0x1);
PB_UnlockThumb(uiIdx);
}
memcpy((void *)&g_DispTmpFrm, (void *)&VdoDstDisp, sizeof(HD_VIDEO_FRAME));
#if 1 // set vout
HD_VIDEOOUT_IN video_out_param={0};
HD_VIDEOOUT_WIN_ATTR video_out_win = {0};
video_out_param.dim.w = DstDispRect.w;
video_out_param.dim.h = DstDispRect.h;
video_out_param.pxlfmt = HD_VIDEO_PXLFMT_YUV420;
video_out_param.dir = SysVideo_GetDirbyID(0);
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN, &video_out_param);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_set: HD_VIDEOOUT_PARAM_IN failed\r\n");
return E_SYS;
}
video_out_win.visible = TRUE;
if (disp_rotate) {
video_out_win.rect.x = DstDispRect.y;
video_out_win.rect.y = DstDispRect.x;
video_out_win.rect.w = DstDispRect.h;
video_out_win.rect.h = DstDispRect.w;
} else {
video_out_win.rect.x = DstDispRect.x;
video_out_win.rect.y = DstDispRect.y;
video_out_win.rect.w = DstDispRect.w;
video_out_win.rect.h = DstDispRect.h;
}
video_out_win.layer = HD_LAYER1;
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN_WIN_ATTR, &video_out_win);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_set: HD_VIDEOOUT_PARAM_IN_WIN_ATTR fail\r\n");
}
#endif
PB_SetPBFlag(PB_SET_FLG_BROWSER_END);
return E_OK;
}
#else
ER PBView_OnThumbDraw(HD_VIDEO_FRAME *pHdDecVdoFrame, PUSIZE dst_ratio)
{
ER er;
UINT32 uiIdx;
UINT32 i, thumb_num=0;
HD_RESULT ret = HD_OK;
PBVIEW_HD_COM_BUF hd_view_buf = {0};
HD_VIDEOOUT_SYSCAPS video_out_syscaps;
HD_VIDEOOUT_SYSCAPS *p_video_out_syscaps = &video_out_syscaps;
HD_VIDEO_FRAME VdoSrc = {0};
HD_VIDEO_FRAME VdoDstDisp = {0}; //Display size
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
HD_PATH_ID video_out_path = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_PATH);
HD_PATH_ID video_out_ctrl = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_CTRLPATH);
HD_URECT DstDispRect = {0};
UINT32 disp_rotate = GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_SWAPXY);
ret = hd_videoout_get(video_out_ctrl, HD_VIDEOOUT_PARAM_SYSCAPS, p_video_out_syscaps);
if (ret != HD_OK) {
DBG_ERR("get video_out_syscaps failed\r\n");
}
hd_view_buf.blk_size = p_video_out_syscaps->output_dim.w*p_video_out_syscaps->output_dim.h*3/2; //YUV420
PBView_get_hd_common_buf(&hd_view_buf);
DstDispRect.x = 0;
DstDispRect.y = 0;
if (disp_rotate) {
DstDispRect.w = p_video_out_syscaps->output_dim.h;
DstDispRect.h = p_video_out_syscaps->output_dim.w;
} else {
DstDispRect.w = p_video_out_syscaps->output_dim.w;
DstDispRect.h = p_video_out_syscaps->output_dim.h;
}
loff[0] = DstDispRect.w; //Besides rotate panel, the display device don't consider the line offset.
addr[0] = hd_view_buf.pa;
loff[1] = DstDispRect.w; //Besides rotate panel, the display device don't consider the line offset.
addr[1] = ALIGN_CEIL_4(addr[0] + DstDispRect.w * DstDispRect.h);
ret = vf_init_ex(&VdoDstDisp, DstDispRect.w, DstDispRect.h, HD_VIDEO_PXLFMT_YUV420, loff, addr);
if (ret != HD_OK) {
DBG_ERR("vf_init_ex dst failed\r\n");
}
VdoDstDisp.blk = hd_view_buf.blk;
PB_GetParam(PBPRMID_THUMB_CURR_NUM, (UINT32 *) &thumb_num);
for (i = 0; i < thumb_num; i++) {
uiIdx = (i & 0x1);
if ((er = PB_LockThumb(uiIdx)) != E_OK) {
//locked fail indicate skip this draw
PB_SetPBFlag(PB_SET_FLG_BROWSER_END);
return er;
}
PB_GetParam(PBPRMID_INFO_IMG, (UINT32 *)&VdoSrc);
PBView_DrawThumbView(i, &VdoSrc, &VdoDstDisp, dst_ratio);
uiIdx = ((i+1) & 0x1);
PB_UnlockThumb(uiIdx);
}
#if 1 // set vout
HD_VIDEOOUT_IN video_out_param={0};
HD_VIDEOOUT_WIN_ATTR video_out_win = {0};
video_out_param.dim.w = DstDispRect.w;
video_out_param.dim.h = DstDispRect.h;
video_out_param.pxlfmt = HD_VIDEO_PXLFMT_YUV420;
video_out_param.dir = SysVideo_GetDirbyID(0);
DBG_DUMP("PBView_OnThumbDraw: video_out_param w %d, h %d\r\n", video_out_param.dim.w, video_out_param.dim.h);
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN, &video_out_param);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_set: HD_VIDEOOUT_PARAM_IN failed\r\n");
return E_SYS;
}
video_out_win.visible = TRUE;
if (disp_rotate) {
video_out_win.rect.x = DstDispRect.y;
video_out_win.rect.y = DstDispRect.x;
video_out_win.rect.w = DstDispRect.h;
video_out_win.rect.h = DstDispRect.w;
} else {
video_out_win.rect.x = DstDispRect.x;
video_out_win.rect.y = DstDispRect.y;
video_out_win.rect.w = DstDispRect.w;
video_out_win.rect.h = DstDispRect.h;
}
video_out_win.layer = HD_LAYER1;
DBG_DUMP("PBView_OnThumbDraw: video_out x %d, y %d, w %d, h %d\r\n", video_out_win.rect.x, video_out_win.rect.y, video_out_win.rect.w, video_out_win.rect.h);
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN_WIN_ATTR, &video_out_win);
if (ret != HD_OK) {
DBG_ERR("hd_videoout_set: HD_VIDEOOUT_PARAM_IN_WIN_ATTR fail\r\n");
}
ret = hd_videoout_start(video_out_path);
if(ret != HD_OK){
DBG_ERR("hd_videoout_start failed\r\n");
return E_SYS;
}
#endif
VdoDstDisp.blk = hd_view_buf.blk;
ret = hd_videoout_push_in_buf(video_out_path, &VdoDstDisp, NULL, 0); // only support non-blocking mode now
if (ret != HD_OK){
DBG_ERR("failed to push in buf of videoout\r\n");
}else{
ret = hd_common_mem_munmap((void *)hd_view_buf.va, hd_view_buf.blk_size);
if (ret != HD_OK){
DBG_ERR("failed to memory munmap\r\n");
}
ret = hd_common_mem_release_block(hd_view_buf.blk);
if (ret != HD_OK){
DBG_ERR("release blk(0x%x) failed\r\n", hd_view_buf.blk);
}
memcpy((void *)&g_LastVdoFrm, (void *)&VdoDstDisp, sizeof(HD_VIDEO_FRAME));
}
PB_SetPBFlag(PB_SET_FLG_BROWSER_END);
return E_OK;
}
#endif
void PBView_OnDrawCB(PB_VIEW_STATE view_state, HD_VIDEO_FRAME *pHdDecVdoFrame)
{
UINT32 uiFileNum = 0;
UINT32 u32CurrPbStatus = 0;
PB_GetParam(PBPRMID_TOTAL_FILE_COUNT, &uiFileNum);
PB_GetParam(PBPRMID_PLAYBACK_STATUS, &u32CurrPbStatus);
if ((uiFileNum == 0) || (u32CurrPbStatus != PB_STA_DONE)){
PBView_DrawErrorView();
PB_SetPBFlag(PB_SET_FLG_DRAW_END);
return;
}
if (view_state == PB_VIEW_STATE_SINGLE) {
gfpDrawCb = PBView_OnSingleDraw;
} else if (view_state == PB_VIEW_STATE_THUMB) {
gfpDrawCb = PBView_OnThumbDraw;
}
gPbState = view_state;
aspect_ratio = GxVideo_GetDeviceAspect(DOUT1);
if (gPbState == PB_VIEW_STATE_THUMB) {
gfpDrawCb(0, &aspect_ratio);
}else{
gfpDrawCb(pHdDecVdoFrame, &aspect_ratio);
}
}
#if _TODO //refer to NA51055-840 JIRA and using new method
void PBView_KeepLastView(void)
{
HD_RESULT hd_ret = HD_OK;
PBVIEW_HD_COM_BUF hd_view_buf = {0};
HD_COMMON_MEM_DDR_ID ddr_id = 0;
VF_GFX_COPY copy_param;
HD_PATH_ID video_out_path = (HD_PATH_ID)GxVideo_GetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_PATH);
hd_view_buf.blk_size = g_LastVdoFrm.dim.w*g_LastVdoFrm.loff[0]*3/2;
if ((hd_ret = hd_common_mem_alloc("NVTMPP_TEMP", &hd_view_buf.pa, (void **)&hd_view_buf.va, hd_view_buf.blk_size, ddr_id)) != HD_OK) {
DBG_ERR("hd_common_mem_alloc fail(%d)\r\n", hd_ret);
return;
}
copy_param.src_img = g_LastVdoFrm;
if ((hd_ret = vf_init(&(copy_param.dst_img), g_LastVdoFrm.dim.w, g_LastVdoFrm.dim.h, g_LastVdoFrm.pxlfmt, g_LastVdoFrm.loff[0], hd_view_buf.pa, hd_view_buf.blk_size)) != HD_OK) {
DBG_ERR("vf_init fail(%d)\r\n", hd_ret);
return;
}
copy_param.src_region.x = 0;
copy_param.src_region.y = 0;
copy_param.src_region.w = g_LastVdoFrm.dim.w;
copy_param.src_region.h = g_LastVdoFrm.dim.h;
copy_param.dst_pos.x = 0;
copy_param.dst_pos.y = 0;
copy_param.colorkey = 0;
copy_param.alpha = 255;
copy_param.engine = 0;
if ((hd_ret = vf_gfx_copy(&copy_param)) != HD_OK) {
DBG_ERR("vf_gfx_copy fail(%d)\r\n", hd_ret);
}
copy_param.dst_img.blk = -2;
if ((hd_ret = hd_videoout_push_in_buf(video_out_path, &(copy_param.dst_img), NULL, 500)) != HD_OK) {
DBG_ERR("hd_videoout_push_in_buf fail(%d)\r\n", hd_ret);
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink