1994 lines
73 KiB
C++
1994 lines
73 KiB
C++
|
|
||
|
|
//#define CONFIG_LOG_LEVEL OPTION_LOG_LEVEL_DETAIL
|
||
|
|
#define LOG_TAG "videoRenderComponent"
|
||
|
|
#include "log.h"
|
||
|
|
|
||
|
|
#include <pthread.h>
|
||
|
|
#include <semaphore.h>
|
||
|
|
#include <malloc.h>
|
||
|
|
#include <memory.h>
|
||
|
|
#include <time.h>
|
||
|
|
|
||
|
|
#include "videoRenderComponent.h"
|
||
|
|
#include "messageQueue.h"
|
||
|
|
#include "layerControl.h"
|
||
|
|
#include "memoryAdapter.h"
|
||
|
|
#include <deinterlace.h>
|
||
|
|
|
||
|
|
#include<sys/types.h>
|
||
|
|
#include<sys/stat.h>
|
||
|
|
#include<fcntl.h>
|
||
|
|
#include <linux/ioctl.h>
|
||
|
|
|
||
|
|
#if (CONFIG_OS != OPTION_OS_LINUX)
|
||
|
|
#include <hardware/hwcomposer.h>
|
||
|
|
#include <cutils/properties.h>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
#define USE_DETNTERLACE 1
|
||
|
|
#define SEND_PTS_TO_SF 0
|
||
|
|
|
||
|
|
extern LayerControlOpsT mLayerControlOps;
|
||
|
|
|
||
|
|
typedef struct VideoRenderCompContext
|
||
|
|
{
|
||
|
|
//* created at initialize time.
|
||
|
|
MessageQueue* mq;
|
||
|
|
sem_t startMsgReplySem;
|
||
|
|
sem_t stopMsgReplySem;
|
||
|
|
sem_t pauseMsgReplySem;
|
||
|
|
sem_t resetMsgReplySem;
|
||
|
|
sem_t eosMsgReplySem;
|
||
|
|
sem_t quitMsgReplySem;
|
||
|
|
sem_t set3DModeReplySem;
|
||
|
|
sem_t setWindowReplySem;
|
||
|
|
sem_t setHideVideoSem;
|
||
|
|
sem_t setHoldLastPictureSem;
|
||
|
|
|
||
|
|
int nStartReply;
|
||
|
|
int nStopReply;
|
||
|
|
int nPauseReply;
|
||
|
|
int nResetReply;
|
||
|
|
int nSet3DModeReply;
|
||
|
|
|
||
|
|
pthread_t sRenderThread;
|
||
|
|
|
||
|
|
enum EPLAYERSTATUS eStatus;
|
||
|
|
void* pNativeWindow;
|
||
|
|
LayerControlOpsT* mLayerOps;
|
||
|
|
LayerCtrl* pLayerCtrl;
|
||
|
|
VideoDecComp* pDecComp;
|
||
|
|
|
||
|
|
enum EPICTURE3DMODE ePicture3DMode;
|
||
|
|
enum EDISPLAY3DMODE eDisplay3DMode;
|
||
|
|
|
||
|
|
//* objects set by user.
|
||
|
|
AvTimer* pAvTimer;
|
||
|
|
PlayerCallback callback;
|
||
|
|
void* pUserData;
|
||
|
|
int bEosFlag;
|
||
|
|
int nRotationAngle;
|
||
|
|
int nRequsetPictureNum;
|
||
|
|
int ptsSecs;
|
||
|
|
|
||
|
|
Deinterlace *di;
|
||
|
|
|
||
|
|
VideoPicture* pDeinterlacePrePicture;
|
||
|
|
int nGpuYAlign;
|
||
|
|
int nGpuCAlign;
|
||
|
|
int bSyncFirstPictureFlag;
|
||
|
|
FramerateEstimater* pFrameRateEstimater;
|
||
|
|
VideoStreamInfo videoStreamInfo;
|
||
|
|
}VideoRenderCompContext;
|
||
|
|
|
||
|
|
static void* VideoRenderThread(void* arg);
|
||
|
|
static void PostRenderMessage(MessageQueue* mq);
|
||
|
|
static int IsVideoWithTwoStream(VideoDecComp* pDecComp);
|
||
|
|
static int LayerCallback(void* pUserData, int eMessageId, void* param);
|
||
|
|
static void CheckScreenRotateAngle(VideoRenderCompContext* p,
|
||
|
|
VideoPicture* pPicture,
|
||
|
|
int bNeedResetAngleFlag);
|
||
|
|
static void showVideoDecodefps(VideoPicture* pPicture);
|
||
|
|
|
||
|
|
VideoRenderComp* VideoRenderCompCreate(void)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
int err;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)malloc(sizeof(VideoRenderCompContext));
|
||
|
|
if(p == NULL)
|
||
|
|
{
|
||
|
|
loge("memory alloc fail.");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
memset(p, 0, sizeof(*p));
|
||
|
|
|
||
|
|
p->mLayerOps = __GetLayerControlOps();
|
||
|
|
p->mq = MessageQueueCreate(4, "VideoRenderMq");
|
||
|
|
if(p->mq == NULL)
|
||
|
|
{
|
||
|
|
loge("video render component create message queue fail.");
|
||
|
|
free(p);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
sem_init(&p->startMsgReplySem, 0, 0);
|
||
|
|
sem_init(&p->stopMsgReplySem, 0, 0);
|
||
|
|
sem_init(&p->pauseMsgReplySem, 0, 0);
|
||
|
|
sem_init(&p->resetMsgReplySem, 0, 0);
|
||
|
|
sem_init(&p->eosMsgReplySem, 0, 0);
|
||
|
|
sem_init(&p->quitMsgReplySem, 0, 0);
|
||
|
|
sem_init(&p->set3DModeReplySem, 0, 0);
|
||
|
|
sem_init(&p->setWindowReplySem, 0, 0);
|
||
|
|
sem_init(&p->setHideVideoSem, 0, 0);
|
||
|
|
sem_init(&p->setHoldLastPictureSem, 0, 0);
|
||
|
|
|
||
|
|
p->eStatus = PLAYER_STATUS_STOPPED;
|
||
|
|
|
||
|
|
p->ptsSecs = -1;
|
||
|
|
p->di = DeinterlaceCreate();
|
||
|
|
if (!p->di)
|
||
|
|
{
|
||
|
|
logw("No deinterlace...");
|
||
|
|
}
|
||
|
|
|
||
|
|
err = pthread_create(&p->sRenderThread, NULL, VideoRenderThread, p);
|
||
|
|
if(err != 0)
|
||
|
|
{
|
||
|
|
loge("video render component create thread fail.");
|
||
|
|
sem_destroy(&p->startMsgReplySem);
|
||
|
|
sem_destroy(&p->stopMsgReplySem);
|
||
|
|
sem_destroy(&p->pauseMsgReplySem);
|
||
|
|
sem_destroy(&p->resetMsgReplySem);
|
||
|
|
sem_destroy(&p->eosMsgReplySem);
|
||
|
|
sem_destroy(&p->quitMsgReplySem);
|
||
|
|
sem_destroy(&p->set3DModeReplySem);
|
||
|
|
sem_destroy(&p->setWindowReplySem);
|
||
|
|
sem_destroy(&p->setHideVideoSem);
|
||
|
|
sem_destroy(&p->setHoldLastPictureSem);
|
||
|
|
MessageQueueDestroy(p->mq);
|
||
|
|
if (p->di)
|
||
|
|
{
|
||
|
|
delete p->di;
|
||
|
|
p->di = NULL;
|
||
|
|
}
|
||
|
|
free(p);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if(GPU_Y_C_ALIGN == GPU_Y16_C16_ALIGN) //* on 1680, Y-Align is 16, C-Align is 16,
|
||
|
|
p->nGpuYAlign = 16;
|
||
|
|
p->nGpuCAlign = 16;
|
||
|
|
#elif(GPU_Y_C_ALIGN == GPU_Y32_C16_ALIGN)//* on 1673, Y-Align is 32, C-Align is 16,
|
||
|
|
p->nGpuYAlign = 32;
|
||
|
|
p->nGpuCAlign = 16;
|
||
|
|
#else //* on others, Y-Align is 16, C-Align is 8,
|
||
|
|
p->nGpuYAlign = 16;
|
||
|
|
p->nGpuCAlign = 8;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
return (VideoRenderComp*)p;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompSetLayerCtlOps(VideoRenderComp* v, LayerControlOpsT* ops)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
p->mLayerOps = ops;
|
||
|
|
logd("==== set layer control ops");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompDestroy(VideoRenderComp* v)
|
||
|
|
{
|
||
|
|
void* status;
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
msg.messageId = MESSAGE_ID_QUIT;
|
||
|
|
msg.params[0] = (uintptr_t)&p->quitMsgReplySem;
|
||
|
|
msg.params[1] = msg.params[2] = msg.params[3] = 0;
|
||
|
|
|
||
|
|
if(MessageQueuePostMessage(p->mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
SemTimedWait(&p->quitMsgReplySem, -1);
|
||
|
|
pthread_join(p->sRenderThread, &status);
|
||
|
|
|
||
|
|
if(p->videoStreamInfo.pCodecSpecificData)
|
||
|
|
free(p->videoStreamInfo.pCodecSpecificData);
|
||
|
|
|
||
|
|
sem_destroy(&p->startMsgReplySem);
|
||
|
|
sem_destroy(&p->stopMsgReplySem);
|
||
|
|
sem_destroy(&p->pauseMsgReplySem);
|
||
|
|
sem_destroy(&p->resetMsgReplySem);
|
||
|
|
sem_destroy(&p->eosMsgReplySem);
|
||
|
|
sem_destroy(&p->quitMsgReplySem);
|
||
|
|
sem_destroy(&p->set3DModeReplySem);
|
||
|
|
sem_destroy(&p->setWindowReplySem);
|
||
|
|
sem_destroy(&p->setHideVideoSem);
|
||
|
|
sem_destroy(&p->setHoldLastPictureSem);
|
||
|
|
|
||
|
|
if(p->pDeinterlacePrePicture != NULL)
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pDeinterlacePrePicture);
|
||
|
|
|
||
|
|
if (p->di)
|
||
|
|
{
|
||
|
|
delete p->di;
|
||
|
|
p->di = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageQueueDestroy(p->mq);
|
||
|
|
free(p);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompStart(VideoRenderComp* v)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
logv("video render component starting");
|
||
|
|
|
||
|
|
msg.messageId = MESSAGE_ID_START;
|
||
|
|
msg.params[0] = (uintptr_t)&p->startMsgReplySem;
|
||
|
|
msg.params[1] = (uintptr_t)&p->nStartReply;
|
||
|
|
msg.params[2] = msg.params[3] = 0;
|
||
|
|
|
||
|
|
if(MessageQueuePostMessage(p->mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(SemTimedWait(&p->startMsgReplySem, -1) < 0)
|
||
|
|
{
|
||
|
|
loge("video render component wait for start finish timeout.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return p->nStartReply;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompStop(VideoRenderComp* v)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
logv("video render component stopping");
|
||
|
|
|
||
|
|
msg.messageId = MESSAGE_ID_STOP;
|
||
|
|
msg.params[0] = (uintptr_t)&p->stopMsgReplySem;
|
||
|
|
msg.params[1] = (uintptr_t)&p->nStopReply;
|
||
|
|
msg.params[2] = msg.params[3] = 0;
|
||
|
|
|
||
|
|
if(MessageQueuePostMessage(p->mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(SemTimedWait(&p->stopMsgReplySem, -1) < 0)
|
||
|
|
{
|
||
|
|
loge("video render component wait for stop finish timeout.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return p->nStopReply;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompPause(VideoRenderComp* v)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
logv("video render component pausing");
|
||
|
|
|
||
|
|
msg.messageId = MESSAGE_ID_PAUSE;
|
||
|
|
msg.params[0] = (uintptr_t)&p->pauseMsgReplySem;
|
||
|
|
msg.params[1] = (uintptr_t)&p->nPauseReply;
|
||
|
|
msg.params[2] = msg.params[3] = 0;
|
||
|
|
|
||
|
|
if(MessageQueuePostMessage(p->mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(SemTimedWait(&p->pauseMsgReplySem, -1) < 0)
|
||
|
|
{
|
||
|
|
loge("video render component wait for pause finish timeout.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return p->nPauseReply;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
enum EPLAYERSTATUS VideoRenderCompGetStatus(VideoRenderComp* v)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
return p->eStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompReset(VideoRenderComp* v)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
logv("video render component reseting");
|
||
|
|
|
||
|
|
msg.messageId = MESSAGE_ID_RESET;
|
||
|
|
msg.params[0] = (uintptr_t)&p->resetMsgReplySem;
|
||
|
|
msg.params[1] = (uintptr_t)&p->nResetReply;
|
||
|
|
msg.params[2] = msg.params[3] = 0;
|
||
|
|
|
||
|
|
if(MessageQueuePostMessage(p->mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(SemTimedWait(&p->resetMsgReplySem, -1) < 0)
|
||
|
|
{
|
||
|
|
loge("video render component wait for reset finish timeout.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return p->nResetReply;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompSetEOS(VideoRenderComp* v)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
logv("video render component setting EOS.");
|
||
|
|
|
||
|
|
msg.messageId = MESSAGE_ID_EOS;
|
||
|
|
msg.params[0] = (uintptr_t)&p->eosMsgReplySem;
|
||
|
|
msg.params[1] = msg.params[2] = msg.params[3] = 0;
|
||
|
|
|
||
|
|
if(MessageQueuePostMessage(p->mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(SemTimedWait(&p->eosMsgReplySem, -1) < 0)
|
||
|
|
{
|
||
|
|
loge("video render component wait for setting eos finish timeout.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompSetCallback(VideoRenderComp* v, PlayerCallback callback, void* pUserData)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
p->callback = callback;
|
||
|
|
p->pUserData = pUserData;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompSetTimer(VideoRenderComp* v, AvTimer* timer)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
p->pAvTimer = timer;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompSetWindow(VideoRenderComp* v, void* pNativeWindow)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
logv("video render component setting window.");
|
||
|
|
|
||
|
|
msg.messageId = MESSAGE_ID_SET_WINDOW;
|
||
|
|
msg.params[0] = (uintptr_t)&p->setWindowReplySem;
|
||
|
|
msg.params[1] = 0;
|
||
|
|
msg.params[2] = (uintptr_t)pNativeWindow;
|
||
|
|
msg.params[3] = 0;
|
||
|
|
|
||
|
|
if(MessageQueuePostMessage(p->mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(SemTimedWait(&p->setWindowReplySem, -1) < 0)
|
||
|
|
{
|
||
|
|
loge("video render component wait for setting window finish timeout.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderCompSetDecodeComp(VideoRenderComp* v, VideoDecComp* d)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
p->pDecComp = d;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int VideoRenderCompSetFrameRateEstimater(VideoRenderComp* v, FramerateEstimater* fe)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
p->pFrameRateEstimater = fe;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderSet3DMode(VideoRenderComp* v,
|
||
|
|
enum EPICTURE3DMODE ePicture3DMode,
|
||
|
|
enum EDISPLAY3DMODE eDisplay3DMode)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
logv("video render component setting 3d mode.");
|
||
|
|
|
||
|
|
msg.messageId = MESSAGE_ID_SET_3D_MODE;
|
||
|
|
msg.params[0] = (uintptr_t)&p->set3DModeReplySem;
|
||
|
|
msg.params[1] = (uintptr_t)&p->nSet3DModeReply;
|
||
|
|
msg.params[2] = (uintptr_t)ePicture3DMode;
|
||
|
|
msg.params[3] = (uintptr_t)eDisplay3DMode;
|
||
|
|
|
||
|
|
if(MessageQueuePostMessage(p->mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(SemTimedWait(&p->set3DModeReplySem, -1) < 0)
|
||
|
|
{
|
||
|
|
loge("video render component wait for setting 3d mode finish timeout.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return p->nSet3DModeReply;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderGet3DMode(VideoRenderComp* v,
|
||
|
|
enum EPICTURE3DMODE* ePicture3DMode,
|
||
|
|
enum EDISPLAY3DMODE* eDisplay3DMode)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
*ePicture3DMode = p->ePicture3DMode;
|
||
|
|
*eDisplay3DMode = p->eDisplay3DMode;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderVideoHide(VideoRenderComp* v, int bHideVideo)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
logv("video render component setting video hide(%d).", bHideVideo);
|
||
|
|
|
||
|
|
msg.messageId = MESSAGE_ID_SET_VIDEO_HIDE;
|
||
|
|
msg.params[0] = (uintptr_t)&p->setHideVideoSem;
|
||
|
|
msg.params[1] = 0;
|
||
|
|
msg.params[2] = bHideVideo;
|
||
|
|
msg.params[3] = 0;
|
||
|
|
|
||
|
|
if(MessageQueuePostMessage(p->mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(SemTimedWait(&p->setHideVideoSem, -1) < 0)
|
||
|
|
{
|
||
|
|
loge("video render component wait for setting 3d mode finish timeout.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int VideoRenderSetHoldLastPicture(VideoRenderComp* v, int bHold)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
logv("video render component setting hold last picture(bHold=%d).", bHold);
|
||
|
|
|
||
|
|
msg.messageId = MESSAGE_ID_SET_HOLD_LAST_PICTURE;
|
||
|
|
msg.params[0] = (uintptr_t)&p->setHoldLastPictureSem;
|
||
|
|
msg.params[1] = 0;
|
||
|
|
msg.params[2] = bHold;
|
||
|
|
msg.params[3] = 0;
|
||
|
|
|
||
|
|
if(MessageQueuePostMessage(p->mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(SemTimedWait(&p->setHoldLastPictureSem, -1) < 0)
|
||
|
|
{
|
||
|
|
loge("video render component wait for setting 3d mode finish timeout.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(p->pLayerCtrl != NULL && (p->eStatus == PLAYER_STATUS_STOPPED))
|
||
|
|
{
|
||
|
|
if(bHold)
|
||
|
|
p->mLayerOps->ctrlHoldLastPicture(p->pLayerCtrl, 1);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
p->mLayerOps->ctrlHoldLastPicture(p->pLayerCtrl, 0);
|
||
|
|
if(p->mLayerOps->ctrlIsVideoShow(p->pLayerCtrl) == 1)
|
||
|
|
p->mLayerOps->ctrlHideVideo(p->pLayerCtrl);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void VideoRenderCompSetProtecedFlag(VideoRenderComp* v, int bProtectedFlag)
|
||
|
|
{
|
||
|
|
//*TODO
|
||
|
|
CDX_PLAYER_UNUSE(v);
|
||
|
|
CDX_PLAYER_UNUSE(bProtectedFlag);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
int VideoRenderCompSetVideoStreamInfo(VideoRenderComp* v, VideoStreamInfo* pStreamInfo)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
p = (VideoRenderCompContext *)v;
|
||
|
|
|
||
|
|
memcpy(&p->videoStreamInfo, pStreamInfo, sizeof(VideoStreamInfo));
|
||
|
|
|
||
|
|
if(pStreamInfo->nCodecSpecificDataLen > 0)
|
||
|
|
{
|
||
|
|
p->videoStreamInfo.pCodecSpecificData = (char*)malloc(pStreamInfo->nCodecSpecificDataLen);
|
||
|
|
if(p->videoStreamInfo.pCodecSpecificData == NULL)
|
||
|
|
{
|
||
|
|
loge("malloc video codec specific data fail!");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
memcpy(p->videoStreamInfo.pCodecSpecificData,
|
||
|
|
pStreamInfo->pCodecSpecificData,
|
||
|
|
pStreamInfo->nCodecSpecificDataLen);
|
||
|
|
p->videoStreamInfo.nCodecSpecificDataLen = pStreamInfo->nCodecSpecificDataLen;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int VideoRenderCompSetSyncFirstPictureFlag(VideoRenderComp* v, int bSyncFirstPictureFlag)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
p = (VideoRenderCompContext*)v;
|
||
|
|
|
||
|
|
p->bSyncFirstPictureFlag = bSyncFirstPictureFlag;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void* VideoRenderThread(void* arg)
|
||
|
|
{
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
Message msg;
|
||
|
|
int ret;
|
||
|
|
sem_t* pReplySem;
|
||
|
|
int* pReplyValue;
|
||
|
|
int64_t nCurTime;
|
||
|
|
int nWaitTime;
|
||
|
|
int bFirstPictureShowed;
|
||
|
|
int bFirstPtsNotified;
|
||
|
|
int bVideoWithTwoStream;
|
||
|
|
VideoPicture* pPicture;
|
||
|
|
VideoPicture* pSecondPictureOf3DMode;
|
||
|
|
VideoPicture* pLayerBuffer;
|
||
|
|
VideoPicture* pSecondLayerBufferOf3DMode;
|
||
|
|
int bHideVideo;
|
||
|
|
int bHoldLastPicture;
|
||
|
|
int bResolutionChange;
|
||
|
|
int bNeedResetLayerParams;
|
||
|
|
int bDeinterlaceFlag;
|
||
|
|
int nDeinterlaceDispNum;
|
||
|
|
VideoPicture* pPreLayerBuffer;
|
||
|
|
int nLayerBufferMode;
|
||
|
|
int bNeedResetAngleFlag;
|
||
|
|
int bNotDropFlag;
|
||
|
|
int bBotFiledError;
|
||
|
|
int bTopFiledError;
|
||
|
|
int bTopFiledFirst;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)arg;
|
||
|
|
bFirstPictureShowed = 0;
|
||
|
|
bFirstPtsNotified = 0;
|
||
|
|
bVideoWithTwoStream = 0;
|
||
|
|
pPicture = NULL;
|
||
|
|
pSecondPictureOf3DMode = NULL;
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
bHideVideo = 0;
|
||
|
|
bHoldLastPicture = 0;
|
||
|
|
bResolutionChange = 0;
|
||
|
|
bNeedResetLayerParams = 0;
|
||
|
|
bDeinterlaceFlag = 0;
|
||
|
|
nDeinterlaceDispNum = 1;
|
||
|
|
pPreLayerBuffer = NULL;
|
||
|
|
nLayerBufferMode = 0;
|
||
|
|
bNeedResetAngleFlag = 0;
|
||
|
|
bNotDropFlag = 0;
|
||
|
|
bBotFiledError = 0;
|
||
|
|
bTopFiledError = 0;
|
||
|
|
bTopFiledFirst = 0;
|
||
|
|
|
||
|
|
while(1)
|
||
|
|
{
|
||
|
|
if(MessageQueueGetMessage(p->mq, &msg) < 0)
|
||
|
|
{
|
||
|
|
loge("get message fail.");
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
process_message:
|
||
|
|
|
||
|
|
pReplySem = (sem_t*)msg.params[0];
|
||
|
|
pReplyValue = (int*)msg.params[1];
|
||
|
|
|
||
|
|
if(msg.messageId == MESSAGE_ID_START)
|
||
|
|
{
|
||
|
|
logi("process MESSAGE_ID_START message");
|
||
|
|
if(p->eStatus == PLAYER_STATUS_STARTED)
|
||
|
|
{
|
||
|
|
logw("already in started status.");
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
*pReplyValue = -1;
|
||
|
|
sem_post(pReplySem);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(p->eStatus == PLAYER_STATUS_STOPPED)
|
||
|
|
{
|
||
|
|
bFirstPictureShowed = 0;
|
||
|
|
bFirstPtsNotified = 0;
|
||
|
|
p->bEosFlag = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//* send a render message to start decoding.
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
|
||
|
|
p->eStatus = PLAYER_STATUS_STARTED;
|
||
|
|
*pReplyValue = 0;
|
||
|
|
sem_post(pReplySem);
|
||
|
|
}
|
||
|
|
else if(msg.messageId == MESSAGE_ID_STOP)
|
||
|
|
{
|
||
|
|
logi("process MESSAGE_ID_STOP message");
|
||
|
|
if(p->eStatus == PLAYER_STATUS_STOPPED)
|
||
|
|
{
|
||
|
|
logw("already in stopped status.");
|
||
|
|
*pReplyValue = -1;
|
||
|
|
sem_post(pReplySem);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
//* return buffers before stop.
|
||
|
|
if(pLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(pSecondLayerBufferOf3DMode == NULL)
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pLayerBuffer, 0);
|
||
|
|
else
|
||
|
|
p->mLayerOps->queue3DBuffer(p->pLayerCtrl, pLayerBuffer, pSecondLayerBufferOf3DMode, 0);
|
||
|
|
}
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pPreLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(pSecondLayerBufferOf3DMode == NULL)
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pPreLayerBuffer, 0);
|
||
|
|
else
|
||
|
|
p->mLayerOps->queue3DBuffer(p->pLayerCtrl, pPreLayerBuffer, pSecondLayerBufferOf3DMode, 0);
|
||
|
|
}
|
||
|
|
pPreLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
if(pPicture != NULL)
|
||
|
|
{
|
||
|
|
if(p->pDecComp != NULL)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
if(pSecondPictureOf3DMode != NULL)
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pSecondPictureOf3DMode);
|
||
|
|
}
|
||
|
|
pPicture = NULL;
|
||
|
|
pSecondPictureOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(bHoldLastPicture)
|
||
|
|
p->mLayerOps->ctrlHoldLastPicture(p->pLayerCtrl, 1);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
p->mLayerOps->ctrlHoldLastPicture(p->pLayerCtrl, 0);
|
||
|
|
if(p->mLayerOps->ctrlIsVideoShow(p->pLayerCtrl) == 1)
|
||
|
|
p->mLayerOps->ctrlHideVideo(p->pLayerCtrl);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//* set status to stopped.
|
||
|
|
p->eStatus = PLAYER_STATUS_STOPPED;
|
||
|
|
*pReplyValue = 0;
|
||
|
|
sem_post(pReplySem);
|
||
|
|
}
|
||
|
|
else if(msg.messageId == MESSAGE_ID_PAUSE)
|
||
|
|
{
|
||
|
|
logi("process MESSAGE_ID_PAUSE message");
|
||
|
|
if(p->eStatus != PLAYER_STATUS_STARTED &&
|
||
|
|
!(p->eStatus == PLAYER_STATUS_PAUSED && bFirstPictureShowed == 0))
|
||
|
|
{
|
||
|
|
logw("not in started status, pause operation invalid.");
|
||
|
|
*pReplyValue = -1;
|
||
|
|
sem_post(pReplySem);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
//* set status to paused.
|
||
|
|
p->eStatus = PLAYER_STATUS_PAUSED;
|
||
|
|
if(bFirstPictureShowed == 0 && p->bSyncFirstPictureFlag == 0)
|
||
|
|
{
|
||
|
|
PostRenderMessage(p->mq); //* post a decode message to decode the first picture.
|
||
|
|
}
|
||
|
|
*pReplyValue = 0;
|
||
|
|
sem_post(pReplySem);
|
||
|
|
}
|
||
|
|
else if(msg.messageId == MESSAGE_ID_QUIT)
|
||
|
|
{
|
||
|
|
logi("process MESSAGE_ID_QUIT message");
|
||
|
|
//* return buffers before quit.
|
||
|
|
if(pLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(pSecondLayerBufferOf3DMode == NULL)
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pLayerBuffer, 0);
|
||
|
|
else
|
||
|
|
p->mLayerOps->queue3DBuffer(p->pLayerCtrl, pLayerBuffer, pSecondLayerBufferOf3DMode, 0);
|
||
|
|
}
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
if(pPreLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(pSecondLayerBufferOf3DMode == NULL)
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pPreLayerBuffer, 0);
|
||
|
|
else
|
||
|
|
p->mLayerOps->queue3DBuffer(p->pLayerCtrl, pPreLayerBuffer, pSecondLayerBufferOf3DMode, 0);
|
||
|
|
}
|
||
|
|
pPreLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pPicture != NULL)
|
||
|
|
{
|
||
|
|
if(p->pDecComp != NULL)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
if(pSecondPictureOf3DMode != NULL)
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pSecondPictureOf3DMode);
|
||
|
|
}
|
||
|
|
pPicture = NULL;
|
||
|
|
pSecondPictureOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
sem_post(pReplySem);
|
||
|
|
p->eStatus = PLAYER_STATUS_STOPPED;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else if(msg.messageId == MESSAGE_ID_RESET)
|
||
|
|
{
|
||
|
|
logi("process MESSAGE_ID_RESET message");
|
||
|
|
//* return buffers before quit.
|
||
|
|
if(pLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(pSecondLayerBufferOf3DMode == NULL)
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pLayerBuffer, 0);
|
||
|
|
else
|
||
|
|
p->mLayerOps->queue3DBuffer(p->pLayerCtrl, pLayerBuffer, pSecondLayerBufferOf3DMode, 0);
|
||
|
|
}
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
if(pPreLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(pSecondLayerBufferOf3DMode == NULL)
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pPreLayerBuffer, 0);
|
||
|
|
else
|
||
|
|
p->mLayerOps->queue3DBuffer(p->pLayerCtrl, pPreLayerBuffer, pSecondLayerBufferOf3DMode, 0);
|
||
|
|
}
|
||
|
|
pPreLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
VideoPicture* tmp = pPicture;
|
||
|
|
if(pPicture != NULL)
|
||
|
|
{
|
||
|
|
if(p->pDecComp != NULL)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
if(pSecondPictureOf3DMode != NULL)
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pSecondPictureOf3DMode);
|
||
|
|
}
|
||
|
|
pPicture = NULL;
|
||
|
|
pSecondPictureOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(p->pDeinterlacePrePicture != tmp && p->pDeinterlacePrePicture != NULL)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pDeinterlacePrePicture);
|
||
|
|
}
|
||
|
|
p->pDeinterlacePrePicture = NULL;
|
||
|
|
|
||
|
|
|
||
|
|
//* clear the eos flag.
|
||
|
|
p->bEosFlag = 0;
|
||
|
|
p->nRequsetPictureNum = 0;
|
||
|
|
bFirstPictureShowed = 0;
|
||
|
|
bFirstPtsNotified = 0;
|
||
|
|
*pReplyValue = 0;
|
||
|
|
sem_post(pReplySem);
|
||
|
|
|
||
|
|
//* send a message to continue the thread.
|
||
|
|
if(p->eStatus == PLAYER_STATUS_STARTED ||
|
||
|
|
(p->eStatus == PLAYER_STATUS_PAUSED && bFirstPictureShowed == 0 && p->bSyncFirstPictureFlag == 0))
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
}
|
||
|
|
else if(msg.messageId == MESSAGE_ID_EOS)
|
||
|
|
{
|
||
|
|
logi("process MESSAGE_ID_EOS message");
|
||
|
|
p->bEosFlag = 1;
|
||
|
|
sem_post(pReplySem);
|
||
|
|
|
||
|
|
//* send a message to continue the thread.
|
||
|
|
if(p->eStatus == PLAYER_STATUS_STARTED ||
|
||
|
|
(p->eStatus == PLAYER_STATUS_PAUSED && bFirstPictureShowed == 0 && p->bSyncFirstPictureFlag == 0))
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
}
|
||
|
|
else if(msg.messageId == MESSAGE_ID_SET_WINDOW)
|
||
|
|
{
|
||
|
|
logi("process MESSAGE_ID_SET_WINDOW message");
|
||
|
|
//* return buffer to old layer.
|
||
|
|
if(pLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(pSecondLayerBufferOf3DMode == NULL)
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pLayerBuffer, 0);
|
||
|
|
else
|
||
|
|
p->mLayerOps->queue3DBuffer(p->pLayerCtrl, pLayerBuffer, pSecondLayerBufferOf3DMode, 0);
|
||
|
|
}
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pPreLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(pSecondLayerBufferOf3DMode == NULL)
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pPreLayerBuffer, 0);
|
||
|
|
else
|
||
|
|
p->mLayerOps->queue3DBuffer(p->pLayerCtrl, pPreLayerBuffer, pSecondLayerBufferOf3DMode, 0);
|
||
|
|
}
|
||
|
|
pPreLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
p->mLayerOps->release(p->pLayerCtrl);
|
||
|
|
p->pLayerCtrl = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
p->pNativeWindow = (void*)msg.params[2];
|
||
|
|
|
||
|
|
//* on linux, pNativeWindow == NULL, and the LayerCtrl module will
|
||
|
|
//* create a layer to show video picture.
|
||
|
|
#if CONFIG_OS == OPTION_OS_ANDROID
|
||
|
|
if(p->pNativeWindow != NULL)
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
p->pLayerCtrl = p->mLayerOps->init(p->pNativeWindow);
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
p->mLayerOps->setCallback(p->pLayerCtrl, (PlayerCallback)LayerCallback, (void*)p);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
loge("can not initialize the video layer.");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
bNeedResetLayerParams = 1;
|
||
|
|
sem_post(pReplySem);
|
||
|
|
|
||
|
|
//* send a message to continue the thread.
|
||
|
|
if(p->eStatus == PLAYER_STATUS_STARTED ||
|
||
|
|
(p->eStatus == PLAYER_STATUS_PAUSED && bFirstPictureShowed == 0 && p->bSyncFirstPictureFlag == 0))
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if(msg.messageId == MESSAGE_ID_SET_3D_MODE)
|
||
|
|
{
|
||
|
|
logi("process MESSAGE_ID_SET_3D_MODE message");
|
||
|
|
p->ePicture3DMode = (enum EPICTURE3DMODE)msg.params[2];
|
||
|
|
p->eDisplay3DMode = (enum EDISPLAY3DMODE)msg.params[3];
|
||
|
|
|
||
|
|
//* now , we no need to set 3D mode to nativeWindow , the app will set it
|
||
|
|
#if 0
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
LayerSetPicture3DMode(p->pLayerCtrl, (enum EPICTURE3DMODE)msg.params[2]);
|
||
|
|
*pReplyValue = LayerSetDisplay3DMode(p->pLayerCtrl, (enum EDISPLAY3DMODE)msg.params[3]);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
logw("window not set yet, can not set 3d mode.");
|
||
|
|
*pReplyValue = -1;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
*pReplyValue = 0;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
sem_post(pReplySem);
|
||
|
|
|
||
|
|
//* send a message to continue the thread.
|
||
|
|
if(p->eStatus == PLAYER_STATUS_STARTED ||
|
||
|
|
(p->eStatus == PLAYER_STATUS_PAUSED && bFirstPictureShowed == 0 && p->bSyncFirstPictureFlag == 0))
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
}
|
||
|
|
else if(msg.messageId == MESSAGE_ID_SET_VIDEO_HIDE)
|
||
|
|
{
|
||
|
|
logi("process MESSAGE_ID_SET_VIDEO_HIDE message");
|
||
|
|
bHideVideo = msg.params[2];
|
||
|
|
if(bHideVideo == 1) //* hide video.
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL && p->mLayerOps->ctrlIsVideoShow(p->pLayerCtrl) == 1)
|
||
|
|
p->mLayerOps->ctrlHideVideo(p->pLayerCtrl);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL &&
|
||
|
|
p->mLayerOps->ctrlIsVideoShow(p->pLayerCtrl) == 0 &&
|
||
|
|
bFirstPictureShowed == 1)
|
||
|
|
p->mLayerOps->ctrlShowVideo(p->pLayerCtrl);
|
||
|
|
}
|
||
|
|
sem_post(pReplySem);
|
||
|
|
|
||
|
|
//* send a message to continue the thread.
|
||
|
|
if(p->eStatus == PLAYER_STATUS_STARTED ||
|
||
|
|
(p->eStatus == PLAYER_STATUS_PAUSED && bFirstPictureShowed == 0 && p->bSyncFirstPictureFlag == 0))
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
}
|
||
|
|
else if(msg.messageId == MESSAGE_ID_SET_HOLD_LAST_PICTURE)
|
||
|
|
{
|
||
|
|
bHoldLastPicture = msg.params[2];
|
||
|
|
|
||
|
|
logv("process MESSAGE_ID_SET_HOLD_LAST_PICTURE message, bHoldLastPicture(%d)", bHoldLastPicture);
|
||
|
|
sem_post(pReplySem);
|
||
|
|
|
||
|
|
//* send a message to continue the thread.
|
||
|
|
if(p->eStatus == PLAYER_STATUS_STARTED ||
|
||
|
|
(p->eStatus == PLAYER_STATUS_PAUSED && bFirstPictureShowed == 0 && p->bSyncFirstPictureFlag == 0))
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
}
|
||
|
|
else if(msg.messageId == MESSAGE_ID_RENDER)
|
||
|
|
{
|
||
|
|
logv("process MESSAGE_ID_RENDER message");
|
||
|
|
|
||
|
|
if(p->eStatus != PLAYER_STATUS_STARTED &&
|
||
|
|
!(p->eStatus == PLAYER_STATUS_PAUSED && bFirstPictureShowed == 0))
|
||
|
|
{
|
||
|
|
logw("not in started status, render message ignored.");
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
//****************************
|
||
|
|
//* check whether it is a 3D stream.
|
||
|
|
//****************************
|
||
|
|
if(bFirstPictureShowed == 0)
|
||
|
|
{
|
||
|
|
do
|
||
|
|
{
|
||
|
|
bVideoWithTwoStream = IsVideoWithTwoStream(p->pDecComp);
|
||
|
|
if(bVideoWithTwoStream == -1)
|
||
|
|
{
|
||
|
|
//* get stream info fail, decoder not initialized yet.
|
||
|
|
bVideoWithTwoStream = 0;
|
||
|
|
|
||
|
|
//* check whether stream end.
|
||
|
|
if(p->bEosFlag)
|
||
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_EOS, NULL);
|
||
|
|
|
||
|
|
ret = MessageQueueTryGetMessage(p->mq, &msg, 10); //* wait for 10ms if no message come.
|
||
|
|
if(ret == 0) //* new message come, quit loop to process.
|
||
|
|
goto process_message;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
break;
|
||
|
|
}while(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pPicture == NULL && pLayerBuffer == NULL)
|
||
|
|
{
|
||
|
|
//*******************************
|
||
|
|
//* 1. get picture from decoder.
|
||
|
|
//*******************************
|
||
|
|
if(bVideoWithTwoStream == 0)
|
||
|
|
{
|
||
|
|
//* get one picture from decoder.
|
||
|
|
while(pPicture == NULL)
|
||
|
|
{
|
||
|
|
pPicture = VideoDecCompRequestPicture(p->pDecComp, 0, &bResolutionChange);
|
||
|
|
if(pPicture != NULL || p->bEosFlag)
|
||
|
|
{
|
||
|
|
if(pPicture)
|
||
|
|
{
|
||
|
|
bBotFiledError = pPicture->bBottomFieldError;
|
||
|
|
bTopFiledError = pPicture->bTopFieldError;
|
||
|
|
bTopFiledFirst = pPicture->bTopFieldFirst ;
|
||
|
|
}
|
||
|
|
p->nRequsetPictureNum++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(bResolutionChange)
|
||
|
|
{
|
||
|
|
bNeedResetAngleFlag = 1;
|
||
|
|
|
||
|
|
if(pPreLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(pSecondLayerBufferOf3DMode == NULL)
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pPreLayerBuffer, 0);
|
||
|
|
else
|
||
|
|
p->mLayerOps->queue3DBuffer(p->pLayerCtrl, pPreLayerBuffer, pSecondLayerBufferOf3DMode, 0);
|
||
|
|
}
|
||
|
|
pPreLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//* reopen the layer.
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
if(bFirstPictureShowed == 1)
|
||
|
|
p->mLayerOps->ctrlHoldLastPicture(p->pLayerCtrl, 1);
|
||
|
|
p->mLayerOps->release(p->pLayerCtrl);
|
||
|
|
p->pLayerCtrl = NULL;
|
||
|
|
|
||
|
|
p->pLayerCtrl = p->mLayerOps->init(p->pNativeWindow);
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
p->mLayerOps->setCallback(p->pLayerCtrl, (PlayerCallback)LayerCallback, (void*)p);
|
||
|
|
bNeedResetLayerParams = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(p->pDeinterlacePrePicture != NULL)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pDeinterlacePrePicture);
|
||
|
|
p->pDeinterlacePrePicture = NULL;
|
||
|
|
}
|
||
|
|
//* reopen the video engine.
|
||
|
|
VideoDecCompReopenVideoEngine(p->pDecComp);
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = MessageQueueTryGetMessage(p->mq, &msg, 5); //* wait for 5ms if no message come.
|
||
|
|
if(ret == 0) //* new message come, quit loop to process.
|
||
|
|
goto process_message;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//* get pictures of two streams from decoder.
|
||
|
|
while(pPicture == NULL)
|
||
|
|
{
|
||
|
|
if(VideoDecCompNextPictureInfo(p->pDecComp, 0, 0) != NULL &&
|
||
|
|
VideoDecCompNextPictureInfo(p->pDecComp, 1, 0) != NULL)
|
||
|
|
{
|
||
|
|
pPicture = VideoDecCompRequestPicture(p->pDecComp, 0);
|
||
|
|
pSecondPictureOf3DMode = VideoDecCompRequestPicture(p->pDecComp, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pPicture != NULL || p->bEosFlag)
|
||
|
|
break;
|
||
|
|
|
||
|
|
ret = MessageQueueTryGetMessage(p->mq, &msg, 5); //* wait for 10ms if no message come.
|
||
|
|
if(ret == 0) //* new message come, quit loop to process.
|
||
|
|
goto process_message;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//* debug show videoDecodefps
|
||
|
|
showVideoDecodefps(pPicture);
|
||
|
|
|
||
|
|
//*****************************************************************
|
||
|
|
//* 2. handle EOS, pPicture should not be NULL except bEosFlag==1.
|
||
|
|
//*****************************************************************
|
||
|
|
if(pPicture == NULL)
|
||
|
|
{
|
||
|
|
if(p->bEosFlag == 1)
|
||
|
|
{
|
||
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_EOS, NULL);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
loge("pPicture=NULL but bEosFlag is not set, shouldn't run here.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//********************************************
|
||
|
|
//* 3. initialize layer and notify video size.
|
||
|
|
//********************************************
|
||
|
|
if(bFirstPictureShowed == 0 || bNeedResetLayerParams == 1)
|
||
|
|
{
|
||
|
|
int size[4];
|
||
|
|
int display_pixel_format = PIXEL_FORMAT_DEFAULT;
|
||
|
|
int deinterlace_flag = DE_INTERLACE_NONE;
|
||
|
|
logv("xxxxxxxxxxxxxxxxxxxxxx pPicture width(%d) height(%d)", pPicture->nWidth, pPicture->nHeight);
|
||
|
|
logv("xxxxxxxxxxxxxxxxxxxxxx width=%d, height=%d", p->videoStreamInfo.nWidth, p->videoStreamInfo.nHeight);
|
||
|
|
#if(NOT_DROP_FRAME == 1)
|
||
|
|
if(p->videoStreamInfo.nWidth >= 3800 && p->videoStreamInfo.nHeight >= 2100
|
||
|
|
&& p->videoStreamInfo.eCodecFormat == VIDEO_CODEC_FORMAT_H264)
|
||
|
|
{
|
||
|
|
bNotDropFlag = 1;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
//* We should compute the real width and height again if the offset is valid.
|
||
|
|
//* Because the pPicture->nWidth is not the real width, it is buffer widht.
|
||
|
|
if((pPicture->nBottomOffset != 0 || pPicture->nRightOffset != 0) &&
|
||
|
|
pPicture->nRightOffset <= pPicture->nLineStride)
|
||
|
|
{
|
||
|
|
size[0] = pPicture->nRightOffset - pPicture->nLeftOffset;
|
||
|
|
size[1] = pPicture->nBottomOffset - pPicture->nTopOffset;
|
||
|
|
size[2] = 0;
|
||
|
|
size[3] = 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
size[0] = pPicture->nWidth;
|
||
|
|
size[1] = pPicture->nHeight;
|
||
|
|
size[2] = 0;
|
||
|
|
size[3] = 0;
|
||
|
|
}
|
||
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_VIDEO_SIZE, (void*)size);
|
||
|
|
|
||
|
|
if((pPicture->nRightOffset - pPicture->nLeftOffset) > 0 &&
|
||
|
|
(pPicture->nBottomOffset - pPicture->nTopOffset) > 0)
|
||
|
|
{
|
||
|
|
size[0] = pPicture->nLeftOffset;
|
||
|
|
size[1] = pPicture->nTopOffset;
|
||
|
|
size[2] = pPicture->nRightOffset - pPicture->nLeftOffset;
|
||
|
|
size[3] = pPicture->nBottomOffset - pPicture->nTopOffset;
|
||
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_VIDEO_CROP, (void*)size);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(p->pLayerCtrl)
|
||
|
|
{
|
||
|
|
//* we use rotate-transform to do video-rotation on 1673,
|
||
|
|
//* we set the PIXEL_FORMAT_YV12 , becase the output format of
|
||
|
|
//* rotate-transform is YV12
|
||
|
|
#if(ROTATE_PIC_HW == 1)
|
||
|
|
display_pixel_format = PIXEL_FORMAT_YV12;
|
||
|
|
#else
|
||
|
|
display_pixel_format = pPicture->ePixelFormat;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
nDeinterlaceDispNum = 1;
|
||
|
|
//* if use deinterlace, decise by if DeinterlaceCreate() success
|
||
|
|
if (p->di
|
||
|
|
&& pPicture->bIsProgressive == 0
|
||
|
|
&& USE_DETNTERLACE == 1)
|
||
|
|
{
|
||
|
|
if(p->pDeinterlacePrePicture != NULL)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pDeinterlacePrePicture);
|
||
|
|
p->pDeinterlacePrePicture = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (p->di->init() == 0)
|
||
|
|
{
|
||
|
|
int di_flag = p->di->flag();
|
||
|
|
p->nRequsetPictureNum = 1;//*have requset picture here
|
||
|
|
bDeinterlaceFlag = 1;
|
||
|
|
//nDeinterlaceDispNum = (di_flag == DE_INTERLACE_HW) ? 2 : 1;
|
||
|
|
if (MemAdapterGetDramFreq() < 360000 && pPicture->nHeight >= 1080) {
|
||
|
|
nDeinterlaceDispNum = 1;
|
||
|
|
} else if (di_flag == DE_INTERLACE_HW) {
|
||
|
|
nDeinterlaceDispNum = 2;
|
||
|
|
} else {
|
||
|
|
nDeinterlaceDispNum = 1;
|
||
|
|
}
|
||
|
|
display_pixel_format = p->di->expectPixelFormat();
|
||
|
|
deinterlace_flag = p->di->flag();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
logw(" open deinterlace failed , we not to use deinterlace!");
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
p->mLayerOps->setDisplayBufferSize(p->pLayerCtrl, pPicture->nWidth, pPicture->nHeight);
|
||
|
|
p->mLayerOps->setDisplayRegion(p->pLayerCtrl,
|
||
|
|
pPicture->nLeftOffset,
|
||
|
|
pPicture->nTopOffset,
|
||
|
|
pPicture->nRightOffset - pPicture->nLeftOffset,
|
||
|
|
pPicture->nBottomOffset - pPicture->nTopOffset);
|
||
|
|
p->mLayerOps->setDisplayPixelFormat(p->pLayerCtrl, (enum EPIXELFORMAT)display_pixel_format);
|
||
|
|
p->mLayerOps->setDeinterlaceFlag(p->pLayerCtrl, deinterlace_flag);
|
||
|
|
bNeedResetLayerParams = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//************************************************************************************
|
||
|
|
//* 4. notify the first sync frame to set timer. the first sync frame is the second
|
||
|
|
//* picture, the first picture need to be showed as soon as we can.(unsynchroized)
|
||
|
|
//************************************************************************************
|
||
|
|
step_4:
|
||
|
|
if(bFirstPictureShowed == 1
|
||
|
|
|| (bFirstPictureShowed == 0 && p->bSyncFirstPictureFlag == 1))
|
||
|
|
{
|
||
|
|
if(bFirstPtsNotified == 0)
|
||
|
|
{
|
||
|
|
//* this callback may block because the player need wait audio first frame to sync.
|
||
|
|
ret = p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_FIRST_PICTURE, (void*)&pPicture->nPts);
|
||
|
|
if(ret == TIMER_DROP_VIDEO_DATA)
|
||
|
|
{
|
||
|
|
//* video first frame pts small (too much) than the audio,
|
||
|
|
//* discard this frame to catch up the audio.
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
pPicture = NULL;
|
||
|
|
if(pSecondPictureOf3DMode != NULL)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pSecondPictureOf3DMode);
|
||
|
|
pSecondPictureOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
else if(ret == TIMER_NEED_NOTIFY_AGAIN)
|
||
|
|
{
|
||
|
|
//* waiting process for first frame sync with audio is broken by a new message to player, so the player tell us to notify again later.
|
||
|
|
//* post a render message to continue the rendering job after message processed.
|
||
|
|
ret = MessageQueueTryGetMessage(p->mq, &msg, 10); //* wait for 10ms if no message come.
|
||
|
|
if(ret == 0) //* new message come, quit loop to process.
|
||
|
|
goto process_message;
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
bFirstPtsNotified = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#if(ROTATE_PIC_HW == 1)
|
||
|
|
//* 4.1 on 1673, we use rotate-transfrom to do video rotation
|
||
|
|
//* so, we should check the system angle and reset the Layer
|
||
|
|
if(bFirstPictureShowed == 0 || bNeedResetAngleFlag == 1)
|
||
|
|
CheckScreenRotateAngle(p, pPicture, 1);
|
||
|
|
else
|
||
|
|
CheckScreenRotateAngle(p, pPicture, 0);
|
||
|
|
|
||
|
|
if(bNeedResetAngleFlag == 1)
|
||
|
|
bNeedResetAngleFlag = 0;
|
||
|
|
#endif
|
||
|
|
//******************************************************
|
||
|
|
//* 5. dequeue buffer from layer and copy picture data.
|
||
|
|
//******************************************************
|
||
|
|
step_5:
|
||
|
|
logv("***nDeinterlaceDispNum = %d,bDeinterlaceFlag = %d",nDeinterlaceDispNum,bDeinterlaceFlag);
|
||
|
|
for(int nDeinterlaceTime = 0;nDeinterlaceTime < nDeinterlaceDispNum;nDeinterlaceTime++)
|
||
|
|
{
|
||
|
|
if(pLayerBuffer == NULL)
|
||
|
|
{
|
||
|
|
if(bVideoWithTwoStream == 0)
|
||
|
|
{
|
||
|
|
//* dequeue buffer from layer.
|
||
|
|
//* if the pLayerCtrl==NULL(when the nativeWindow==NULL),
|
||
|
|
//* we should not call LayerDequeueBuffer();
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
while(pLayerBuffer == NULL)
|
||
|
|
{
|
||
|
|
// i) acquire buffer for deinterlace.
|
||
|
|
// buffer from a) dequeue buffer
|
||
|
|
// b) last non-queue buffer(pPreLayerBuffer).
|
||
|
|
if(pPreLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
pLayerBuffer = pPreLayerBuffer;
|
||
|
|
pPreLayerBuffer = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
nLayerBufferMode = p->mLayerOps->dequeueBuffer(p->pLayerCtrl, &pLayerBuffer);
|
||
|
|
|
||
|
|
if(nLayerBufferMode == LAYER_RESULT_USE_OUTSIDE_BUFFER)
|
||
|
|
{
|
||
|
|
pLayerBuffer = pPicture;
|
||
|
|
pPicture = NULL;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else if(nLayerBufferMode == 0)
|
||
|
|
{
|
||
|
|
if(bDeinterlaceFlag == 1)
|
||
|
|
{
|
||
|
|
if(p->pDeinterlacePrePicture == NULL)
|
||
|
|
p->pDeinterlacePrePicture = pPicture;
|
||
|
|
|
||
|
|
// if it is the first pic(normal->fast or fast->normal),
|
||
|
|
// bot filed or top filed error, cannot display both of them,
|
||
|
|
// Why!!!!
|
||
|
|
if(p->pDeinterlacePrePicture == pPicture && (bTopFiledError || bBotFiledError))
|
||
|
|
{
|
||
|
|
bTopFiledError = bBotFiledError = 1;
|
||
|
|
}
|
||
|
|
logv("++++ p->pDeinterlacePrePicture: %p, pPicture: %p", p->pDeinterlacePrePicture, pPicture);
|
||
|
|
// ii) deinterlace process
|
||
|
|
int diret = p->di->process(p->pDeinterlacePrePicture,
|
||
|
|
pPicture,
|
||
|
|
pLayerBuffer,
|
||
|
|
nDeinterlaceTime);
|
||
|
|
if (diret != 0)
|
||
|
|
{
|
||
|
|
p->di->reset();
|
||
|
|
|
||
|
|
// iii) deinterlace error handling.
|
||
|
|
// two ways for handling pLayerBuffer,
|
||
|
|
// a) cancel to layer
|
||
|
|
// b) set to pPreLayerBuffer for next deinterlace process.
|
||
|
|
// we use b).
|
||
|
|
if (nDeinterlaceTime == (nDeinterlaceDispNum - 1)) {
|
||
|
|
// last field, quit render msg.
|
||
|
|
logd("last field...");
|
||
|
|
if(pPicture != p->pDeinterlacePrePicture)
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pDeinterlacePrePicture);
|
||
|
|
p->pDeinterlacePrePicture = pPicture;
|
||
|
|
pPreLayerBuffer = pLayerBuffer;
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
goto process_message;
|
||
|
|
} else {
|
||
|
|
// first field, try deinterlace last field.
|
||
|
|
logd("first field...");
|
||
|
|
// prepicture == curpicture
|
||
|
|
if(pPicture != p->pDeinterlacePrePicture)
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pDeinterlacePrePicture);
|
||
|
|
p->pDeinterlacePrePicture = pPicture;
|
||
|
|
pPreLayerBuffer = pLayerBuffer;
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
nDeinterlaceTime ++;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// iv) end of deinterlacing this frame, set prepicture for next frame.
|
||
|
|
if(nDeinterlaceTime == (nDeinterlaceDispNum - 1))
|
||
|
|
{
|
||
|
|
if(pPicture != p->pDeinterlacePrePicture
|
||
|
|
&& p->pDeinterlacePrePicture != NULL)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pDeinterlacePrePicture);
|
||
|
|
}
|
||
|
|
p->pDeinterlacePrePicture = pPicture;
|
||
|
|
pPicture = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
VideoDecCompRotatePicture(p->pDecComp,
|
||
|
|
pPicture,
|
||
|
|
pLayerBuffer,
|
||
|
|
p->nRotationAngle,
|
||
|
|
p->nGpuYAlign,
|
||
|
|
p->nGpuCAlign); //* copy picture.
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
pPicture = NULL;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
loge("dequeue buffer from layer fail.");
|
||
|
|
ret = MessageQueueTryGetMessage(p->mq, &msg, 5); //* wait for 5ms if no message come.
|
||
|
|
if(ret == 0) //* new message come, quit loop to process.
|
||
|
|
goto process_message;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
pLayerBuffer = pPicture;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//* dequeue buffer from layer.
|
||
|
|
//* if the pLayerCtrl==NULL(when the nativeWindow==NULL),
|
||
|
|
//* we should not call LayerDequeueBuffer();
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
while(pLayerBuffer == NULL)
|
||
|
|
{
|
||
|
|
if(pPreLayerBuffer != NULL)
|
||
|
|
{
|
||
|
|
pLayerBuffer = pPreLayerBuffer;
|
||
|
|
pPreLayerBuffer = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
nLayerBufferMode = p->mLayerOps->dequeue3DBuffer(p->pLayerCtrl, &pLayerBuffer, &pSecondLayerBufferOf3DMode);
|
||
|
|
|
||
|
|
if(nLayerBufferMode == LAYER_RESULT_USE_OUTSIDE_BUFFER)
|
||
|
|
{
|
||
|
|
pLayerBuffer = pPicture;
|
||
|
|
pSecondLayerBufferOf3DMode = pSecondPictureOf3DMode;
|
||
|
|
pPicture = NULL;
|
||
|
|
pSecondPictureOf3DMode = NULL;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else if(nLayerBufferMode == 0)
|
||
|
|
{
|
||
|
|
//* copy picture.
|
||
|
|
VideoDecCompRotatePicture(p->pDecComp,
|
||
|
|
pPicture,
|
||
|
|
pLayerBuffer,
|
||
|
|
p->nRotationAngle,
|
||
|
|
p->nGpuYAlign,
|
||
|
|
p->nGpuCAlign);
|
||
|
|
VideoDecCompRotatePicture(p->pDecComp,
|
||
|
|
pSecondPictureOf3DMode,
|
||
|
|
pSecondLayerBufferOf3DMode,
|
||
|
|
p->nRotationAngle,
|
||
|
|
p->nGpuYAlign,
|
||
|
|
p->nGpuCAlign);
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pSecondPictureOf3DMode);
|
||
|
|
pPicture = NULL;
|
||
|
|
pSecondPictureOf3DMode = NULL;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
loge("dequeue buffer from layer fail.");
|
||
|
|
ret = MessageQueueTryGetMessage(p->mq, &msg, 5); //* wait for 5ms if no message come.
|
||
|
|
if(ret == 0) //* new message come, quit loop to process.
|
||
|
|
goto process_message;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pLayerBuffer = pPicture;
|
||
|
|
pSecondLayerBufferOf3DMode = pSecondPictureOf3DMode;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
logv("++++topFiledFirst:%d topfiledError: %d, bBottomFieldError: %d", bTopFiledFirst, bTopFiledError, bBotFiledError);
|
||
|
|
if(bTopFiledError && nDeinterlaceTime == 0)
|
||
|
|
{
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pLayerBuffer, 0);
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
if(p->di)
|
||
|
|
p->di->reset();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if((bTopFiledError || bBotFiledError) && nDeinterlaceTime == 1)
|
||
|
|
{
|
||
|
|
logd("+++++ bot filed error");
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pLayerBuffer, 0);
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
if(p->di)
|
||
|
|
p->di->reset();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
//******************************************************
|
||
|
|
//* 6. wait according to the presentation time stamp.
|
||
|
|
//******************************************************
|
||
|
|
//step_6:
|
||
|
|
//* the first picture is showed unsychronized if the flag is 0
|
||
|
|
if(bFirstPictureShowed == 1
|
||
|
|
|| (bFirstPictureShowed == 0 && p->bSyncFirstPictureFlag == 1))
|
||
|
|
{
|
||
|
|
//* nWaitTime is in unit of ms.
|
||
|
|
nWaitTime = p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_PICTURE_PTS, (void*)&pLayerBuffer->nPts);
|
||
|
|
|
||
|
|
if (nWaitTime > 500)
|
||
|
|
{
|
||
|
|
nWaitTime = 500;
|
||
|
|
}
|
||
|
|
if (SEND_PTS_TO_SF == 1)
|
||
|
|
{
|
||
|
|
if (nWaitTime > 120)
|
||
|
|
{
|
||
|
|
nWaitTime -= 90;
|
||
|
|
}
|
||
|
|
else if(nWaitTime >= 0)
|
||
|
|
{
|
||
|
|
nWaitTime = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#if ((NATIVE_WIN_DISPLAY_CMD_GETDISPFPS == 1) && (CONFIG_OS == OPTION_OS_ANDROID) && (CONFIG_ALI_YUNOS == OPTION_ALI_YUNOS_NO))
|
||
|
|
int dropTime;
|
||
|
|
ANativeWindow *pNativeWindow = (ANativeWindow *)p->pNativeWindow;
|
||
|
|
if(pNativeWindow == NULL)
|
||
|
|
{
|
||
|
|
dropTime = -2500;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
int dispFPS = pNativeWindow->perform(pNativeWindow, NATIVE_WINDOW_GETPARAMETER, DISPLAY_CMD_GETDISPFPS);
|
||
|
|
int frameRate = 0;
|
||
|
|
if(p->pFrameRateEstimater)
|
||
|
|
{
|
||
|
|
frameRate = FramerateEstimaterGetFramerate(p->pFrameRateEstimater) / 1000;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
frameRate = pLayerBuffer->nFrameRate;
|
||
|
|
}
|
||
|
|
|
||
|
|
dropTime = -2500;
|
||
|
|
if (frameRate == 0)
|
||
|
|
frameRate = 25;
|
||
|
|
if (frameRate > 1000)
|
||
|
|
frameRate = (frameRate + 999) / 1000;
|
||
|
|
if (frameRate > dispFPS)
|
||
|
|
dropTime = -100;
|
||
|
|
|
||
|
|
if(dispFPS == 0)
|
||
|
|
dropTime = -2500;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
int dropTime = -2500;
|
||
|
|
#endif
|
||
|
|
logv("dropTime=%d", dropTime);
|
||
|
|
if(nWaitTime > 0)
|
||
|
|
{
|
||
|
|
int nWaitTimeOnce;
|
||
|
|
while(nWaitTime > 0)
|
||
|
|
{
|
||
|
|
//* wait for 100ms if no message come.
|
||
|
|
nWaitTimeOnce = (nWaitTime>100 ? 100 : nWaitTime);
|
||
|
|
ret = MessageQueueTryGetMessage(p->mq, &msg, nWaitTimeOnce);
|
||
|
|
if(ret == 0) //* new message come, quit loop to process.
|
||
|
|
{
|
||
|
|
//* if pLayerCtrl==null, we should return picture before process message
|
||
|
|
//* or the picture will never be returned.
|
||
|
|
if(p->pLayerCtrl == NULL)
|
||
|
|
{
|
||
|
|
if(bVideoWithTwoStream == 0)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
pPicture = NULL;
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pSecondPictureOf3DMode);
|
||
|
|
pPicture = NULL;
|
||
|
|
pSecondPictureOf3DMode = NULL;
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
goto process_message;
|
||
|
|
}
|
||
|
|
nWaitTime -= nWaitTimeOnce;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if(nWaitTime < -100 && bDeinterlaceFlag == 1)
|
||
|
|
{
|
||
|
|
//* if it is deinterlace and expired, we should drop it
|
||
|
|
#if 1
|
||
|
|
pPreLayerBuffer = pLayerBuffer;
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
if(nDeinterlaceTime == 0)
|
||
|
|
continue;
|
||
|
|
else
|
||
|
|
break;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
else if(nWaitTime < dropTime && bDeinterlaceFlag == 0)
|
||
|
|
{
|
||
|
|
loge("*** the picture is too late(%d ms), drop it",nWaitTime);
|
||
|
|
|
||
|
|
if(bNotDropFlag == 1)
|
||
|
|
{
|
||
|
|
//* not drop
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(bVideoWithTwoStream == 0)
|
||
|
|
{
|
||
|
|
if(nLayerBufferMode == LAYER_RESULT_USE_OUTSIDE_BUFFER)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pLayerBuffer);
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
}
|
||
|
|
pPreLayerBuffer = pLayerBuffer;
|
||
|
|
pPicture = NULL;
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(nLayerBufferMode == LAYER_RESULT_USE_OUTSIDE_BUFFER)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pLayerBuffer);
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pSecondLayerBufferOf3DMode);
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
pPreLayerBuffer = pLayerBuffer;
|
||
|
|
pPicture = NULL;
|
||
|
|
pSecondPictureOf3DMode = NULL;
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//******************************************************
|
||
|
|
//* 7. queue buffer to show.
|
||
|
|
//******************************************************
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
#if(CONFIG_CMCC==OPTION_CMCC_NO)
|
||
|
|
if ((p->pAvTimer != NULL)
|
||
|
|
&& (SEND_PTS_TO_SF == 1))
|
||
|
|
{
|
||
|
|
int64_t ptsAbs = p->pAvTimer->PtsToSystemTime(p->pAvTimer, pLayerBuffer->nPts);
|
||
|
|
p->mLayerOps->setBufferTimeStamp(p->pLayerCtrl, ptsAbs);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
int ptsSecs = (int)(pLayerBuffer->nPts/1000000);
|
||
|
|
if (p->ptsSecs != ptsSecs)
|
||
|
|
{
|
||
|
|
p->ptsSecs = ptsSecs;
|
||
|
|
logd("video pts(%.3f) ", pLayerBuffer->nPts/1000000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(bVideoWithTwoStream == 0)
|
||
|
|
{
|
||
|
|
p->mLayerOps->queueBuffer(p->pLayerCtrl, pLayerBuffer, 1);
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
p->mLayerOps->queue3DBuffer(p->pLayerCtrl, pLayerBuffer, pSecondLayerBufferOf3DMode, 1);
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//* if pLayerCtrl==null , we should return picture to decoder immediately
|
||
|
|
if(bVideoWithTwoStream == 0)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
pPicture = NULL;
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pSecondPictureOf3DMode);
|
||
|
|
pPicture = NULL;
|
||
|
|
pSecondPictureOf3DMode = NULL;
|
||
|
|
pLayerBuffer = NULL;
|
||
|
|
pSecondLayerBufferOf3DMode = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(p->pLayerCtrl != NULL &&
|
||
|
|
p->mLayerOps->ctrlIsVideoShow(p->pLayerCtrl) == 0 &&
|
||
|
|
bHideVideo == 0)
|
||
|
|
p->mLayerOps->ctrlShowVideo(p->pLayerCtrl);
|
||
|
|
|
||
|
|
if(p->callback)
|
||
|
|
{
|
||
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_VIDEO_FRAME, NULL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(bFirstPictureShowed == 0)
|
||
|
|
bFirstPictureShowed = 1;
|
||
|
|
|
||
|
|
if(p->eStatus == PLAYER_STATUS_STARTED)
|
||
|
|
PostRenderMessage(p->mq);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//* p->eStatus == PLAYER_STATUS_PAUSED && bFirstPictureShowed == 0
|
||
|
|
//* need to show the first picture as soon as we can after seek.
|
||
|
|
logi("first picture showed at paused status.");
|
||
|
|
}
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
else //* pPicture or pLayerBuffer not NULL.
|
||
|
|
{
|
||
|
|
//* continue last process.
|
||
|
|
if(pLayerBuffer != NULL)
|
||
|
|
goto step_5;
|
||
|
|
else if(bFirstPtsNotified == 1)
|
||
|
|
goto step_5;
|
||
|
|
else
|
||
|
|
goto step_4;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//* unknown message.
|
||
|
|
if(pReplyValue != NULL)
|
||
|
|
*pReplyValue = -1;
|
||
|
|
if(pReplySem)
|
||
|
|
sem_post(pReplySem);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
p->mLayerOps->release(p->pLayerCtrl);
|
||
|
|
p->pLayerCtrl = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = 0;
|
||
|
|
pthread_exit(&ret);
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void PostRenderMessage(MessageQueue* mq)
|
||
|
|
{
|
||
|
|
if(MessageQueueGetCount(mq)<=0)
|
||
|
|
{
|
||
|
|
Message msg;
|
||
|
|
msg.messageId = MESSAGE_ID_RENDER;
|
||
|
|
msg.params[0] = msg.params[1] = msg.params[2] = msg.params[3] = 0;
|
||
|
|
if(MessageQueuePostMessage(mq, &msg) != 0)
|
||
|
|
{
|
||
|
|
loge("fatal error, video render component post message fail.");
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static int IsVideoWithTwoStream(VideoDecComp* pDecComp)
|
||
|
|
{
|
||
|
|
VideoStreamInfo videoStreamInfo;
|
||
|
|
if(VideoDecCompGetVideoStreamInfo(pDecComp, &videoStreamInfo) == 0)
|
||
|
|
return videoStreamInfo.bIs3DStream;
|
||
|
|
else
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static int LayerCallback(void* pUserData, int eMessageId, void* param)
|
||
|
|
{
|
||
|
|
VideoPicture* pPicture;
|
||
|
|
VideoRenderCompContext* p;
|
||
|
|
|
||
|
|
p = (VideoRenderCompContext*)pUserData;
|
||
|
|
if(eMessageId == MESSAGE_ID_LAYER_RETURN_BUFFER)
|
||
|
|
{
|
||
|
|
pPicture = (VideoPicture*)param;
|
||
|
|
if(p->pDecComp != NULL)
|
||
|
|
{
|
||
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if(eMessageId == MESSAGE_ID_LAYER_NOTIFY_BUFFER)
|
||
|
|
{
|
||
|
|
if(p->callback)
|
||
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_VIDEO_BUFFER, param);
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void CheckScreenRotateAngle(VideoRenderCompContext* p,
|
||
|
|
VideoPicture* pPicture,
|
||
|
|
int bNeedResetAngleFlag)
|
||
|
|
{
|
||
|
|
if(p->pLayerCtrl != NULL)
|
||
|
|
{
|
||
|
|
int nCurRotation = p->mLayerOps->getRotationAngle(p->pLayerCtrl);
|
||
|
|
logv("**nCurRotation = %d",nCurRotation);
|
||
|
|
if(p->nRotationAngle != nCurRotation || bNeedResetAngleFlag == 1)
|
||
|
|
{
|
||
|
|
logv("**angle change : %d, %d",p->nRotationAngle,nCurRotation);
|
||
|
|
int nRotateWidth = pPicture->nWidth;
|
||
|
|
int nRotateHeight = pPicture->nHeight;
|
||
|
|
int nRotateTopOffset = 0;
|
||
|
|
int nRotateLeftOffset = 0;
|
||
|
|
int nRotateDisplayWidth = 0;
|
||
|
|
int nRotateDisplayHeight = 0;
|
||
|
|
|
||
|
|
if(nCurRotation == 0)
|
||
|
|
{
|
||
|
|
nRotateWidth = pPicture->nWidth;
|
||
|
|
nRotateHeight = pPicture->nHeight;
|
||
|
|
nRotateTopOffset = pPicture->nTopOffset;
|
||
|
|
nRotateLeftOffset = pPicture->nLeftOffset;
|
||
|
|
nRotateDisplayWidth = pPicture->nRightOffset - pPicture->nLeftOffset;
|
||
|
|
nRotateDisplayHeight = pPicture->nBottomOffset - pPicture->nTopOffset;
|
||
|
|
}
|
||
|
|
else if(nCurRotation == 90)
|
||
|
|
{
|
||
|
|
nRotateWidth = pPicture->nHeight;
|
||
|
|
nRotateHeight = pPicture->nWidth;
|
||
|
|
nRotateTopOffset = pPicture->nLeftOffset;
|
||
|
|
nRotateLeftOffset = pPicture->nHeight - pPicture->nBottomOffset;
|
||
|
|
nRotateDisplayWidth = pPicture->nBottomOffset - pPicture->nTopOffset;
|
||
|
|
nRotateDisplayHeight = pPicture->nRightOffset - pPicture->nLeftOffset;
|
||
|
|
}
|
||
|
|
else if(nCurRotation == 180)
|
||
|
|
{
|
||
|
|
nRotateWidth = pPicture->nWidth;
|
||
|
|
nRotateHeight = pPicture->nHeight;
|
||
|
|
nRotateTopOffset = pPicture->nHeight - pPicture->nBottomOffset;
|
||
|
|
nRotateLeftOffset = pPicture->nLineStride- pPicture->nRightOffset;
|
||
|
|
nRotateDisplayWidth = pPicture->nRightOffset - pPicture->nLeftOffset;
|
||
|
|
nRotateDisplayHeight = pPicture->nBottomOffset - pPicture->nTopOffset;
|
||
|
|
}
|
||
|
|
else if(nCurRotation == 270)
|
||
|
|
{
|
||
|
|
nRotateWidth = pPicture->nHeight;
|
||
|
|
nRotateHeight = pPicture->nWidth;
|
||
|
|
nRotateTopOffset = pPicture->nLineStride - pPicture->nRightOffset;
|
||
|
|
nRotateLeftOffset = pPicture->nTopOffset;
|
||
|
|
nRotateDisplayWidth = pPicture->nBottomOffset - pPicture->nTopOffset;
|
||
|
|
nRotateDisplayHeight = pPicture->nRightOffset - pPicture->nLeftOffset;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
loge("the nCurRotation is not 0, 90, 180, 270! is--%d",nCurRotation);
|
||
|
|
}
|
||
|
|
|
||
|
|
logv("nRotate %d rect info : w[%d], h[%d], l[%d], t[%d], dw[%d], dh[%d],realRrightO[%d],realBottom[%d]",
|
||
|
|
nCurRotation,
|
||
|
|
nRotateWidth,
|
||
|
|
nRotateHeight,
|
||
|
|
nRotateLeftOffset,
|
||
|
|
nRotateTopOffset,
|
||
|
|
nRotateDisplayWidth,
|
||
|
|
nRotateDisplayHeight,
|
||
|
|
pPicture->nRightOffset,
|
||
|
|
pPicture->nBottomOffset
|
||
|
|
);
|
||
|
|
//* reset the Layer
|
||
|
|
p->mLayerOps->setDisplayBufferSize(p->pLayerCtrl, nRotateWidth, nRotateHeight);
|
||
|
|
|
||
|
|
//* we should not the region when nRightOffset or nBottomOffset is 0
|
||
|
|
if(pPicture->nRightOffset != 0 && pPicture->nBottomOffset != 0)
|
||
|
|
{
|
||
|
|
p->mLayerOps->setDisplayRegion(p->pLayerCtrl,
|
||
|
|
nRotateLeftOffset,
|
||
|
|
nRotateTopOffset,
|
||
|
|
nRotateDisplayWidth,
|
||
|
|
nRotateDisplayHeight);
|
||
|
|
}
|
||
|
|
p->nRotationAngle = nCurRotation;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//*****************************************************************
|
||
|
|
//* showVideoDecodefps debug Instructions:
|
||
|
|
//* open debug: "adb shell setprop debug.cdx.videoDecodefps 1"
|
||
|
|
//* close debug: "adb shell setprop debug.cdx.videoDecodefps 0"
|
||
|
|
//*****************************************************************
|
||
|
|
static void showVideoDecodefps(VideoPicture* pPicture)
|
||
|
|
{
|
||
|
|
#if (CONFIG_OS != OPTION_OS_LINUX)
|
||
|
|
char property[PROPERTY_VALUE_MAX]={0};
|
||
|
|
int show_fps_settings = 0;
|
||
|
|
if (property_get("debug.cdx.videoDecodefps", property, NULL) >= 0)
|
||
|
|
{
|
||
|
|
if(property[0] == '1')
|
||
|
|
show_fps_settings = 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
logd("No videoDecodefps debug attribute node.");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pPicture != NULL && show_fps_settings == 1)
|
||
|
|
{
|
||
|
|
static int64_t nDebugLastTimeMs = systemTime()/1000000;
|
||
|
|
static int nFrameCnt = 0;
|
||
|
|
nFrameCnt++;
|
||
|
|
if (systemTime()/1000000 - nDebugLastTimeMs >= 1000)
|
||
|
|
{
|
||
|
|
logd("VideoDecodefps %dfps", nFrameCnt);
|
||
|
|
nDebugLastTimeMs = systemTime()/1000000;
|
||
|
|
nFrameCnt = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
VideoPicture* tmp = pPicture;
|
||
|
|
#endif
|
||
|
|
}
|