1733 lines
53 KiB
C++
Executable File
1733 lines
53 KiB
C++
Executable File
|
|
//#define CONFIG_LOG_LEVEL OPTION_LOG_LEVEL_DETAIL
|
|
//#define LOG_TAG "videoRenderComponent_newDisplay"
|
|
#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>
|
|
|
|
#define USE_DETNTERLACE 1
|
|
|
|
#if(CONFIG_PRODUCT == OPTION_PRODUCT_TVBOX)
|
|
#define SEND_PTS_TO_SF 0
|
|
#else
|
|
#define SEND_PTS_TO_SF 0
|
|
#endif
|
|
|
|
#if(CONFIG_DTV == OPTION_DTV_YES)
|
|
#define DTMB_PRODUCT 1
|
|
#else
|
|
#define DTMB_PRODUCT 0
|
|
#endif
|
|
|
|
extern LayerControlOpsT mNewLayerControlOps;
|
|
|
|
enum VIDEORENDERRESULT
|
|
{
|
|
VIDEO_RENDER_PROCESS_MESSAGE = 1,
|
|
VIDEO_RENDER_DEINTERLACE_RESET = 2,
|
|
VIDEO_RENDER_DROP_THE_PICTURE = 3,
|
|
VIDEO_RENDER_THREAD_CONTINUE = 4,
|
|
|
|
VIDEO_RENDER_RESULT_MIN = VDECODE_RESULT_UNSUPPORTED,
|
|
VIDEO_RENDER_RESULT_MAX = VDECODE_RESULT_RESOLUTION_CHANGE,
|
|
};
|
|
|
|
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;
|
|
NewLayerControlOpsT* mNewLayerOps;
|
|
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 bResolutionChange;
|
|
|
|
int bHadSetLayerInfoFlag;
|
|
int bProtectedBufferFlag;//* 1: mean the video picture is secure
|
|
|
|
//* for 3D video stream
|
|
int bVideoWithTwoStream;
|
|
|
|
//* for deinterlace
|
|
Deinterlace *di;
|
|
int bDeinterlaceFlag;
|
|
FbmBufInfo mFbmBufInfo;
|
|
|
|
//******
|
|
int bFirstPictureShowed;
|
|
int bNeedResetLayerParams;
|
|
int bHideVideo;
|
|
VideoPicture* pPicture;
|
|
VideoPicture* pPrePicture;
|
|
int bHadGetVideoFbmBufInfoFlag;
|
|
int nDeinterlaceDispNum;
|
|
int nGpuBufferNum;
|
|
int bHadSetBufferToDecoderFlag;
|
|
VideoPicture* pCancelPicture[4];
|
|
|
|
VideoPicture* pDiOutPicture;
|
|
int bResetBufToDecoderFlag;
|
|
int bHadRequestReleasePicFlag;
|
|
int nNeedReleaseBufferNum;
|
|
|
|
}VideoRenderCompContext;
|
|
|
|
static void* VideoRenderThread(void* arg);
|
|
static void PostRenderMessage(MessageQueue* mq);
|
|
static int IsVideoWithTwoStream(VideoDecComp* pDecComp);
|
|
|
|
static inline void NotifyVideoSizeAndSetDisplayRegion(VideoRenderCompContext* p);
|
|
|
|
static inline int ProcessVideoSync(VideoRenderCompContext* p,
|
|
VideoPicture* pPicture,
|
|
Message* msg);
|
|
static inline int QueueBufferToShow(VideoRenderCompContext* p,
|
|
VideoPicture* pPicture);
|
|
static inline int ProcessDeinterlace(VideoRenderCompContext* p,
|
|
int nDeinterlaceTime);
|
|
static inline int RenderGetVideoFbmBufInfo(VideoRenderCompContext* p);
|
|
|
|
static inline int SetGpuBufferToDecoder(VideoRenderCompContext*p);
|
|
|
|
static inline int ResetBufToDecoder(VideoRenderCompContext*p);
|
|
|
|
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(VideoRenderCompContext));
|
|
|
|
p->mNewLayerOps = __GetNewLayerControlOps();
|
|
p->nDeinterlaceDispNum = 1;
|
|
p->bVideoWithTwoStream = -1;
|
|
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->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(err != 0)
|
|
{
|
|
loge("(f:%s, l:%d) pthread_mutex_init fail!", __FUNCTION__, __LINE__);
|
|
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);
|
|
free(p);
|
|
return NULL;
|
|
}
|
|
|
|
return (VideoRenderComp*)p;
|
|
}
|
|
|
|
|
|
int VideoRenderCompDestroy(VideoRenderComp* v)
|
|
{
|
|
logd("VideoRenderCompDestroy!!!");
|
|
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);
|
|
|
|
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->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;
|
|
|
|
logw("video render component setting window: %p",pNativeWindow);
|
|
|
|
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 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] = (unsigned int)ePicture3DMode;
|
|
msg.params[3] = (unsigned int)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;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void VideoRenderCompSetProtecedFlag(VideoRenderComp* v, int bProtectedFlag)
|
|
{
|
|
VideoRenderCompContext* p;
|
|
|
|
p = (VideoRenderCompContext*)v;
|
|
|
|
p->bProtectedBufferFlag = bProtectedFlag;
|
|
|
|
return ;
|
|
}
|
|
|
|
int VideoRenderCompSetVideoStreamInfo(VideoRenderComp* v, VideoStreamInfo* pStreamInfo)
|
|
{
|
|
CEDARX_UNUSE(v);
|
|
CEDARX_UNUSE(pStreamInfo);
|
|
return 0;
|
|
}
|
|
|
|
int VideoRenderCompSetSyncFirstPictureFlag(VideoRenderComp* v, int bSyncFirstPictureFlag)
|
|
{
|
|
//*TODO
|
|
v;
|
|
bSyncFirstPictureFlag;
|
|
return 0;
|
|
}
|
|
|
|
int VideoRenderCompSetFrameRateEstimater(VideoRenderComp* v, FramerateEstimater* fe)
|
|
{
|
|
//* TODO
|
|
v;
|
|
fe;
|
|
return 0;
|
|
}
|
|
|
|
static void* VideoRenderThread(void* arg)
|
|
{
|
|
VideoRenderCompContext* p;
|
|
Message msg;
|
|
int ret;
|
|
sem_t* pReplySem;
|
|
int* pReplyValue;
|
|
int64_t nCurTime;
|
|
int nWaitTime;
|
|
int bFirstPtsNotified;
|
|
|
|
VideoPicture* pSecondPictureOf3DMode;
|
|
VideoPicture* pLayerBuffer;
|
|
VideoPicture* pSecondLayerBufferOf3DMode;
|
|
int bHoldLastPicture;
|
|
VideoPicture* pPreLayerBuffer;
|
|
int nLayerBufferMode;
|
|
|
|
p = (VideoRenderCompContext*)arg;
|
|
bFirstPtsNotified = 0;
|
|
pSecondPictureOf3DMode = NULL;
|
|
pLayerBuffer = NULL;
|
|
pSecondLayerBufferOf3DMode = NULL;
|
|
bHoldLastPicture = 0;
|
|
pPreLayerBuffer = NULL;
|
|
nLayerBufferMode = 0;
|
|
|
|
while(1)
|
|
{
|
|
|
|
get_message:
|
|
|
|
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)
|
|
{
|
|
p->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(p->pPicture != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPicture);
|
|
p->pPicture = NULL;
|
|
}
|
|
|
|
if(p->pPrePicture != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPrePicture);
|
|
p->pPrePicture = NULL;
|
|
}
|
|
|
|
if(p->pDiOutPicture != NULL)
|
|
{
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
p->mNewLayerOps->queueBuffer(p->pLayerCtrl, p->pDiOutPicture, 0);
|
|
}
|
|
p->pDiOutPicture = NULL;
|
|
}
|
|
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
if(bHoldLastPicture)
|
|
p->mNewLayerOps->ctrlHoldLastPicture(p->pLayerCtrl, 1);
|
|
else
|
|
{
|
|
p->mNewLayerOps->ctrlHoldLastPicture(p->pLayerCtrl, 0);
|
|
if(p->mNewLayerOps->ctrlIsVideoShow(p->pLayerCtrl) == 1)
|
|
p->mNewLayerOps->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 && p->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(p->bFirstPictureShowed == 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(p->pPicture != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPicture);
|
|
p->pPicture = NULL;
|
|
}
|
|
|
|
if(p->pPrePicture != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPrePicture);
|
|
p->pPrePicture = NULL;
|
|
}
|
|
|
|
if(p->pDiOutPicture != NULL)
|
|
{
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
p->mNewLayerOps->queueBuffer(p->pLayerCtrl, p->pDiOutPicture, 0);
|
|
}
|
|
p->pDiOutPicture = 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(p->pPicture != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPicture);
|
|
p->pPicture = NULL;
|
|
}
|
|
|
|
if(p->pPrePicture != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPrePicture);
|
|
p->pPrePicture = NULL;
|
|
}
|
|
|
|
if(p->pDiOutPicture != NULL)
|
|
{
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
p->mNewLayerOps->queueBuffer(p->pLayerCtrl, p->pDiOutPicture, 0);
|
|
}
|
|
p->pDiOutPicture = NULL;
|
|
}
|
|
|
|
//* clear the eos flag.
|
|
p->bEosFlag = 0;
|
|
p->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 && p->bFirstPictureShowed == 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 && p->bFirstPictureShowed == 0))
|
|
PostRenderMessage(p->mq);
|
|
}
|
|
else if(msg.messageId == MESSAGE_ID_SET_WINDOW)
|
|
{
|
|
logw("process MESSAGE_ID_SET_WINDOW message, p->pPicture(%p)",p->pPicture);
|
|
//* return buffer to old layer.
|
|
if(p->pPicture != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPicture);
|
|
p->pPicture = NULL;
|
|
}
|
|
|
|
if(p->pPrePicture != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPrePicture);
|
|
p->pPrePicture = NULL;
|
|
}
|
|
|
|
if(p->pDiOutPicture != NULL)
|
|
{
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
p->mNewLayerOps->queueBuffer(p->pLayerCtrl, p->pDiOutPicture, 0);
|
|
}
|
|
p->pDiOutPicture = NULL;
|
|
}
|
|
|
|
p->pNativeWindow = (void*)msg.params[2];
|
|
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
//* On the new-displayer of android, we not call LayerRelease,
|
|
//* just reset nativeWindow.
|
|
#if(CONFIG_OS == OPTION_OS_ANDROID)
|
|
|
|
VideoPicture* pPicture = NULL;
|
|
int nWhileNum = 0;
|
|
while(1)
|
|
{
|
|
nWhileNum++;
|
|
if(nWhileNum >= 100)
|
|
{
|
|
loge("get pic node time more than 100, it is wrong");
|
|
break;
|
|
}
|
|
|
|
pPicture = p->mNewLayerOps->getBufferOwnedByGpu(p->pLayerCtrl);
|
|
if(pPicture == NULL)
|
|
{
|
|
break;
|
|
}
|
|
VideoDecCompReturnPicture(p->pDecComp, pPicture);
|
|
}
|
|
|
|
p->mNewLayerOps->resetNativeWindow(p->pLayerCtrl,p->pNativeWindow);
|
|
VideoDecCompSetVideoFbmBufRelease(p->pDecComp);
|
|
p->bResetBufToDecoderFlag = 1;
|
|
p->nNeedReleaseBufferNum = p->nGpuBufferNum;
|
|
|
|
goto set_nativeWindow_exit;
|
|
#else
|
|
p->mNewLayerOps->release(p->pLayerCtrl);
|
|
p->pLayerCtrl = NULL;
|
|
#endif
|
|
}
|
|
|
|
|
|
//* 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->mNewLayerOps->init(p->pNativeWindow,p->bProtectedBufferFlag);
|
|
}
|
|
p->bNeedResetLayerParams = 1;
|
|
|
|
//* we should set layer info here if it hadn't set it
|
|
if(p->bHadSetLayerInfoFlag == 0 && p->mFbmBufInfo.nBufNum != 0)
|
|
{
|
|
enum EPIXELFORMAT eDisplayPixelFormat = PIXEL_FORMAT_DEFAULT;
|
|
FbmBufInfo* pFbmBufInfo = &p->mFbmBufInfo;
|
|
//* we init deinterlace device here
|
|
if(p->di != NULL && pFbmBufInfo->bProgressiveFlag == 0 && USE_DETNTERLACE && !DTMB_PRODUCT)
|
|
{
|
|
if (p->di->init() == 0)
|
|
{
|
|
int di_flag = p->di->flag();
|
|
p->bDeinterlaceFlag = 1;
|
|
p->nDeinterlaceDispNum = (di_flag == DE_INTERLACE_HW) ? 2 : 1;
|
|
}
|
|
else
|
|
{
|
|
logw(" open deinterlace failed , we not to use deinterlace!");
|
|
}
|
|
}
|
|
|
|
if(p->bDeinterlaceFlag == 1)
|
|
{
|
|
eDisplayPixelFormat = p->di->expectPixelFormat();
|
|
}
|
|
else
|
|
{
|
|
eDisplayPixelFormat = (enum EPIXELFORMAT)pFbmBufInfo->ePixelFormat;
|
|
}
|
|
|
|
p->mNewLayerOps->setDisplayPixelFormat(p->pLayerCtrl,(enum EPIXELFORMAT)pFbmBufInfo->ePixelFormat);
|
|
p->mNewLayerOps->setVideoWithTwoStreamFlag(p->pLayerCtrl,p->bVideoWithTwoStream);
|
|
p->mNewLayerOps->setIsSoftDecoderFlag(p->pLayerCtrl, pFbmBufInfo->bIsSoftDecoderFlag);
|
|
p->mNewLayerOps->setDisplayBufferSize(p->pLayerCtrl, pFbmBufInfo->nBufWidth, pFbmBufInfo->nBufHeight);
|
|
p->nGpuBufferNum = p->mNewLayerOps->setDisplayBufferCount(p->pLayerCtrl, pFbmBufInfo->nBufNum);
|
|
|
|
p->bHadSetLayerInfoFlag = 1;
|
|
}
|
|
|
|
set_nativeWindow_exit:
|
|
|
|
sem_post(pReplySem);
|
|
|
|
//* send a message to continue the thread.
|
|
if(p->eStatus == PLAYER_STATUS_STARTED ||
|
|
(p->eStatus == PLAYER_STATUS_PAUSED && p->bFirstPictureShowed == 0))
|
|
{
|
|
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 && p->bFirstPictureShowed == 0))
|
|
PostRenderMessage(p->mq);
|
|
}
|
|
else if(msg.messageId == MESSAGE_ID_SET_VIDEO_HIDE)
|
|
{
|
|
logi("process MESSAGE_ID_SET_VIDEO_HIDE message");
|
|
p->bHideVideo = msg.params[2];
|
|
if(p->bHideVideo == 1) //* hide video.
|
|
{
|
|
if(p->pLayerCtrl != NULL && p->mNewLayerOps->ctrlIsVideoShow(p->pLayerCtrl) == 1)
|
|
p->mNewLayerOps->ctrlHideVideo(p->pLayerCtrl);
|
|
}
|
|
else
|
|
{
|
|
if(p->pLayerCtrl != NULL &&
|
|
p->mNewLayerOps->ctrlIsVideoShow(p->pLayerCtrl) == 0 &&
|
|
p->bFirstPictureShowed == 1)
|
|
p->mNewLayerOps->ctrlShowVideo(p->pLayerCtrl);
|
|
}
|
|
sem_post(pReplySem);
|
|
|
|
//* send a message to continue the thread.
|
|
if(p->eStatus == PLAYER_STATUS_STARTED ||
|
|
(p->eStatus == PLAYER_STATUS_PAUSED && p->bFirstPictureShowed == 0))
|
|
PostRenderMessage(p->mq);
|
|
}
|
|
else if(msg.messageId == MESSAGE_ID_SET_HOLD_LAST_PICTURE)
|
|
{
|
|
logi("process MESSAGE_ID_SET_HOLD_LAST_PICTURE message");
|
|
bHoldLastPicture = msg.params[2];
|
|
sem_post(pReplySem);
|
|
|
|
//* send a message to continue the thread.
|
|
if(p->eStatus == PLAYER_STATUS_STARTED ||
|
|
(p->eStatus == PLAYER_STATUS_PAUSED && p->bFirstPictureShowed == 0))
|
|
PostRenderMessage(p->mq);
|
|
}
|
|
else if(msg.messageId == MESSAGE_ID_RENDER)
|
|
{
|
|
|
|
process_render:
|
|
|
|
logi("process MESSAGE_ID_RENDER message");
|
|
|
|
if(p->eStatus != PLAYER_STATUS_STARTED &&
|
|
!(p->eStatus == PLAYER_STATUS_PAUSED && p->bFirstPictureShowed == 0))
|
|
{
|
|
logw("not in started status, render message ignored.");
|
|
continue;
|
|
}
|
|
|
|
//* when nativeWindow change ,we should reset buffer to decoder
|
|
while(p->bResetBufToDecoderFlag == 1)
|
|
{
|
|
ret = ResetBufToDecoder(p);
|
|
if(ret == VIDEO_RENDER_THREAD_CONTINUE)
|
|
{
|
|
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;
|
|
|
|
PostRenderMessage(p->mq);
|
|
goto process_message;
|
|
}
|
|
else
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
logv(" *** bHadGetVideoFbmBufInfoFlag = %d",p->bHadGetVideoFbmBufInfoFlag);
|
|
//* get video fbm buf info
|
|
while(p->bHadGetVideoFbmBufInfoFlag == 0)
|
|
{
|
|
if(p->bEosFlag == 1)
|
|
{
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_EOS, NULL);
|
|
goto get_message;
|
|
}
|
|
|
|
if(RenderGetVideoFbmBufInfo(p) == 0)
|
|
{
|
|
p->bHadGetVideoFbmBufInfoFlag = 1;
|
|
}
|
|
else
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
logv(" *** bHadSetBufferToDecoderFlag = %d",p->bHadSetBufferToDecoderFlag);
|
|
//* set buffer to decoder
|
|
while(p->bHadSetBufferToDecoderFlag == 0)
|
|
{
|
|
if(p->bHadSetLayerInfoFlag)
|
|
{
|
|
SetGpuBufferToDecoder(p);
|
|
p->bHadSetBufferToDecoderFlag = 1;
|
|
}
|
|
else
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
if(p->pPicture != NULL) //* p->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
|
|
{
|
|
//*******************************
|
|
//* 1. get picture from display queue.
|
|
//*******************************
|
|
while(p->pPicture == NULL)
|
|
{
|
|
p->pPicture = VideoDecCompRequestPicture(p->pDecComp, 0, &p->bResolutionChange);
|
|
logv("** get picture, picture = %p",p->pPicture);
|
|
if(p->pPicture != NULL || (p->pPicture == NULL && p->bEosFlag))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if(p->bResolutionChange)
|
|
{
|
|
//* reopen the video engine.
|
|
VideoDecCompReopenVideoEngine(p->pDecComp);
|
|
//* reopen the layer.
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
if(p->bFirstPictureShowed == 1)
|
|
p->mNewLayerOps->ctrlHoldLastPicture(p->pLayerCtrl, 1);
|
|
p->mNewLayerOps->release(p->pLayerCtrl);
|
|
p->pLayerCtrl = NULL;
|
|
|
|
p->pLayerCtrl = p->mNewLayerOps->init(p->pNativeWindow,p->bProtectedBufferFlag);
|
|
if(p->pLayerCtrl != NULL)
|
|
p->bNeedResetLayerParams = 1;
|
|
}
|
|
p->bResolutionChange = 0;
|
|
p->bHadSetLayerInfoFlag = 0;
|
|
p->bHadGetVideoFbmBufInfoFlag = 0;
|
|
p->bHadSetBufferToDecoderFlag = 0;
|
|
|
|
goto process_render;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
//*****************************************************************
|
|
//* 2. handle EOS, p->pPicture should not be NULL except bEosFlag==1.
|
|
//*****************************************************************
|
|
if(p->pPicture == NULL)
|
|
{
|
|
if(p->bEosFlag == 1)
|
|
{
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_EOS, NULL);
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
loge("p->pPicture=NULL but bEosFlag is not set, shouldn't run here.");
|
|
abort();
|
|
}
|
|
}
|
|
|
|
//********************************************
|
|
//* 3. notify video size and set display region
|
|
//********************************************
|
|
if(p->bFirstPictureShowed == 0 || p->bNeedResetLayerParams == 1)
|
|
{
|
|
NotifyVideoSizeAndSetDisplayRegion(p);
|
|
p->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(p->bFirstPictureShowed != 0 && 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*)&p->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, p->pPicture);
|
|
p->pPicture = 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;
|
|
}
|
|
|
|
//******************************************************
|
|
//* 6. sync and show the picture
|
|
//******************************************************
|
|
step_5:
|
|
logv("** p->bDeinterlaceFlag[%d]",p->bDeinterlaceFlag);
|
|
if(p->bDeinterlaceFlag == 0)
|
|
{
|
|
#if DTMB_PRODUCT
|
|
if(p->bFirstPictureShowed == 0)
|
|
{
|
|
QueueBufferToShow(p, p->pPicture);
|
|
p->pPicture = NULL;
|
|
|
|
VideoPicture* pReturnPicture = NULL;
|
|
p->mNewLayerOps->dequeueBuffer(p->pLayerCtrl, &pReturnPicture, 0);
|
|
VideoDecCompReturnPicture(p->pDecComp, pReturnPicture);
|
|
}
|
|
#endif
|
|
//* 6.1. wait according to the presentation time stamp.
|
|
if(p->bFirstPictureShowed != 0) //* the first picture is showed unsychronized.
|
|
{
|
|
ret = ProcessVideoSync(p,p->pPicture,&msg);
|
|
if(ret == VIDEO_RENDER_PROCESS_MESSAGE)
|
|
{
|
|
goto process_message;
|
|
}
|
|
else if(ret == VIDEO_RENDER_DROP_THE_PICTURE)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPicture);
|
|
p->pPicture = NULL;
|
|
}
|
|
else
|
|
{
|
|
//* 6.2. queue buffer to show.
|
|
QueueBufferToShow(p, p->pPicture);
|
|
p->pPicture = NULL;
|
|
|
|
//* 6.3. dequeue buffer from gpu and return it to decoder
|
|
VideoPicture* pReturnPicture = NULL;
|
|
p->mNewLayerOps->dequeueBuffer(p->pLayerCtrl, &pReturnPicture, 0);
|
|
VideoDecCompReturnPicture(p->pDecComp, pReturnPicture);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int nDeinterlaceTime = 0; nDeinterlaceTime < p->nDeinterlaceDispNum; nDeinterlaceTime++)
|
|
{
|
|
//*6.1. deinterlace process
|
|
ret = ProcessDeinterlace(p, nDeinterlaceTime);
|
|
if(ret == VIDEO_RENDER_DEINTERLACE_RESET)
|
|
{
|
|
nDeinterlaceTime = 0;
|
|
continue;
|
|
}
|
|
|
|
//*6.2. sync process
|
|
if(p->bFirstPictureShowed != 0) //* the first picture is showed unsychronized.
|
|
{
|
|
ret = ProcessVideoSync(p, p->pDiOutPicture, &msg);
|
|
if(ret == VIDEO_RENDER_PROCESS_MESSAGE)
|
|
{
|
|
p->mNewLayerOps->queueBuffer(p->pLayerCtrl, p->pDiOutPicture, 0);
|
|
p->pDiOutPicture = NULL;
|
|
|
|
if(p->pPicture != p->pPrePicture && p->pPrePicture != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPrePicture);
|
|
}
|
|
p->pPrePicture = p->pPicture;
|
|
p->pPicture = NULL;
|
|
goto process_message;
|
|
}
|
|
else if(ret == VIDEO_RENDER_DROP_THE_PICTURE)
|
|
{
|
|
p->mNewLayerOps->queueBuffer(p->pLayerCtrl, p->pDiOutPicture, 0);
|
|
p->pDiOutPicture = NULL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//*6.3. queue buffer to show.
|
|
QueueBufferToShow(p, p->pDiOutPicture);
|
|
p->pDiOutPicture = NULL;
|
|
|
|
}
|
|
|
|
//* we return the pic to decoder, no need queue to gpu
|
|
if(p->pPicture != p->pPrePicture && p->pPrePicture != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPrePicture);
|
|
}
|
|
p->pPrePicture = p->pPicture;
|
|
p->pPicture = NULL;
|
|
}
|
|
|
|
if(p->bFirstPictureShowed == 0)
|
|
p->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
|
|
{
|
|
//* unknown message.
|
|
if(pReplyValue != NULL)
|
|
*pReplyValue = -1;
|
|
if(pReplySem)
|
|
sem_post(pReplySem);
|
|
}
|
|
}
|
|
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
p->mNewLayerOps->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 inline void NotifyVideoSizeAndSetDisplayRegion(VideoRenderCompContext* p)
|
|
{
|
|
int size[4];
|
|
|
|
if((p->pPicture->nRightOffset - p->pPicture->nLeftOffset) > 0 &&
|
|
(p->pPicture->nBottomOffset - p->pPicture->nTopOffset) > 0)
|
|
{
|
|
size[0] = p->pPicture->nRightOffset - p->pPicture->nLeftOffset;
|
|
size[1] = p->pPicture->nBottomOffset - p->pPicture->nTopOffset;
|
|
size[2] = 0;
|
|
size[3] = 0;
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_VIDEO_SIZE, (void*)size);
|
|
|
|
size[0] = p->pPicture->nLeftOffset;
|
|
size[1] = p->pPicture->nTopOffset;
|
|
size[2] = p->pPicture->nRightOffset - p->pPicture->nLeftOffset;
|
|
size[3] = p->pPicture->nBottomOffset - p->pPicture->nTopOffset;
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_VIDEO_CROP, (void*)size);
|
|
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
p->mNewLayerOps->setDisplayRegion(p->pLayerCtrl,
|
|
p->pPicture->nLeftOffset,
|
|
p->pPicture->nTopOffset,
|
|
p->pPicture->nRightOffset - p->pPicture->nLeftOffset,
|
|
p->pPicture->nBottomOffset - p->pPicture->nTopOffset);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
logw("the offset of picture is not right, we set bufferWidht and \
|
|
bufferHeight as video size, this is maybe wrong, offset: %d, %d, %d, %d",
|
|
p->pPicture->nLeftOffset,p->pPicture->nRightOffset,
|
|
p->pPicture->nTopOffset,p->pPicture->nBottomOffset);
|
|
size[0] = p->pPicture->nWidth;
|
|
size[1] = p->pPicture->nHeight;
|
|
size[2] = 0;
|
|
size[3] = 0;
|
|
p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_VIDEO_SIZE, (void*)size);
|
|
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
p->mNewLayerOps->setDisplayRegion(p->pLayerCtrl,
|
|
0,
|
|
0,
|
|
p->pPicture->nWidth,
|
|
p->pPicture->nHeight);
|
|
}
|
|
}
|
|
|
|
return ;
|
|
}
|
|
|
|
static inline int ProcessVideoSync(VideoRenderCompContext* p,
|
|
VideoPicture* pPicture,
|
|
Message* msg)
|
|
{
|
|
int nWaitTime;
|
|
int ret;
|
|
|
|
nWaitTime = p->callback(p->pUserData, PLAYER_VIDEO_RENDER_NOTIFY_PICTURE_PTS, (void*)&pPicture->nPts);
|
|
|
|
if (SEND_PTS_TO_SF == 1)
|
|
{
|
|
if (nWaitTime > 120)
|
|
{
|
|
nWaitTime -= 90;
|
|
}
|
|
else if(nWaitTime >= 0)
|
|
{
|
|
nWaitTime = 0;
|
|
}
|
|
}
|
|
logv("nWaitTime=%d", nWaitTime);
|
|
|
|
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.
|
|
{
|
|
logw("**** detect message coming, nWaitTime = %d",nWaitTime);
|
|
//* if pLayerCtrl==null, we should return picture before process message
|
|
//* or the picture will never be returned.
|
|
#if 0
|
|
if(p->pLayerCtrl == NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPicture);
|
|
p->pPicture = NULL;
|
|
pLayerBuffer = NULL;
|
|
}
|
|
#endif
|
|
return VIDEO_RENDER_PROCESS_MESSAGE;
|
|
}
|
|
nWaitTime -= nWaitTimeOnce;
|
|
}
|
|
}
|
|
else if(nWaitTime < -10 && p->bDeinterlaceFlag == 1)
|
|
{
|
|
//* if it is deinterlace and expired, we should drop it
|
|
return VIDEO_RENDER_DROP_THE_PICTURE;
|
|
}
|
|
#if (CONFIG_PRODUCT == OPTION_PRODUCT_TVBOX)
|
|
else if(nWaitTime < -100)
|
|
{
|
|
int nDispFPS = p->mNewLayerOps->getDisplayFPS(p->pLayerCtrl);
|
|
if(nDispFPS <= 30)
|
|
{
|
|
/* when disp in 24fps/30fps, SurfaceFlinger could not drop-frame correctly when video framerate larger than 2x */
|
|
/* so we drop it here */
|
|
logd("drop frame nWaitTime=%d, nDispFPS=%d, nFrameRate=%d.", nWaitTime, nDispFPS, pPicture->nFrameRate);
|
|
return VIDEO_RENDER_DROP_THE_PICTURE;
|
|
}
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static inline int QueueBufferToShow(VideoRenderCompContext* p,
|
|
VideoPicture* pPicture)
|
|
{
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
if (SEND_PTS_TO_SF == 1)
|
|
{
|
|
int64_t ptsAbs = p->pAvTimer->PtsToSystemTime(p->pAvTimer, pPicture->nPts);
|
|
p->mNewLayerOps->setBufferTimeStamp(p->pLayerCtrl, ptsAbs);
|
|
}
|
|
p->mNewLayerOps->queueBuffer(p->pLayerCtrl, pPicture, 1);
|
|
}
|
|
else
|
|
{
|
|
//* if pLayerCtrl==null , we should return picture to decoder immediately
|
|
#if 0
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPicture);
|
|
p->pPicture = NULL;
|
|
pLayerBuffer = NULL;
|
|
#endif
|
|
}
|
|
|
|
if(p->pLayerCtrl != NULL &&
|
|
p->mNewLayerOps->ctrlIsVideoShow(p->pLayerCtrl) == 0 &&
|
|
p->bHideVideo == 0)
|
|
{
|
|
p->mNewLayerOps->ctrlShowVideo(p->pLayerCtrl);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline int ProcessDeinterlace(VideoRenderCompContext* p,
|
|
int nDeinterlaceTime)
|
|
{
|
|
//* deinterlace process
|
|
int ret = -1;
|
|
|
|
if(p->pPrePicture == NULL)
|
|
{
|
|
p->pPrePicture = p->pPicture;
|
|
}
|
|
ret = p->mNewLayerOps->dequeueBuffer(p->pLayerCtrl, &p->pDiOutPicture, 0);
|
|
if(ret != 0)
|
|
{
|
|
loge("** dequeue buffer failed when process deinterlace");
|
|
return -1;
|
|
}
|
|
|
|
int diret = p->di->process(p->pPrePicture,
|
|
p->pPicture,
|
|
p->pDiOutPicture,
|
|
nDeinterlaceTime);
|
|
if (diret != 0)
|
|
{
|
|
p->di->reset();
|
|
|
|
VideoDecCompReturnPicture(p->pDecComp, p->pPrePicture);
|
|
p->mNewLayerOps->queueBuffer(p->pLayerCtrl, p->pDiOutPicture, 0);
|
|
p->pPrePicture = NULL;
|
|
p->pDiOutPicture = NULL;
|
|
return VIDEO_RENDER_DEINTERLACE_RESET;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static inline int RenderGetVideoFbmBufInfo(VideoRenderCompContext* p)
|
|
{
|
|
enum EPIXELFORMAT eDisplayPixelFormat = PIXEL_FORMAT_DEFAULT;
|
|
FbmBufInfo* pFbmBufInfo = VideoDecCompGetVideoFbmBufInfo(p->pDecComp);
|
|
|
|
logv("pFbmBufInfo = %p",pFbmBufInfo);
|
|
|
|
if(pFbmBufInfo != NULL)
|
|
{
|
|
memcpy(&p->mFbmBufInfo, pFbmBufInfo, sizeof(FbmBufInfo));
|
|
//* We check whether it is a 3D stream here,
|
|
//* because Layer must know whether it 3D stream at the beginning;
|
|
p->bVideoWithTwoStream = IsVideoWithTwoStream(p->pDecComp);
|
|
|
|
if(p->bVideoWithTwoStream == -1)
|
|
p->bVideoWithTwoStream = 0;
|
|
|
|
if(p->pLayerCtrl != NULL)
|
|
{
|
|
logd("video buffer info: nWidth[%d],nHeight[%d],nBufferCount[%d],ePixelFormat[%d]",
|
|
pFbmBufInfo->nBufWidth,pFbmBufInfo->nBufHeight,
|
|
pFbmBufInfo->nBufNum,pFbmBufInfo->ePixelFormat);
|
|
logd("video buffer info: nAlignValue[%d],bProgressiveFlag[%d],bIsSoftDecoderFlag[%d]",
|
|
pFbmBufInfo->nAlignValue,pFbmBufInfo->bProgressiveFlag,
|
|
pFbmBufInfo->bIsSoftDecoderFlag);
|
|
|
|
//* we init deinterlace device here
|
|
if(p->di != NULL && pFbmBufInfo->bProgressiveFlag == 0 && USE_DETNTERLACE && !DTMB_PRODUCT)
|
|
{
|
|
if (p->di->init() == 0)
|
|
{
|
|
int di_flag = p->di->flag();
|
|
p->bDeinterlaceFlag = 1;
|
|
p->nDeinterlaceDispNum = (di_flag == DE_INTERLACE_HW) ? 2 : 1;
|
|
}
|
|
else
|
|
{
|
|
logw(" open deinterlace failed , we not to use deinterlace!");
|
|
}
|
|
}
|
|
|
|
if(p->bDeinterlaceFlag == 1)
|
|
{
|
|
eDisplayPixelFormat = p->di->expectPixelFormat();
|
|
}
|
|
else
|
|
{
|
|
eDisplayPixelFormat = (enum EPIXELFORMAT)pFbmBufInfo->ePixelFormat;
|
|
}
|
|
|
|
p->mNewLayerOps->setDisplayPixelFormat(p->pLayerCtrl,eDisplayPixelFormat);
|
|
p->mNewLayerOps->setDisplayBufferSize(p->pLayerCtrl, pFbmBufInfo->nBufWidth, pFbmBufInfo->nBufHeight);
|
|
p->mNewLayerOps->setVideoWithTwoStreamFlag(p->pLayerCtrl,p->bVideoWithTwoStream);
|
|
p->mNewLayerOps->setIsSoftDecoderFlag(p->pLayerCtrl, pFbmBufInfo->bIsSoftDecoderFlag);
|
|
p->nGpuBufferNum = p->mNewLayerOps->setDisplayBufferCount(p->pLayerCtrl, pFbmBufInfo->nBufNum);
|
|
|
|
p->bHadSetLayerInfoFlag = 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static inline int SetGpuBufferToDecoder(VideoRenderCompContext*p)
|
|
{
|
|
VideoPicture mTmpVideoPicture;
|
|
VideoPicture* pTmpVideoPicture = &mTmpVideoPicture;
|
|
int nLayerBufferNum = p->mNewLayerOps->getBufferNumHoldByGpu(p->pLayerCtrl);
|
|
memset(pTmpVideoPicture, 0, sizeof(VideoPicture));
|
|
for(int i = 0; i< p->nGpuBufferNum; i++)
|
|
{
|
|
int ret = p->mNewLayerOps->dequeueBuffer(p->pLayerCtrl, &pTmpVideoPicture, 1);
|
|
if(ret == 0)
|
|
{
|
|
if (i >= p->nGpuBufferNum - nLayerBufferNum)
|
|
{
|
|
p->pCancelPicture[i-(p->nGpuBufferNum-nLayerBufferNum)] = VideoDecCompSetVideoFbmBufAddress(p->pDecComp, pTmpVideoPicture, 1);
|
|
}
|
|
else
|
|
{
|
|
VideoDecCompSetVideoFbmBufAddress(p->pDecComp, pTmpVideoPicture, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
loge("*** dequeue buffer failed when set-buffer-to-decoder");
|
|
abort();
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < nLayerBufferNum; ++i)
|
|
{
|
|
p->mNewLayerOps->queueBuffer(p->pLayerCtrl, p->pCancelPicture[i], 0);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static inline int ResetBufToDecoder(VideoRenderCompContext*p)
|
|
{
|
|
int ret = 0;
|
|
VideoPicture* pReleasePicture = NULL;
|
|
|
|
if(p->bHadRequestReleasePicFlag == 0)
|
|
{
|
|
pReleasePicture = VideoDecCompRequestReleasePicture(p->pDecComp);
|
|
|
|
logv("*** pReleasePicture(%p),nNeedReleaseBufferNum(%d)",
|
|
pReleasePicture,p->nNeedReleaseBufferNum);
|
|
|
|
if(pReleasePicture != NULL)
|
|
{
|
|
p->mNewLayerOps->releaseBuffer(p->pLayerCtrl, pReleasePicture);
|
|
}
|
|
else
|
|
{
|
|
//* we drop the picture here, or the decoder will block and
|
|
//* can not return all the ReleasePicture
|
|
VideoPicture* pRequestPic = NULL;
|
|
int nResolutionChange = 0;
|
|
pRequestPic = VideoDecCompRequestPicture(p->pDecComp, 0, &nResolutionChange);
|
|
if(pRequestPic != NULL)
|
|
{
|
|
VideoDecCompReturnPicture(p->pDecComp, pRequestPic);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(p->bHadRequestReleasePicFlag == 1 || pReleasePicture != NULL)
|
|
{
|
|
VideoPicture mTmpReturnPicture;
|
|
memset(&mTmpReturnPicture, 0, sizeof(VideoPicture));
|
|
VideoPicture* pTmpReturnPicture = &mTmpReturnPicture;
|
|
ret = p->mNewLayerOps->dequeueBuffer(p->pLayerCtrl, &pTmpReturnPicture, 1);
|
|
if(ret == 0)
|
|
{
|
|
if(p->nNeedReleaseBufferNum == 2 || p->nNeedReleaseBufferNum == 1)
|
|
{
|
|
pTmpReturnPicture = VideoDecCompReturnRelasePicture(p->pDecComp, pTmpReturnPicture, 1);
|
|
p->mNewLayerOps->queueBuffer(p->pLayerCtrl, pTmpReturnPicture, 0);
|
|
}
|
|
else
|
|
{
|
|
VideoDecCompReturnRelasePicture(p->pDecComp, pTmpReturnPicture, 0);
|
|
}
|
|
|
|
if(p->bHadRequestReleasePicFlag == 1)
|
|
{
|
|
p->bHadRequestReleasePicFlag = 0;
|
|
}
|
|
|
|
p->nNeedReleaseBufferNum--;
|
|
|
|
if(p->nNeedReleaseBufferNum <= 0)
|
|
{
|
|
p->bResetBufToDecoderFlag = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p->bHadRequestReleasePicFlag = 1;
|
|
return VIDEO_RENDER_THREAD_CONTINUE;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|