bool HTTPSourceMMIExtensionEventHandler::HTTPMMIEventQManager<T>::Peek
(
T& eventToRead
)
{
bool bOk = false;
//Check if the queue is already empty, if not get the event from
//the queue
if (IsQEmpty())
{
QTV_MSG_PRIO( QTVDIAG_STREAMING, QTVDIAG_PRIO_MEDIUM,
"MMIEventQManager - MMI event queue empty" );
}
else
{
(void)MM_CriticalSection_Enter(m_hEventQLock);
if (m_nEventReadIndex < ARR_SIZE(m_eventQ))
{
bOk = true;
eventToRead = m_eventQ[m_nEventReadIndex];
QTV_MSG_PRIO2( QTVDIAG_STREAMING, QTVDIAG_PRIO_MEDIUM,
"MMIEventQManager - Peeked event from index %u, "
"%u events remain", m_nEventReadIndex, m_nOutstandingEvents );
}
(void)MM_CriticalSection_Leave(m_hEventQLock);
}
return bOk;
}
/*
* This function is called with a presentation (printable or ASCII) format
* address to be converted to its network address (binary) format. The af
* argument can be either AF_INET if the address to be converted is an IPv4
* address or AF_INET6 if the address is an IPv6 address. In case of error
* the error code is returned in the dss_errno argument.
*
* The dst argument should have sufficient memory for the network address
* of the appropriate family. For IPv4 it should be at least
* sizeof(struct in_addr) while for IPv6 it should be at least
* sizeof(struct in6_addr).
*/
int32 inet_pton
(
int32 af, /* Address family of address in src argument */
const char *src, /* String containing presentation form IP address */
void *dst /* Memory for returning address in network format */
)
{
int32 retval = STREAMNET_FAILED;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
if (src == NULL || dst == NULL)
{
QTV_MSG_PRIO2( QTVDIAG_GENERAL, QTVDIAG_PRIO_ERROR,
"inet_pton(): Called with src %p, dst %p", src, dst );
return STREAMNET_FAILED;
}
if(af)
{
int32 retval_tmp = ::inet_pton(af, src, dst);
if(retval_tmp == 1)
{
retval = STREAMNET_SUCCESS;
}
}
return retval;
} /* inet_pton() */
void convertFrameInfoToFrameDetails(struct Vdec_FrameDetailsType *Frame_details,
struct vdec_frame_info *pFrame)
{
int i;
if (NULL == Frame_details || NULL == pFrame) {
QTV_MSG_PRIO2(QTVDIAG_GENERAL, QTVDIAG_PRIO_LOW,
"convertFrameInfoToFrameDetails() Frame Details or vdec-frame NULL "
"Frame Details: 0x%x, pFrame: 0x%x\n",
Frame_details, pFrame);
}
Frame_details->status = (Vdec_StatusType) pFrame->status; //TBD
Frame_details->userData1 = pFrame->data1;
Frame_details->userData2 = pFrame->data2;
Frame_details->timestamp =
(unsigned long long)((unsigned long long)pFrame->
timestamp_hi << 32 | (unsigned long long)
pFrame->timestamp_lo & 0x0FFFFFFFFLL);
Frame_details->calculatedTimeStamp =
(unsigned long long)((unsigned long long)pFrame->
cal_timestamp_hi << 32 | (unsigned long long)
pFrame->cal_timestamp_lo & 0x0FFFFFFFFLL);
Frame_details->nDecPicWidth = pFrame->dec_width;
Frame_details->nDecPicHeight = pFrame->dec_height;
Frame_details->cwin.x1 = pFrame->cwin.x1;
Frame_details->cwin.y1 = pFrame->cwin.y1;
Frame_details->cwin.x2 = pFrame->cwin.x2;
Frame_details->cwin.y2 = pFrame->cwin.y2;
for (i = 0; i < MAX_FIELDS; i++) {
Frame_details->ePicType[i] =
(Vdec_PictureType) pFrame->picture_type[i];
}
Frame_details->ePicFormat = (Vdec_PictureFormat) pFrame->picture_format;
Frame_details->nVC1RangeY = pFrame->vc1_rangeY;
Frame_details->nVC1RangeUV = pFrame->vc1_rangeUV;
Frame_details->ePicResolution =
(Vdec_PictureRes) pFrame->picture_resolution;
Frame_details->nRepeatProgFrames = pFrame->frame_disp_repeat;
Frame_details->bRepeatFirstField = pFrame->repeat_first_field;
Frame_details->bTopFieldFirst = pFrame->top_field_first;
Frame_details->bFrameInterpFlag = pFrame->interframe_interp;
Frame_details->panScan.numWindows = pFrame->panscan.num;
for (i = 0; i < MAX_VC1_PAN_SCAN_WINDOWS; i++) {
Frame_details->panScan.winHeight[i] = pFrame->panscan.width[i];
Frame_details->panScan.winHeight[i] = pFrame->panscan.height[i];
Frame_details->panScan.winHorOffset[i] =
pFrame->panscan.xoffset[i];
Frame_details->panScan.winVerOffset[i] =
pFrame->panscan.yoffset[i];
}
Frame_details->nPercentConcealedMacroblocks =
pFrame->concealed_macblk_num;
Frame_details->flags = pFrame->flags;
Frame_details->performanceStats = pFrame->performance_stats;
}
/** @brief PLAYLIST_READY state handler.
*
* @param[in] pDownloadHelper - Reference to
* PlaylistDownloadHelper
* @return
* HTTPDL_WAITING - Data successfully written or no data available to write
* and download incomplete
* HTTPDL_SUCCESS - Download complete
* HTTPDL_ERROR_ABORT - Otherwise
*/
HTTPDownloadStatus PlaylistDownloadHelper::PlaylistReadyStateHandler::Execute
(
PlaylistDownloadHelper* pDownloadHelper
)
{
QTV_MSG_PRIO( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_LOW,
"PlaylistDownloadHelper::PlaylistReadyStateHandler::Execute()" );
HTTPDownloadStatus status = HTTPCommon::HTTPDL_ERROR_ABORT;
PlaylistDownloadHelper* pSelf = pDownloadHelper;
//Validity check
if (pSelf)
{
char* pRepresentationBuf = pSelf->m_RepresentationBuffer;
int numBytesToRead = STD_MAX(0, pSelf->m_nRepresentationLen - pSelf->m_nRepresentationBytesRead);
HTTPStackInterface& HTTPStack = *(pSelf->m_pHTTPStack);
QTV_MSG_PRIO2( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_MEDIUM,
"numBytesToRead %d, (numBytesReceived %d)",
numBytesToRead, pSelf->m_nRepresentationBytesRead );
if (pSelf->m_RepresentationBuffer && numBytesToRead > 0)
{
status = HTTPCommon::HTTPDL_ERROR_ABORT;
//Get a data chunk from HTTP stack
size_t numBytesRead = 0;
HTTPReturnCode result =
HTTPStack.GetData(pSelf->m_nRequestID,
pRepresentationBuf+pSelf->m_nRepresentationBytesRead,
numBytesToRead,
&numBytesRead);
if (result != HTTP_FAILURE && result != HTTP_BADPARAM)
{
//Update total number of bytes dowloaded/written so far
pSelf->m_nRepresentationBytesRead += (int)numBytesRead;
status = HTTPCommon::HTTPDL_WAITING;
if(result == HTTP_NOMOREDATA ||
pSelf->m_nRepresentationBytesRead >= (pSelf->m_nRepresentationLen -1))
{
pSelf->m_nRepresentationLen = pSelf->m_nRepresentationBytesRead;
status = HTTPCommon::HTTPDL_SUCCESS;
}
QTV_MSG_PRIO1( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_HIGH,
"Total numBytesReceived %d", pSelf->m_nRepresentationBytesRead );
}// result check
else
{
//Data read failure
QTV_MSG_PRIO1( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR,
"Error: Data read failure %d from HTTP stack", result );
}
}// if (HTTPSUCCEEDED(status))
}// if (pSelf && pSelf->GetState() == DATA_READY)
return status;
}
Vdec_ReturnType vdec_release_frame(struct VDecoder *dec, struct vdec_frame *frame)
{
VDEC_FRAME vdecFrame;
VideoDecoder *pDec = (VideoDecoder*)(dec->core);
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: release_frame %p\n", frame);
if (NULL == dec || NULL == frame)
{
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: error: encountered NULL parameter vdec: 0x%x frame: 0x%x", (unsigned int)dec, (unsigned int)frame);
return VDEC_EFAILED;
}
//vdecFrame.pBuf = (VDEC_BYTE*)frame->phys;
vdecFrame.pBuf = (VDEC_BYTE*)frame->base;
vdecFrame.timestamp = (unsigned long long)frame->timestamp;
pDec->ReuseFrameBuffer(&vdecFrame);
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: released_frame with ptr: 0x%x", (unsigned int)vdecFrame.pBuf);
return VDEC_SUCCESS;
}
/** @brief Invoke the registered generic callback for the MMI base interface.
*
* @param[in] eventID - The async event to be reported in the callback
*/
void HTTPSourceMMIHelper::NotifyMmi
(
OMX_U32 nEvtCode,
OMX_U32 nEvtStatus,
size_t nPayloadLen,
void *pEvtData,
void * /*pClientData*/
)
{
if (m_pHTTPSourceMMI && m_pHTTPSourceMMI->m_HTTPSourceMMIAsync_CB)
{
OMX_U32 eventID = 0;
if(pEvtData)
{
MMI_ExtSpecificMsgType* mmiExtMsg;
mmiExtMsg = (MMI_ExtSpecificMsgType *)pEvtData;
eventID = mmiExtMsg->nData2;
}
if (m_pHTTPSourceMMI->IsShutDownInProgress() && !(eventID == QOMX_HTTP_IndexParamQOEStop))
{
QTV_MSG_PRIO(QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_HIGH,
"HTTPSourceMMIHelper::NotifyMmi - Shutdown in progress,"
" not sending any notifications to MMI");
}
else
{
QTV_MSG_PRIO2( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_HIGH,
"HTTPSourceMMIHelper::NotifyMmi - "
"Async notification [event code - %d :Event Status - %d] "
"sent to MMI source filter",
(uint32)(nEvtCode-MMI_MSG_BASE), (uint32)(nEvtStatus-MMI_S_BASE));
m_pHTTPSourceMMI->m_HTTPSourceMMIAsync_CB(nEvtCode, nEvtStatus,
(OMX_U32)nPayloadLen, pEvtData,
m_pHTTPSourceMMI->m_pClientData);
}
}
else
{
QTV_MSG_PRIO( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR,
"Error: MMI async event suppressed - either "
"m_pHTTPSourceMMI is NULL or CB not registered" );
}
}
bool HTTPSourceMMIExtensionEventHandler::HTTPMMIEventQManager<T>::Enqueue
(
const T& eventToWrite
)
{
bool bOk = false;
//Check if the queue is already full, if not push the new event
//into the queue
if (IsQFull())
{
QTV_MSG_PRIO( QTVDIAG_STREAMING, QTVDIAG_PRIO_MEDIUM,
"MMIEventQManager - MMI event queue full" );
}
else
{
(void)MM_CriticalSection_Enter(m_hEventQLock);
if (m_nEventWriteIndex < ARR_SIZE(m_eventQ))
{
//Update the write index and number of queued events
bOk = true;
m_eventQ[m_nEventWriteIndex] = eventToWrite;
m_nOutstandingEvents++;
QTV_MSG_PRIO2( QTVDIAG_STREAMING, QTVDIAG_PRIO_MEDIUM,
"MMIEventQManager - Queued event to index %u, "
"%u events remain", m_nEventReadIndex, m_nOutstandingEvents );
m_nEventWriteIndex = (m_nEventWriteIndex + 1) % (uint32)ARR_SIZE(m_eventQ);
}
else
{
QTV_MSG_PRIO1( QTVDIAG_STREAMING, QTVDIAG_PRIO_ERROR,
"MMIEventQManager - Invalid MMI event queue write index %u",
m_nEventWriteIndex );
}
(void)MM_CriticalSection_Leave(m_hEventQLock);
}
return bOk;
}
bool HTTPSourceMMIExtensionEventHandler::HTTPMMIEventQManager<T>::Dequeue
(
T& eventToRead
)
{
bool bOk = false;
//Check if the queue is already empty, if not get the event from
//the queue
if (IsQEmpty())
{
QTV_MSG_PRIO( QTVDIAG_STREAMING, QTVDIAG_PRIO_MEDIUM,
"MMIEventQManager - MMI event queue empty" );
}
else
{
(void)MM_CriticalSection_Enter(m_hEventQLock);
if (m_nEventReadIndex < ARR_SIZE(m_eventQ))
{
//Dequeue the event and update the read index and number of queued events
bOk = true;
eventToRead = m_eventQ[m_nEventReadIndex];
m_nOutstandingEvents--;
QTV_MSG_PRIO2( QTVDIAG_STREAMING, QTVDIAG_PRIO_MEDIUM,
"MMIEventQManager - Dequeued event from index %u, "
"%u events remain", m_nEventReadIndex, m_nOutstandingEvents );
m_nEventReadIndex = (m_nEventReadIndex + 1) % (uint32)ARR_SIZE(m_eventQ);
}
else
{
QTV_MSG_PRIO1( QTVDIAG_STREAMING, QTVDIAG_PRIO_ERROR,
"MMIEventQManager - Invalid MMI event queue read index %u",
m_nEventReadIndex );
}
(void)MM_CriticalSection_Leave(m_hEventQLock);
}
return bOk;
}
/**
* @brief Process the Buffering Status and enqueu the status
* and Notify clinet if required
*
* @param pHTTPSourceMMIHelper
* @param portID
* @param bDataAvailable
* @param pClientData
*
* @return bool
*/
bool HTTPSourceMMIExtensionEventHandler::HTTPBufferingEventManager::ProcessBufferingStatus
(
HTTPSourceMMIHelper *pHTTPSourceMMIHelper,
const uint32 portID,
bool bDataAvailable,
void *pClientData
)
{
bool bOk = false;
QOMX_WATERMARKTYPE eCurrentBufferingEventType =
(bDataAvailable == true)? QOMX_WATERMARK_NORMAL: QOMX_WATERMARK_UNDERRUN;
if(eCurrentBufferingEventType != GetCurrentWatermarkType())
{
SetCurrentWatermarkType(eCurrentBufferingEventType);
bool bNotify = m_HTTPBufferingEventMgr[eCurrentBufferingEventType].GetNotify();
if(bNotify)
{
if(pHTTPSourceMMIHelper)
{
bOk = NotifyBufferingEvent(pHTTPSourceMMIHelper,portID,pClientData);
if(eCurrentBufferingEventType == QOMX_WATERMARK_UNDERRUN)
{
pHTTPSourceMMIHelper->UpdateRebufCount(1);
}
QTV_MSG_PRIO2(QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_MEDIUM,
"ProcessBufferingStatus: Notify watermark event on port %u as reached watermark type %d",
portID, (int)eCurrentBufferingEventType);
}
}
}
return bOk;
}
void
HTTPStackHelper::SetState(HTTPStateBase *state)
{
QTV_MSG_PRIO2(QTVDIAG_HTTP_STACK, QTVDIAG_PRIO_HIGH,
"HTTPStackHelper::SetState. Transition from '%s' to '%s'",
m_HTTPState->GetStateName(),
state->GetStateName());
m_HTTPState = state;
// Update state information
if (&(HTTPStackStateObjects::HTTPStateIdleObj) == state)
{
m_HTTPStateInfo.ResetPersistentConnection();
StartNewRequest();
ResetOptions();
}
else
if (&(HTTPStackStateObjects::HTTPStateClosedObj) == state)
{
m_HTTPStateInfo.ResetPersistentConnection();
}
}
Vdec_ReturnType vdec_post_input_buffer(struct VDecoder *dec, video_input_frame_info *frame, void *cookie)
{
QTV_MSG_PRIO3(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: post_input data=%p len=%d cookie=%p\n", frame->data, frame->len, cookie);
#ifdef LOG_INPUT_BUFFERS
static int take_input = 1;
#endif
int fatal_err = 0;
/*checkBufAvail flag is needed since we do not need to checkout
* YUV/Slice buffer incase the NAL corresponds to same frame.
* This is required for multiple NALs in one input buffer
*/
bool checkBufAvail = true;
VDEC_INPUT_BUFFER input;
VideoDecoder *pDec = (VideoDecoder*)(dec->core);
VDEC_ERROR err = VDEC_ERR_EVERYTHING_FINE;
if (NULL == dec || NULL == frame || NULL == frame->data )
{
QTV_MSG_PRIO3(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: error: encountered NULL parameter dec: 0x%x frame: 0x%x data: 0x%x\n",
(unsigned int)dec,
(unsigned int)frame,
(unsigned int)frame->data);
return VDEC_EFAILED;
}
input.buffer[0] = (unsigned char*)frame->data;
input.timestamp[0] = (long long)frame->timestamp;
input.buffer_size[0] = (unsigned long int)frame->len;
input.buffer_pos[0] = 0;
input.layers = 1;
input.eOSIndicator[0]= false;
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: received ts: %lld", frame->timestamp);
if (frame->timestamp < timestamp )
{
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: error: out of order stamp! %d < %d\n",
(int)(frame->timestamp&0xFFFFFFFF), timestamp);
}
timestamp = (int)frame->timestamp;
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: vdec_core_post_input. buffer_size[0]: %ld frame->flags: 0x%x\n",
input.buffer_size[0], frame->flags);
if (input.buffer_size[0] == 0 && frame->flags & FRAME_FLAG_EOS)
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: Zero-length buffer with EOS bit set\n");
input.eOSIndicator[0] = true;
if(pDec)
err = pDec->EOS( );
else
err = VDEC_ERR_NULL_STREAM_ID;
if(VDEC_ERR_OUT_OF_BUFFERS == err) return VDEC_EOUTOFBUFFERS;
vdec_decoder_info->ctxt->buffer_done(vdec_decoder_info->ctxt, cookie);
if (VDEC_ERR_EVERYTHING_FINE == err) return VDEC_SUCCESS;
return VDEC_EFAILED;
}
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: vdec_core_post_input\n");
#ifdef LOG_INPUT_BUFFERS
if (take_input)
{
fwritex((unsigned char*)frame->data, frame->len, pInputFile);
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: frame %d frame->len %d\n", counter++, frame->len);
}
#endif
do {
QPERF_TIME(arm_decode, err = pDec->Decode( &input, checkBufAvail ));
if (VDEC_ERR_EVERYTHING_FINE != err)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: vdec_decoder error: %d\n", (int)err);
if(VDEC_ERR_UNSUPPORTED_DIMENSIONS == err) {
fatal_err = 1;
break;
}
}
checkBufAvail = false;
} while( ( VDEC_ERR_EVERYTHING_FINE == err ) && ( 0 != input.buffer_size[0] ) );
#ifdef LOG_INPUT_BUFFERS
take_input = (err==14?0:1);
#endif
if(VDEC_ERR_OUT_OF_BUFFERS == err) return VDEC_EOUTOFBUFFERS;
vdec_input_buffer_release_cb_handler(pDec,&input,cookie);
if(VDEC_ERR_EVERYTHING_FINE == err) return VDEC_SUCCESS;
if(fatal_err) {
static struct vdec_frame frame;
memset(&frame, 0, sizeof(frame));
frame.flags |= FRAME_FLAG_FATAL_ERROR;
QPERF_END(frame_data);
vdec_decoder_info->ctxt->frame_done(vdec_decoder_info->ctxt, &frame);
}
return VDEC_EFAILED;
}
struct VDecoder *vdec_open(struct vdec_context *ctxt)
{
struct VDecoder *dec = NULL;
VDEC_ERROR err = 0;
const VDEC_CONCURRENCY_CONFIG concurrencyConfig = VDEC_CONCURRENT_NONE;
VideoDecoder* pDec = NULL;
dec = (VDecoder*)calloc(1, sizeof(struct VDecoder));
if (!dec) {
return 0;
}
dec->ctxt = ctxt;
dec->width = ctxt->width;
dec->height = ctxt->height;
dec->ctxt->outputBuffer.numBuffers = ctxt->outputBuffer.numBuffers;
if(VDEC_SUCCESS != vdec_commit_memory(dec)) {
return 0;
}
QPERF_RESET(arm_decode);
QPERF_RESET(frame_data);
nFrameDoneCnt = 0;
nGoodFrameCnt = 0;
#ifdef PROFILE_DECODER
qperf_total_frame_cnt = 0;
#endif
vdec_output_frame_index = 0;
timestamp = 0;
int i;
VDEC_PARAMETER_DATA codeDetectionEnable;
codeDetectionEnable.startCodeDetection.bStartCodeDetectionEnable = false; // by default set to false; MPEG4 doesnt require it
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: vdec_open(). width: %d, height: %d\n", dec->width, dec->height);
vdec_decoder_info = dec;
QTV_MSG_PRIO3(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: vdec_open(). width: %d, height: %d kind[%s]\n",
vdec_decoder_info->ctxt->width, vdec_decoder_info->ctxt->height,
vdec_decoder_info->ctxt->kind);
if(!strcmp(vdec_decoder_info->ctxt->kind,"OMX.qcom.video.decoder.avc"))
{
dec->core = reinterpret_cast<VDEC_STREAM_ID>(pCreateFnH264(&err));
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: Creating H264 Decoder [%p]\n",dec->core);
VDEC_PARAMETER_DATA sizeOfNalLengthField;
sizeOfNalLengthField.sizeOfNalLengthField.sizeOfNalLengthField = dec->ctxt->size_of_nal_length_field;
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: NAL lenght [%d]\n",dec->ctxt->size_of_nal_length_field);
pDec = (VideoDecoder*)(dec->core);
if (0 == dec->ctxt->size_of_nal_length_field)
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: START CODE....\n");
codeDetectionEnable.startCodeDetection.bStartCodeDetectionEnable = true;
if(!pDec)
err = VDEC_ERR_NULL_STREAM_ID;
else
err = pDec->SetParameter(VDEC_PARM_START_CODE_DETECTION,&codeDetectionEnable);
if (VDEC_ERR_EVERYTHING_FINE != err)
{
// TBD- printx("[vdec_core] set start code detection parameter failed: %d", (int)err);
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"[vdec_core] set start code detection parameter failed: %d", (int)err);
goto fail_initialize;
}
}
else if(dec->ctxt->size_of_nal_length_field > 0 && dec->ctxt->size_of_nal_length_field <= 4)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: NALU LENGTH[%d]\n",dec->ctxt->size_of_nal_length_field);
// test size of NAL length field decoder support
if(!pDec)
err = VDEC_ERR_NULL_STREAM_ID;
else
err = pDec->SetParameter( VDEC_PARM_SIZE_OF_NAL_LENGTH_FIELD, &sizeOfNalLengthField );
if (VDEC_ERR_EVERYTHING_FINE != err)
{
// TBD- printx("[vdec_core] set start code detection parameter failed: %d", (int)err);
goto fail_initialize;
}
}
else
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: Invalid size of nal length field: %d\n", dec->ctxt->size_of_nal_length_field);
goto fail_core;
}
}
else if ((!strcmp(vdec_decoder_info->ctxt->kind,"OMX.qcom.video.decoder.mpeg4"))
|| (!strcmp(vdec_decoder_info->ctxt->kind,"OMX.qcom.video.decoder.h263")))
{
dec->core = reinterpret_cast<VDEC_STREAM_ID>(pCreateFnMpeg4(&err));
pDec = (VideoDecoder*)(dec->core);
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: Creating MP4 Decoder [%p]\n",dec->core);
}
else if (!strcmp(vdec_decoder_info->ctxt->kind,"OMX.qcom.video.decoder.vc1"))
{
dec->core = reinterpret_cast<VDEC_STREAM_ID>(pCreateFnWmv(&err));
pDec = (VideoDecoder*)(dec->core);
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: Creating WMV Decoder [%p]\n",dec->core);
}
else
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"Incorrect codec kind\n");
goto fail_core;
}
if (VDEC_ERR_EVERYTHING_FINE != err || NULL == dec->core)
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: create failed\n");
goto fail_core;
}
for(i=0; i<VDEC_NFRAMES; i++)
{
slice_buffer_info[i].base = (char*)dec->input[i].base;
//slice_buffer_info[i].phys = dec->input[i].phys;
slice_buffer_info[i].fd = dec->input[i].pmem_id;
}
VDEC_DIMENSIONS frameSize;
frameSize.height = dec->height;
frameSize.width = dec->width;
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: Init width: %d height %d\n", frameSize.width, frameSize.height);
/*
VDEC_PARAMETER_DATA deblockerInfo;
deblockerInfo.deblockerEnable.bDeblockerEnable = true;
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"[vdec_core] SetParameter\n");
err = vdec_set_parameter(dec->core, VDEC_PARM_DEBLOCKER_ENABLE, &deblockerInfo);
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"[vdec_core] after SetParameter\n",err);
if (VDEC_ERR_EVERYTHING_FINE != err)
{
//TBD - printx("[vdec_core] set deblocker enable parameter failed: %d", (int)err);
goto fail_initialize;
}
*/
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: vdec_initialize\n");
if(!pDec)
err = VDEC_ERR_NULL_STREAM_ID;
else
{
err = pDec->Initialize(1,
vdec_frame_buffer_malloc_cb_handler,
vdec_frame_buffer_free_cb_handler,
vdec_frame_cb_handler,
NULL,
frameSize,
VDEC_CONCURRENT_NONE,
slice_buffer_info,
dec->ctxt->outputBuffer.numBuffers,
ctxt->adsp_fd);
}
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: vdec_initialize\n",err);
if (err != VDEC_ERR_EVERYTHING_FINE)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: initialization failed: %d\n", (int)err);
goto fail_initialize;
}
#if NEED_VDEC_LP
#ifdef _ANDROID_
dec->fake = adsp_open("/dev/adsp/VDEC_LP_MODE", dec->core, core_msg_func);
#else
dec->fake = adsp_open("/dev/VDEC_LP_MODE", dec->core, core_msg_func);
#endif //_ANDROID_
if (!dec->fake)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: adsp_open() failed error: %s\n", strerror(errno));
goto fail_initialize;
}
if (adsp_enable((adsp_module*)dec->fake)) goto fail_enable;
#endif
#ifdef LOG_YUV_FRAMES
#ifdef T_WINNT
pYUVFile = fopen ( "../debug/yuvframes.yuv" , "wb" );
#elif _ANDROID_
pYUVFile = fopen ( "/data/yuvframes.yuv" , "wb" );
#else
pYUVFile = fopen ( "yuvframes.yuv" , "wb" );
#endif
#endif
#ifdef LOG_INPUT_BUFFERS
#ifdef T_WINNT
pInputFile = fopen ( "../debug/inputbuffers.bin" , "wb" );
#elif _ANDROID_
pInputFile = fopen ( "/data/inputbuffers.bin" , "wb" );
#else
pInputFile = fopen ( "inputbuffers.bin" , "wb" );
#endif
#endif
return dec;
fail_enable:
#if NEED_VDEC_LP
adsp_close((adsp_module*)dec->fake);
#endif
fail_initialize:
if(pDec) {
pDec->Suspend( );
QTV_Delete( pDec );
}
fail_core:
if (dec) {
dec->dead = 1;
free(dec);
}
return NULL;
}
void adsp_close(struct adsp_module *mod)
{
#if PROFILE_DECODER
QPERF_TERMINATE(dsp_decode);
QPERF_RESET(dsp_decode);
#endif
#ifndef T_WINNT
int ret;
int thread_ret = 0;
if (NULL == mod) {
QTV_MSG_PRIO1(QTVDIAG_GENERAL, QTVDIAG_PRIO_ERROR,
"adsp_close() mod NULL: 0x%x\n", mod);
return ;
}
mod->dead = 1;
if (ioctl(mod->fd, VDEC_IOCTL_CLOSE, NULL) < 0) {
QTV_MSG_PRIO(QTVDIAG_GENERAL, QTVDIAG_PRIO_ERROR,
"VDEC_IOCTL_CLOSE failed\n");
return;
}
QTV_MSG_PRIO1(QTVDIAG_GENERAL, QTVDIAG_PRIO_LOW, "adsp_close: 0x%x",
(unsigned)mod);
/*Wait on the adsp event thread completion */
ret = pthread_join(mod->thr, (void **)&thread_ret);
if (ret != 0) {
QTV_MSG_PRIO1(QTVDIAG_GENERAL, QTVDIAG_PRIO_ERROR,
"*************adsp_close: Could not join on the adsp event thread err=%d!!\n",
ret);
}
/*Wait on the adsp event thread completion */
ret = close(mod->fd);
if (ret < 0) {
QTV_MSG_PRIO(QTVDIAG_GENERAL, QTVDIAG_PRIO_ERROR,
"*************adsp_close ERROR!");
}
QTV_MSG_PRIO2(QTVDIAG_GENERAL, QTVDIAG_PRIO_LOW,
"adsp_close returned %d, fd: %d", ret, mod->fd);
#if DEBUG
if (logFD) {
pthread_mutex_lock(&logMTX);
fclose(logFD);
logFD = NULL;
pthread_mutex_destroy(&logMTX);
}
#endif
//sleep(1); /* XXX need better way to stop thread XXX */
free(mod);
mod = NULL;
#endif //T_WINNT
}
