710 lines
21 KiB
C++
Executable File
710 lines
21 KiB
C++
Executable File
/*
|
|
********************************************************************************
|
|
* Android multimedia module
|
|
*
|
|
* (c) Copyright 2010-2015, Allwinner Microelectronic Co., Ltd.
|
|
* All Rights Reserved
|
|
*
|
|
* File : StarkModel.cpp
|
|
* Version: V1.0
|
|
* By : eric_wang
|
|
* Date : 2015-7-10
|
|
* Description:
|
|
********************************************************************************
|
|
*/
|
|
//#define LOG_NDEBUG 0
|
|
#define LOG_TAG "StarkModel"
|
|
#include <utils/plat_log.h>
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <fstream>
|
|
|
|
#include <hwdisplay.h>
|
|
#include <mpi_vo.h>
|
|
#include "StarkModel.h"
|
|
#include "stringOperate.h"
|
|
#include "BaseMessageHandler.h"
|
|
//#include <fb.h>
|
|
#include <EyeseePlayer.h>
|
|
|
|
using namespace std;
|
|
|
|
namespace EyeseeLinux {
|
|
|
|
static status_t parseFileList(char *pFileListPath, vector<string>& mediaFileList)
|
|
{
|
|
mediaFileList.clear();
|
|
if(NULL == pFileListPath || 0==strlen(pFileListPath))
|
|
{
|
|
aloge("fatal error! pFileListPath[%s] wrong!", pFileListPath);
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
string tmp;
|
|
ifstream is(pFileListPath, ios_base::in);
|
|
if(!is.is_open())
|
|
{
|
|
aloge("fatal error! open[%s] fail!", pFileListPath);
|
|
goto _err0;
|
|
}
|
|
while(getline(is,tmp))
|
|
{
|
|
removeCharFromString(tmp, '\"');
|
|
removeCharFromString(tmp, '\r');
|
|
removeCharFromString(tmp, '\n');
|
|
mediaFileList.push_back(tmp);
|
|
//alogd("read file[%s], is.rdstate=%d", pFileListPath, is.rdstate());
|
|
}
|
|
//alogd("read file[%s], is.rdstate=%d", pFileListPath, is.rdstate());
|
|
alogd("parse fileList[%s], get [%d]files", pFileListPath, mediaFileList.size());
|
|
for(size_t i=0; i<mediaFileList.size(); i++)
|
|
{
|
|
alogd("file[%d]:[%s]", i, mediaFileList[i].c_str());
|
|
}
|
|
//is.close();
|
|
return NO_ERROR;
|
|
|
|
_err0:
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
StarkModel::InnerThread::InnerThread(StarkModel *pOwner)
|
|
:mpOwner(pOwner)
|
|
{
|
|
mThreadId = 0;
|
|
}
|
|
void StarkModel::InnerThread::start()
|
|
{
|
|
run("StarkModelThread");
|
|
}
|
|
void StarkModel::InnerThread::stop()
|
|
{
|
|
requestExitAndWait();
|
|
}
|
|
status_t StarkModel::InnerThread::readyToRun()
|
|
{
|
|
mThreadId = pthread_self();
|
|
return Thread::readyToRun();
|
|
}
|
|
bool StarkModel::InnerThread::threadLoop()
|
|
{
|
|
if(!exitPending())
|
|
{
|
|
return mpOwner->StarkModelThread();
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
StarkModel::PlayerListener::PlayerListener(StarkModel *pOwner)
|
|
: mpOwner(pOwner)
|
|
{
|
|
}
|
|
|
|
void StarkModel::PlayerListener::onPrepared(EyeseePlayer *pMp)
|
|
{
|
|
alogd("receive onPrepared message!");
|
|
Mutex::Autolock autoLock(mpOwner->mPlayerListenerLock);
|
|
mpOwner->mbPrepareDone = true;
|
|
mpOwner->mOnPrepared.signal();
|
|
}
|
|
void StarkModel::PlayerListener::onCompletion(EyeseePlayer *pMp)
|
|
{
|
|
alogd("receive onCompletion message!");
|
|
Mutex::Autolock autoLock(mpOwner->mPlayerListenerLock);
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_PLAYBACK_COMPLETED;
|
|
mpOwner->mMsgQueue.queueMessage(&msgIn);
|
|
}
|
|
bool StarkModel::PlayerListener::onError(EyeseePlayer *pMp, int what, int extra)
|
|
{
|
|
alogd("receive onError message![%d][%d]", what, extra); //MEDIA_ERROR_UNKNOWN
|
|
Mutex::Autolock autoLock(mpOwner->mPlayerListenerLock);
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_ERROR_MEDIA_ERROR;
|
|
msgIn.mPara0 = what;
|
|
msgIn.mPara1 = extra;
|
|
mpOwner->mMsgQueue.queueMessage(&msgIn);
|
|
return true;
|
|
}
|
|
void StarkModel::PlayerListener::onVideoSizeChanged(EyeseePlayer *pMp, int width, int height)
|
|
{
|
|
alogd("receive onVideoSizeChanged message!size[%dx%d]", width, height);
|
|
Mutex::Autolock autoLock(mpOwner->mPlayerListenerLock);
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_MEDIA_SET_VIDEO_SIZE;
|
|
msgIn.mPara0 = width;
|
|
msgIn.mPara1 = height;
|
|
mpOwner->mMsgQueue.queueMessage(&msgIn);
|
|
}
|
|
bool StarkModel::PlayerListener::onInfo(EyeseePlayer *pMp, int what, int extra)
|
|
{
|
|
alogd("receive onInfo message! media_info_type[%d] extra[%d]", what, extra);
|
|
Mutex::Autolock autoLock(mpOwner->mPlayerListenerLock);
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_MEDIA_INFO;
|
|
msgIn.mPara0 = what;
|
|
msgIn.mPara1 = extra;
|
|
mpOwner->mMsgQueue.queueMessage(&msgIn);
|
|
return true;
|
|
}
|
|
void StarkModel::PlayerListener::onSeekComplete(EyeseePlayer *pMp)
|
|
{
|
|
alogd("receive onSeekComplete message!");
|
|
Mutex::Autolock autoLock(mpOwner->mPlayerListenerLock);
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_MEDIA_SEEK_COMPLETE;
|
|
mpOwner->mMsgQueue.queueMessage(&msgIn);
|
|
}
|
|
StarkModel::StarkModel()
|
|
: mPlayerListener(this)
|
|
{
|
|
mOnMessageListener = NULL;
|
|
mCMP = NULL;
|
|
mHLay = -1;
|
|
mPrerequisiteFlag = false;
|
|
mPlayMode = PlayMode_OneFile;
|
|
mCurMediaFileIndex = -1;
|
|
|
|
mbPrepareDone = false;
|
|
mCurrentState = STATE_IDLE;
|
|
mpInnerThread = NULL;
|
|
}
|
|
StarkModel::~StarkModel()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
int StarkModel::getCurrentState()
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
return mCurrentState;
|
|
}
|
|
status_t StarkModel::init()
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(mCurrentState == STATE_INITIALIZED)
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
if(mCurrentState != STATE_IDLE)
|
|
{
|
|
aloge("init called in an invalid state: %d", mCurrentState);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
mpInnerThread = new InnerThread(this);
|
|
mpInnerThread->start();
|
|
mCurrentState = STATE_INITIALIZED;
|
|
return NO_ERROR;
|
|
}
|
|
status_t StarkModel::reset()
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(mCurrentState == STATE_IDLE)
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
if(mpInnerThread!=NULL)
|
|
{
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_QUIT_THREAD;
|
|
mMsgQueue.queueMessage(&msgIn);
|
|
mpInnerThread->stop();
|
|
delete mpInnerThread;
|
|
mpInnerThread = NULL;
|
|
}
|
|
mMsgQueue.flushMessage();
|
|
mOnMessageListener = NULL;
|
|
if(mPrerequisiteFlag)
|
|
{
|
|
mCMP->reset();
|
|
delete mCMP;
|
|
mCMP = NULL;
|
|
|
|
//hwd_layer_close(mHLay);
|
|
//hwd_layer_release(mHLay);
|
|
AW_MPI_VO_DisableVideoLayer(mHLay);
|
|
mHLay = -1;
|
|
|
|
mPrerequisiteFlag = false;
|
|
}
|
|
mbPrepareDone = false;
|
|
mPlayMode = PlayMode_OneFile;
|
|
mMediaFileList.clear();
|
|
mCurMediaFileIndex = -1;
|
|
mCurrentState = STATE_IDLE;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
void StarkModel::setOnMessageListener(OnMessageListener *pListener)
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
mOnMessageListener = pListener;
|
|
}
|
|
|
|
status_t StarkModel::playFile(char *pFilePath)
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(mCurrentState == STATE_STARTED)
|
|
{
|
|
alogd("already state[0x%x], return immediately", mCurrentState);
|
|
return NO_ERROR;
|
|
}
|
|
if(mCurrentState != STATE_INITIALIZED)
|
|
{
|
|
aloge("playFile called in an invalid state: %d", mCurrentState);
|
|
return INVALID_OPERATION;
|
|
}
|
|
if(NULL==pFilePath || 0==strlen(pFilePath))
|
|
{
|
|
aloge("fatal error! pFilePath[%s] wrong!", pFilePath);
|
|
return BAD_VALUE;
|
|
}
|
|
mPlayMode = PlayMode_OneFile;
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_PLAY_FILE;
|
|
msgIn.setData(pFilePath, strlen(pFilePath)+1);
|
|
mMsgQueue.queueMessage(&msgIn);
|
|
mCurrentState = STATE_STARTED;
|
|
return NO_ERROR;
|
|
}
|
|
status_t StarkModel::playFileLoop(char *pFilePath)
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(mCurrentState == STATE_STARTED || mCurrentState == STATE_PAUSED)
|
|
{
|
|
alogd("already state[0x%x], reject operation, return immediately", mCurrentState);
|
|
return NO_ERROR;
|
|
}
|
|
if(mCurrentState != STATE_INITIALIZED)
|
|
{
|
|
aloge("playFile called in an invalid state: %d", mCurrentState);
|
|
return INVALID_OPERATION;
|
|
}
|
|
if(NULL==pFilePath || 0==strlen(pFilePath))
|
|
{
|
|
aloge("fatal error! pFilePath[%s] wrong!", pFilePath);
|
|
return BAD_VALUE;
|
|
}
|
|
mPlayMode = PlayMode_OneFileLoop;
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_PLAY_FILE;
|
|
msgIn.setData(pFilePath, strlen(pFilePath)+1);
|
|
mMsgQueue.queueMessage(&msgIn);
|
|
mCurrentState = STATE_STARTED;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t StarkModel::playListLoop(char *pFileListPath)
|
|
{
|
|
status_t ret;
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(mCurrentState == STATE_STARTED || mCurrentState == STATE_PAUSED)
|
|
{
|
|
alogd("already state[0x%x], reject operation, return immediately", mCurrentState);
|
|
return NO_ERROR;
|
|
}
|
|
if(mCurrentState != STATE_INITIALIZED)
|
|
{
|
|
aloge("playFile called in an invalid state: %d", mCurrentState);
|
|
return INVALID_OPERATION;
|
|
}
|
|
if(NULL==pFileListPath || 0==strlen(pFileListPath))
|
|
{
|
|
aloge("fatal error! pFileListPath[%s] wrong!", pFileListPath);
|
|
return BAD_VALUE;
|
|
}
|
|
mPlayMode = PlayMode_ListLoop;
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_PLAY_LIST_LOOP;
|
|
msgIn.setData(pFileListPath, strlen(pFileListPath)+1);
|
|
mMsgQueue.queueMessage(&msgIn);
|
|
mCurrentState = STATE_STARTED;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t StarkModel::pauseFile()
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(mCurrentState == STATE_PAUSED)
|
|
{
|
|
alogd("already state[0x%x], return immediately", mCurrentState);
|
|
return NO_ERROR;
|
|
}
|
|
if(mCurrentState != STATE_STARTED)
|
|
{
|
|
aloge("pauseFile called in an invalid state: %d", mCurrentState);
|
|
return INVALID_OPERATION;
|
|
}
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_PAUSE_FILE;
|
|
mMsgQueue.queueMessage(&msgIn);
|
|
mExecuteDoneCondition.wait(mLock);
|
|
mCurrentState = STATE_PAUSED;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t StarkModel::resumeFile()
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(mCurrentState == STATE_STARTED)
|
|
{
|
|
alogd("already state[0x%x], return immediately", mCurrentState);
|
|
return NO_ERROR;
|
|
}
|
|
if(mCurrentState != STATE_PAUSED)
|
|
{
|
|
aloge("resumeFile called in an invalid state: %d", mCurrentState);
|
|
return INVALID_OPERATION;
|
|
}
|
|
alogd("pause->play");
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_RESUME_FILE;
|
|
mMsgQueue.queueMessage(&msgIn);
|
|
mExecuteDoneCondition.wait(mLock);
|
|
mCurrentState = STATE_STARTED;
|
|
return NO_ERROR;
|
|
}
|
|
status_t StarkModel::seekFile(int msec)
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(mCurrentState != STATE_STARTED && mCurrentState != STATE_PAUSED)
|
|
{
|
|
aloge("seekFile called in an invalid state: %d", mCurrentState);
|
|
return INVALID_OPERATION;
|
|
}
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_SEEK_FILE;
|
|
msgIn.mPara0 = msec;
|
|
mMsgQueue.queueMessage(&msgIn);
|
|
mExecuteDoneCondition.wait(mLock);
|
|
return NO_ERROR;
|
|
}
|
|
status_t StarkModel::stopFile()
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(mCurrentState == STATE_INITIALIZED)
|
|
{
|
|
alogd("already state[0x%x], return immediately", mCurrentState);
|
|
return NO_ERROR;
|
|
}
|
|
if(mCurrentState != STATE_STARTED && mCurrentState != STATE_PAUSED)
|
|
{
|
|
aloge("stopFile called in an invalid state: %d", mCurrentState);
|
|
return INVALID_OPERATION;
|
|
}
|
|
EyeseeMessage msgIn;
|
|
msgIn.mWhoseMsg = MessageOfStarkModel;
|
|
msgIn.mMsgType = MSGTYPE_STOP_FILE;
|
|
mMsgQueue.queueMessage(&msgIn);
|
|
mExecuteDoneCondition.wait(mLock);
|
|
mCurrentState = STATE_INITIALIZED;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t StarkModel::setVolume(float leftVolume, float rightVolume)
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
return mCMP->setVolume(leftVolume, rightVolume);
|
|
}
|
|
|
|
status_t StarkModel::setMute(BOOL mute)
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
return mCMP->setMuteMode(mute);
|
|
}
|
|
|
|
status_t StarkModel::StarkModelThread()
|
|
{
|
|
bool bRunningFlag = true;
|
|
EyeseeMessage msg;
|
|
status_t ret;
|
|
while(1)
|
|
{
|
|
PROCESS_MESSAGE:
|
|
ret = mMsgQueue.dequeueMessage(&msg);
|
|
if(ret != NO_ERROR)
|
|
{
|
|
if(NOT_ENOUGH_DATA == ret)
|
|
{
|
|
mMsgQueue.waitMessage();
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
aloge("fatal error! message queue ret[0x%x], quit thread!", ret);
|
|
bRunningFlag = false;
|
|
goto _exit0;
|
|
}
|
|
}
|
|
if(msg.mWhoseMsg != MessageOfStarkModel)
|
|
{
|
|
aloge("fatal error! msg[0x%x] come from [0x%x]!", msg.mMsgType, msg.mWhoseMsg);
|
|
}
|
|
switch(msg.mMsgType)
|
|
{
|
|
case MSGTYPE_PLAY_FILE:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if (access((char*)msg.getData(), F_OK) != 0)
|
|
{
|
|
aloge("fatal error! file[%s] is not exist!", (char*)msg.getData());
|
|
mOnMessageListener->onMessage(MSGTYPE_ERROR_INVALID_FILEPATH, NULL);
|
|
break;
|
|
}
|
|
if(mPlayMode == PlayMode_OneFileLoop)
|
|
{
|
|
mMediaFileList.clear();
|
|
mMediaFileList.push_back(string((char*)msg.getData()));
|
|
mCurMediaFileIndex = 0;
|
|
}
|
|
executePlayFile((char*)msg.getData());
|
|
break;
|
|
}
|
|
case MSGTYPE_PLAY_LIST_LOOP:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
//parse filelist file, get filelist.
|
|
ret = parseFileList((char*)msg.getData(), mMediaFileList);
|
|
if(ret!=NO_ERROR)
|
|
{
|
|
aloge("fatal error! parse file[%s] fail! ret[0x%x]", (char*)msg.getData(), ret);
|
|
mOnMessageListener->onMessage(MSGTYPE_ERROR_PARSE_FILE_LIST_FAIL, NULL);
|
|
break;
|
|
}
|
|
if(0 == mMediaFileList.size())
|
|
{
|
|
alogd("listFile[%s] is empty!", (char*)msg.getData());
|
|
mOnMessageListener->onMessage(MSGTYPE_ERROR_FILELIST_EMPTY, NULL);
|
|
break;
|
|
}
|
|
mCurMediaFileIndex = 0;
|
|
executePlayFile(mMediaFileList[mCurMediaFileIndex++].c_str());
|
|
if(mCurMediaFileIndex >= (int)mMediaFileList.size())
|
|
{
|
|
mCurMediaFileIndex = 0;
|
|
}
|
|
break;
|
|
}
|
|
case MSGTYPE_PAUSE_FILE:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(STATE_PAUSED == mCurrentState)
|
|
{
|
|
alogd("already pause!");
|
|
}
|
|
else if(STATE_STARTED == mCurrentState)
|
|
{
|
|
mCMP->pause();
|
|
}
|
|
else
|
|
{
|
|
aloge("fatal error! wrong state[%d] when process pause!", mCurrentState);
|
|
}
|
|
mExecuteDoneCondition.signal();
|
|
break;
|
|
}
|
|
case MSGTYPE_RESUME_FILE:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(mCurrentState == STATE_PAUSED)
|
|
{
|
|
mCMP->start();
|
|
}
|
|
else
|
|
{
|
|
aloge("fatal error! wrong state[%d] when resume file!", mCurrentState);
|
|
}
|
|
mExecuteDoneCondition.signal();
|
|
break;
|
|
}
|
|
case MSGTYPE_SEEK_FILE:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
alogd("seek [%d]ms!", msg.mPara0);
|
|
mCMP->seekTo(msg.mPara0);
|
|
break;
|
|
}
|
|
case MSGTYPE_STOP_FILE:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(STATE_INITIALIZED== mCurrentState)
|
|
{
|
|
alogd("already stop!");
|
|
}
|
|
else if(STATE_STARTED == mCurrentState || STATE_PAUSED == mCurrentState)
|
|
{
|
|
if(mPrerequisiteFlag)
|
|
{
|
|
mCMP->reset();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aloge("fatal error! wrong state[%d] when process pause!", mCurrentState);
|
|
}
|
|
mExecuteDoneCondition.signal();
|
|
break;
|
|
}
|
|
case MSGTYPE_QUIT_THREAD:
|
|
{
|
|
bRunningFlag = false;
|
|
goto _exit0;
|
|
}
|
|
case MSGTYPE_PLAYBACK_COMPLETED:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
if(STATE_PAUSED == mCurrentState)
|
|
{
|
|
alogw("Be careful! meet pause when play completed");
|
|
}
|
|
if(PlayMode_OneFile == mPlayMode)
|
|
{
|
|
alogd("play one file done!");
|
|
mCMP->reset();
|
|
mOnMessageListener->onMessage(MSGTYPE_PLAYBACK_COMPLETED, NULL);
|
|
}
|
|
else if(PlayMode_OneFileLoop == mPlayMode || PlayMode_ListLoop == mPlayMode)
|
|
{
|
|
alogd("play next file[%s] in mediaList!", mMediaFileList[mCurMediaFileIndex].c_str());
|
|
mCMP->reset();
|
|
executePlayFile(mMediaFileList[mCurMediaFileIndex++].c_str());
|
|
if(mCurMediaFileIndex >= (int)mMediaFileList.size())
|
|
{
|
|
mCurMediaFileIndex = 0;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case MSGTYPE_ERROR_MEDIA_ERROR:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
struct MediaErrorInfo mediaErrorInfo;
|
|
mediaErrorInfo.mMediaErrorType = msg.mPara0;
|
|
mediaErrorInfo.mExtra = msg.mPara1;
|
|
mOnMessageListener->onMessage(MSGTYPE_ERROR_MEDIA_ERROR, &mediaErrorInfo);
|
|
break;
|
|
}
|
|
case MSGTYPE_MEDIA_SET_VIDEO_SIZE:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
alogd("ignore video size changed!");
|
|
break;
|
|
}
|
|
case MSGTYPE_MEDIA_INFO:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
alogd("ignore media info!");
|
|
break;
|
|
}
|
|
case MSGTYPE_MEDIA_SEEK_COMPLETE:
|
|
{
|
|
Mutex::Autolock autoLock(mLock);
|
|
alogd("signal seek complete!");
|
|
mExecuteDoneCondition.signal();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
aloge("unknown msg[0x%x]!", msg.mMsgType);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
_exit0:
|
|
alogd("exit StarkModelThread()");
|
|
return bRunningFlag;
|
|
}
|
|
|
|
status_t StarkModel::executePlayFile(const char *pFilePath)
|
|
{
|
|
if(mCurrentState != STATE_STARTED)
|
|
{
|
|
aloge("fatal error! why state[0x%x] is not started?", mCurrentState);
|
|
}
|
|
if(false == mPrerequisiteFlag)
|
|
{
|
|
mCMP = new EyeseePlayer;
|
|
|
|
alogd("------------hdmi setting------------------");
|
|
VO_PUB_ATTR_S voattr;
|
|
voattr.enIntfType = VO_INTF_LCD;
|
|
voattr.enIntfSync = VO_OUTPUT_1080P60;
|
|
AW_MPI_VO_SetPubAttr(0, &voattr);
|
|
alogd("------------hdmi setting end------------------");
|
|
|
|
alogd("screenInfo[%dx%d]", 800, 600);
|
|
struct view_info sur;
|
|
sur.x = 0;
|
|
sur.y = 0;
|
|
sur.w = 720;
|
|
sur.h = 720;
|
|
//mHLay = hwd_layer_request_v40(&sur, 1);
|
|
mHLay = 0;
|
|
while(mHLay < VO_MAX_LAYER_NUM)
|
|
{
|
|
if(SUCCESS == AW_MPI_VO_EnableVideoLayer(mHLay))
|
|
{
|
|
break;
|
|
}
|
|
mHLay++;
|
|
}
|
|
if(mHLay >= VO_MAX_LAYER_NUM)
|
|
{
|
|
aloge("fatal error! enable video layer fail!");
|
|
}
|
|
VO_VIDEO_LAYER_ATTR_S stLayerAttr;
|
|
AW_MPI_VO_GetVideoLayerAttr(mHLay, &stLayerAttr);
|
|
stLayerAttr.stDispRect.X = sur.x;
|
|
stLayerAttr.stDispRect.Y = sur.y;
|
|
stLayerAttr.stDispRect.Width = sur.w;
|
|
stLayerAttr.stDispRect.Height = sur.h;
|
|
AW_MPI_VO_SetVideoLayerAttr(mHLay, &stLayerAttr);
|
|
alogd("requestSurface hlay=%d", mHLay);
|
|
mPrerequisiteFlag = true;
|
|
}
|
|
mCMP->setOnPreparedListener(&mPlayerListener);
|
|
mCMP->setOnCompletionListener(&mPlayerListener);
|
|
mCMP->setOnErrorListener(&mPlayerListener);
|
|
mCMP->setOnVideoSizeChangedListener(&mPlayerListener);
|
|
mCMP->setOnInfoListener(&mPlayerListener);
|
|
mCMP->setOnSeekCompleteListener(&mPlayerListener);
|
|
mCMP->setDataSource(pFilePath);
|
|
//mCMP->setAudioStreamType(AUDIO_STREAM_MUSIC/*AudioManager.STREAM_MUSIC*/);
|
|
mCMP->setDisplay(mHLay);
|
|
//mCMP->setAOCardType(PCM_CARD_TYPE_SNDHDMI);
|
|
//mCMP->setRotation(ROTATE_90);
|
|
mCMP->setOutputPixelFormat(MM_PIXEL_FORMAT_YVU_SEMIPLANAR_420);
|
|
//mCMP->setLooping(PlayMode_OneFileLoop==mPlayMode?true:false);
|
|
//mCMP->setScreenOnWhilePlaying(true);
|
|
{
|
|
Mutex::Autolock autoLock(mPlayerListenerLock);
|
|
mCMP->prepare();
|
|
// mbPrepareDone = false;
|
|
// while(false == mbPrepareDone)
|
|
// {
|
|
// mOnPrepared.wait(mPlayerListenerLock);
|
|
// }
|
|
}
|
|
mCMP->start();
|
|
return NO_ERROR;
|
|
}
|
|
|
|
};
|