OMX_ERRORTYPE volumeEmptyBufferDone(
OMX_OUT OMX_HANDLETYPE hComponent,
OMX_OUT OMX_PTR pAppData,
OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer) {
OMX_ERRORTYPE err;
static int iBufferDropped = 0;
if(pBuffer != NULL) {
if(!bEOS) {
if(pOutBuffer[0]->pBuffer == pBuffer->pBuffer) {
pOutBuffer[0]->nFilledLen = pBuffer->nFilledLen;
err = OMX_FillThisBuffer(appPriv->audiosrchandle, pOutBuffer[0]);
} else {
pOutBuffer[1]->nFilledLen = pBuffer->nFilledLen;
err = OMX_FillThisBuffer(appPriv->audiosrchandle, pOutBuffer[1]);
}
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
}
} else {
DEBUG(DEB_LEV_ERR, "In %s: eos=%x Dropping Fill This Buffer\n", __func__,(int)pBuffer->nFlags);
iBufferDropped++;
if(iBufferDropped == 2) {
tsem_up(appPriv->eofSem);
}
}
} else {
if(!bEOS) {
tsem_up(appPriv->eofSem);
}
DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE start_data_process(HTEST *hTest)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_U32 i, wait_cnt = 0;
hTest->bHoldBuffers = OMX_FALSE;
OMX_CONFIG_BOOLEANTYPE sCapturing;
OMX_INIT_STRUCT(&sCapturing, OMX_CONFIG_BOOLEANTYPE);
sCapturing.bEnabled = OMX_TRUE;
ret = OMX_SetConfig(hTest->hComponent,OMX_IndexConfigCapturing, &sCapturing);
if (ret != OMX_ErrorNone)
return ret;
/* Send output buffers */
for(i=0; i<hTest->nBufferHdr[0]; i++) {
hTest->pBufferHdr[0][i]->nFilledLen = 0;
hTest->pBufferHdr[0][i]->nOffset = 0;
OMX_FillThisBuffer(hTest->hComponent, hTest->pBufferHdr[0][i]);
}
for(i=0; i<hTest->nBufferHdr[1]; i++) {
hTest->pBufferHdr[1][i]->nFilledLen = 0;
hTest->pBufferHdr[1][i]->nOffset = 0;
OMX_FillThisBuffer(hTest->hComponent, hTest->pBufferHdr[1][i]);
}
return ret;
}
static OMX_ERRORTYPE camera_sourceFillBufferDone(
OMX_OUT OMX_HANDLETYPE hComponent,
OMX_OUT OMX_PTR pAppData,
OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
{
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s for camera component\n",__func__);
DEBUG(DEB_LEV_FULL_SEQ, "%s: Get returned buffer (0x%lX) from port[%ld], nFilledLen=%ld\n", __func__, (OMX_U32)pBuffer, pBuffer->nOutputPortIndex, pBuffer->nFilledLen);
if (pBuffer->nOutputPortIndex == OMX_CAMPORT_INDEX_CP)
{
DEBUG(DEB_LEV_FULL_SEQ, "%s: writing to file",__func__);
//fwrite(pBuffer->pBuffer + pBuffer->nOffset, 1, pBuffer->nFilledLen, fCapture);
pBuffer->nFilledLen = 0;
pBuffer->nOffset = 0;
OMX_FillThisBuffer(appPriv->camerahandle, pBuffer);
fprintf(stdout, "capture buffer done!!!\n");
}
else if(pBuffer->nOutputPortIndex == OMX_CAMPORT_INDEX_VF)
{
if(pBuffer->nFilledLen >0)
{
unsigned char *vaddr = NULL;
vaddr = bufferHandleLock((buffer_handle_t)pBuffer->pBuffer,0,0);
if(vaddr){
surface_display_main_show(vaddr+pBuffer->nOffset, DEFAULT_FRAME_WIDTH, DEFAULT_FRAME_HEIGHT,DEFAULT_CAMERA_COLOR_FORMAT);
}
bufferHandleUnlock((buffer_handle_t)pBuffer->pBuffer);
}
if ((pBuffer->nFlags & OMX_BUFFERFLAG_STARTTIME) != 0)
{
DEBUG(DEB_LEV_ERR, "%s: Get buffer flag OMX_BUFFERFLAG_STARTTIME!\n", __func__);
}
/*
#ifndef OMX_SKIP64BIT
DEBUG(DEB_LEV_ERR, "%s: buffer[0x%lX] time stamp: 0x%016llX\n", __func__, (OMX_U32)pBuffer, pBuffer->nTimeStamp);
#else
DEBUG(DEB_LEV_ERR, "%s: buffer[0x%lX] time stamp: 0x%08lX%08lX\n", __func__, (OMX_U32)pBuffer, pBuffer->nTimeStamp.nHighPart, pBuffer->nTimeStamp.nLowPart);
#endif
*/
pBuffer->nFilledLen = 0;
pBuffer->nOffset = 0;
OMX_FillThisBuffer(appPriv->camerahandle, pBuffer);
}
DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s for camera component, return code: 0x%X\n",__func__, OMX_ErrorNone);
return OMX_ErrorNone;
}
OMX_ERRORTYPE start_data_process(HTEST *hTest)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_U32 i, wait_cnt = 0;
hTest->bHoldBuffers = OMX_FALSE;
while (fsl_osal_sem_trywait(hTest->sParserFormatSem) !=E_FSL_OSAL_SUCCESS)
{
usleep(10*1000);
if(hTest->bError)
return OMX_ErrorUndefined;
if((wait_cnt++) > 60*100)
{
//if load time is larger than 1 minutes, then timeout
printf("timeout when wait output\n");
return OMX_ErrorUndefined;
}
}
ret = parser_process_port_setting_changed(hTest,hTest->nAudioTrackNum);
if (ret != OMX_ErrorNone)
return ret;
ret = parser_process_port_setting_changed(hTest,hTest->nVideoTrackNum);
if (ret != OMX_ErrorNone)
return ret;
OMX_CONFIG_SENDAUDIOFIRST sSendAudioFirst;
OMX_INIT_STRUCT(&sSendAudioFirst, OMX_CONFIG_SENDAUDIOFIRST);
sSendAudioFirst.bSendAudioFrameFirst = OMX_FALSE;
ret = OMX_SetConfig(hTest->hComponent,(OMX_INDEXTYPE)OMX_IndexConfigParserSendAudioFirst, &sSendAudioFirst);
if (ret != OMX_ErrorNone)
return ret;
// do_seek(hTest, 30, OMX_TIME_SeekModeFast);
/* Send output buffers */
for(i=0; i<hTest->nBufferHdr[0]; i++)
{
hTest->pBufferHdr[0][i]->nFilledLen = 0;
hTest->pBufferHdr[0][i]->nOffset = 0;
OMX_FillThisBuffer(hTest->hComponent, hTest->pBufferHdr[0][i]);
}
for(i=0; i<hTest->nBufferHdr[1]; i++)
{
hTest->pBufferHdr[1][i]->nFilledLen = 0;
hTest->pBufferHdr[1][i]->nOffset = 0;
OMX_FillThisBuffer(hTest->hComponent, hTest->pBufferHdr[1][i]);
}
return ret;
}
OMX_ERRORTYPE audiosrcFillBufferDone(
OMX_OUT OMX_HANDLETYPE hComponent,
OMX_OUT OMX_PTR pAppData,
OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer) {
OMX_ERRORTYPE err;
OMX_STATETYPE eState;
if(pBuffer != NULL) {
if(!bEOS) {
/** if there is volume component component in processing state then send this buffer, in non tunneled case
* else in non tunneled case, write the output buffer contents in the specified output file
*/
if(flagIsVolCompRequested && (!flagSetupTunnel)) {
OMX_GetState(appPriv->volume_handle,&eState);
if(eState == OMX_StateExecuting || eState == OMX_StatePause) {
if(pInBufferVolc[0]->pBuffer == pBuffer->pBuffer) {
pInBufferVolc[0]->nFilledLen = pBuffer->nFilledLen;
err = OMX_EmptyThisBuffer(appPriv->volume_handle, pInBufferVolc[0]);
} else {
pInBufferVolc[1]->nFilledLen = pBuffer->nFilledLen;
err = OMX_EmptyThisBuffer(appPriv->volume_handle, pInBufferVolc[1]);
}
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
}
} else {
err = OMX_FillThisBuffer(hComponent, pBuffer);
}
} else if((pBuffer->nFilledLen > 0) && (!flagSetupTunnel)) {
fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, outfile);
pBuffer->nFilledLen = 0;
}
if(pBuffer->nFlags == OMX_BUFFERFLAG_EOS) {
DEBUG(DEB_LEV_ERR, "In %s: eos=%x Calling Empty This Buffer\n", __func__, (int)pBuffer->nFlags);
bEOS = OMX_TRUE;
}
if(!bEOS && !flagIsVolCompRequested && (!flagSetupTunnel)) {
err = OMX_FillThisBuffer(hComponent, pBuffer);
}
} else {
DEBUG(DEB_LEV_ERR, "In %s: eos=%x Dropping Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
}
} else {
DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE SampleTest_ReadOutBuffers(SampleCompTestCtxt * pContext)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
BufferList *pList;
OMX_BUFFERHEADERTYPE *pBufHeader;
pList = pContext->pOutBufferList;
while (pList && pList->pBufHdr)
{
printf("\nAbout to do FTB\n");
BUFFERLIST_CLEAR_ENTRY(pList, pBufHeader);
eError = OMX_FillThisBuffer(pContext->hComp, pBufHeader);
OMX_TEST_BAIL_IF_ERROR(eError);
if (pBufHeader->nFlags == OMX_BUFFERFLAG_EOS)
{
pContext->nBufDoneCalls = OMX_TEST_BUFFERS_OF_TRAFFIC;
}
}
OMX_TEST_BAIL:
return eError;
}
OMX_ERRORTYPE videosrcFillBufferDone(
OMX_OUT OMX_HANDLETYPE hComponent,
OMX_OUT OMX_PTR pAppData,
OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer) {
OMX_ERRORTYPE err;
if(pBuffer != NULL){
if(!bEOS) {
/** if there is color conv component in processing state then send this buffer, in non tunneled case
* else in non tunneled case, write the output buffer contents in the specified output file
*/
if(pBuffer->nFilledLen > 0) {
fwrite(pBuffer->pBuffer, sizeof(char), pBuffer->nFilledLen, outfile);
pBuffer->nFilledLen = 0;
}
if(pBuffer->nFlags == OMX_BUFFERFLAG_EOS) {
DEBUG(DEB_LEV_ERR, "In %s: eos=%x Calling Empty This Buffer\n", __func__, (int)pBuffer->nFlags);
bEOS = OMX_TRUE;
}
if(!bEOS ) {
err = OMX_FillThisBuffer(hComponent, pBuffer);
}
} else {
DEBUG(DEB_LEV_ERR, "In %s: eos=%x Dropping Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
}
} else {
DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE COpenMaxVideo::PrimeFillBuffers(void)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
OpenMaxVideoBuffer *buffer;
#if defined(OMX_DEBUG_VERBOSE)
CLog::Log(LOGDEBUG, "%s::%s\n", CLASSNAME, __func__);
#endif
// tell OpenMax to start filling output buffers
for (size_t i = 0; i < m_omx_output_buffers.size(); i++)
{
buffer = m_omx_output_buffers[i];
// always set the port index.
buffer->omx_buffer->nOutputPortIndex = m_omx_output_port;
// Need to clear the EOS flag.
buffer->omx_buffer->nFlags &= ~OMX_BUFFERFLAG_EOS;
buffer->omx_buffer->pAppPrivate = buffer;
omx_err = OMX_FillThisBuffer(m_omx_decoder, buffer->omx_buffer);
if (omx_err)
CLog::Log(LOGERROR, "%s::%s - OMX_FillThisBuffer failed with omx_err(0x%x)\n",
CLASSNAME, __func__, omx_err);
}
return omx_err;
}
OMX_ERRORTYPE process_event(HTEST *hTest, MSG *pMsg)
{
OMX_EVENTTYPE event = pMsg->data.event.eEvent;
OMX_U32 nPortIndex = pMsg->data.event.nData1;
if(event == OMX_EventPortSettingsChanged)
{
port_disable(hTest, nPortIndex);
port_enable(hTest, nPortIndex);
OMX_STATETYPE eState = OMX_StateInvalid;
OMX_GetState(hTest->hComponent, &eState);
if(eState == OMX_StateExecuting)
{
/* Send output buffers */
OMX_S32 i;
for(i=0; i<hTest->nBufferHdr[1]; i++)
{
hTest->pBufferHdr[1][i]->nFilledLen = 0;
hTest->pBufferHdr[1][i]->nOffset = 0;
OMX_FillThisBuffer(hTest->hComponent, hTest->pBufferHdr[1][i]);
}
}
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE onFillBufferDone(OMX_HANDLETYPE hComponent,
OMX_PTR pAppData,
OMX_BUFFERHEADERTYPE* pBuffer)
{
/*if (isFirstCallback) {
isFirstCallback = false;
currentFrameTime = ofGetElapsedTimeMillis();
ofLogVerbose() << "isFirstCallback";
}else
{
lastFrameTime = currentFrameTime;
currentFrameTime = ofGetElapsedTimeMillis();
ofLogVerbose() << "Frame process time: " << currentFrameTime - lastFrameTime;
}*/
//ofLogVerbose() << "onFillBufferDone<----------";
//COMXCoreComponent *ctx = static_cast<COMXCoreComponent*>(pAppData);
OMX_ERRORTYPE didFillBuffer = OMX_FillThisBuffer(hComponent, pBuffer);
if (didFillBuffer == OMX_ErrorNone)
{
//OMXDecoderBase *ctx = static_cast<OMXDecoderBase*>(pAppData);
OMXDecoderBase::fillBufferCounter++;
//ofLogVerbose(__func__) << " fillBufferCounter: " << fillBufferCounter;
}
return didFillBuffer;
}
void * process_thread(void *ptr)
{
HTEST *hTest = (HTEST*)ptr;
OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
MSG sMsg;
while(1)
{
hTest->pMsgQ->Get(&sMsg);
if(sMsg.type == EVENT)
{
process_event(hTest, &sMsg);
}
else if(sMsg.type == EMPTY_DONE)
{
pBufferHdr = sMsg.data.buffer.pBuffer;
if(hTest->bHoldBuffers != OMX_TRUE)
{
read_data(hTest, pBufferHdr);
OMX_EmptyThisBuffer(sMsg.hComponent, pBufferHdr);
}
}
else if(sMsg.type == FILL_DONE)
{
pBufferHdr = sMsg.data.buffer.pBuffer;
if(hTest->bHoldBuffers != OMX_TRUE)
OMX_FillThisBuffer(sMsg.hComponent, pBufferHdr);
}
if(hTest->bStop == OMX_TRUE)
break;
}
return NULL;
}
OMX_ERRORTYPE port_enable(HTEST *hTest, OMX_U32 nPortIndex)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *hComponent;
OMX_U32 i;
hComponent = hTest->hComponent;
ret = SendCommand(hTest, OMX_CommandPortEnable, nPortIndex, NULL, OMX_FALSE);
if(ret != OMX_ErrorNone)
return ret;
prepare_port_buffers(hTest, nPortIndex);
WaitCommand(hTest, OMX_CommandPortEnable, nPortIndex, NULL);
hTest->bHoldBuffers = OMX_FALSE;
for(i=0; i<hTest->nBufferHdr[nPortIndex]; i++) {
if(hTest->PortDir[nPortIndex] == OMX_DirOutput) {
OMX_FillThisBuffer(hTest->hComponent, hTest->pBufferHdr[nPortIndex][i]);
}
}
printf("port enable done.\n");
return OMX_ErrorNone;
}
OMX_ERRORTYPE AnatomyOMXClient::OnFillBufferDone(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE *pBuffer) {
AnatomyOMXClient* omxclient = reinterpret_cast<AnatomyOMXClient*>(pAppData);
CHECK( NULL != omxclient);
CHECK( NULL != pBuffer );
omxclient->addOMXBufferInfo(kPortIndexOutput, pBuffer);
if( pBuffer->nFlags & OMX_BUFFERFLAG_EOS || omxclient->getStatus() == 1 )
{
omxclient->signalEOF();
omxclient->setStatus(1);
return OMX_ErrorNone;
}
if( pBuffer->nSize > 0 )
{
omxclient->render(pBuffer->pBuffer, pBuffer->nSize);
}
OMX_FillThisBuffer(hComponent, pBuffer);
omxclient->removeOMXBufferInfo(kPortIndexOutput, pBuffer);
return OMX_ErrorNone;
}
void COpenMaxVideo::SetDropState(bool bDrop)
{
m_drop_state = bDrop;
if (m_drop_state)
{
OMX_ERRORTYPE omx_err;
// blow all but the last ready video frame
pthread_mutex_lock(&m_omx_output_mutex);
while (m_omx_output_ready.size() > 1)
{
m_dts_queue.pop();
OMX_BUFFERHEADERTYPE *omx_buffer = m_omx_output_ready.front()->omx_buffer;
m_omx_output_ready.pop();
// return the omx buffer back to OpenMax to fill.
omx_err = OMX_FillThisBuffer(m_omx_decoder, omx_buffer);
if (omx_err)
CLog::Log(LOGERROR, "%s::%s - OMX_FillThisBuffer, omx_err(0x%x)\n",
CLASSNAME, __func__, omx_err);
}
pthread_mutex_unlock(&m_omx_output_mutex);
#if defined(OMX_DEBUG_VERBOSE)
CLog::Log(LOGDEBUG, "%s::%s - m_drop_state(%d)\n",
CLASSNAME, __func__, m_drop_state);
#endif
}
}
void my_fill_buffer_done(void* data, COMPONENT_T* comp)
{
if (OMX_FillThisBuffer(ilclient_get_handle(video_render), eglBuffer) != OMX_ErrorNone)
{
printf("OMX_FillThisBuffer failed in callback\n");
exit(1);
}
}
bool COpenMaxVideo::GetPicture(DVDVideoPicture* pDvdVideoPicture)
{
while (m_omx_output_busy.size() > 1)
{
// fetch a output buffer and pop it off the busy list
pthread_mutex_lock(&m_omx_output_mutex);
OpenMaxVideoBuffer *buffer = m_omx_output_busy.front();
m_omx_output_busy.pop();
pthread_mutex_unlock(&m_omx_output_mutex);
bool done = buffer->omx_buffer->nFlags & OMX_BUFFERFLAG_EOS;
if (!done)
{
// return the omx buffer back to OpenMax to fill.
OMX_ERRORTYPE omx_err = OMX_FillThisBuffer(m_omx_decoder, buffer->omx_buffer);
if (omx_err)
CLog::Log(LOGERROR, "%s::%s - OMX_FillThisBuffer, omx_err(0x%x)\n",
CLASSNAME, __func__, omx_err);
}
}
if (!m_omx_output_ready.empty())
{
OpenMaxVideoBuffer *buffer;
// fetch a output buffer and pop it off the ready list
pthread_mutex_lock(&m_omx_output_mutex);
buffer = m_omx_output_ready.front();
m_omx_output_ready.pop();
m_omx_output_busy.push(buffer);
pthread_mutex_unlock(&m_omx_output_mutex);
pDvdVideoPicture->dts = DVD_NOPTS_VALUE;
pDvdVideoPicture->pts = DVD_NOPTS_VALUE;
pDvdVideoPicture->format = RENDER_FMT_OMXEGL;
pDvdVideoPicture->openMax = this;
pDvdVideoPicture->openMaxBuffer = buffer;
if (!m_dts_queue.empty())
{
pDvdVideoPicture->dts = m_dts_queue.front();
m_dts_queue.pop();
}
// nTimeStamp is in microseconds
pDvdVideoPicture->pts = (buffer->omx_buffer->nTimeStamp == 0) ? DVD_NOPTS_VALUE : (double)buffer->omx_buffer->nTimeStamp / 1000.0;
}
#if defined(OMX_DEBUG_VERBOSE)
else
{
CLog::Log(LOGDEBUG, "%s::%s - called but m_omx_output_ready is empty\n",
CLASSNAME, __func__);
}
#endif
pDvdVideoPicture->iFlags = DVP_FLAG_ALLOCATED;
pDvdVideoPicture->iFlags |= m_drop_state ? DVP_FLAG_DROPPED : 0;
return true;
}
OMX_ERRORTYPE onFillBufferDone(OMX_HANDLETYPE hComponent,
OMX_PTR pAppData,
OMX_BUFFERHEADERTYPE* pBuffer)
{
//ofLogVerbose() << "onFillBufferDone<----------";
//COMXCoreComponent *ctx = static_cast<COMXCoreComponent*>(pAppData);
OMX_ERRORTYPE didFillBuffer = OMX_FillThisBuffer(hComponent, pBuffer);
return didFillBuffer;
}
OMX_ERRORTYPE omxil_comp::FillThisBuffer(OMX_BUFFERHEADERTYPE *pBuffer)
{
OMX_ERRORTYPE result;
result = OMX_FillThisBuffer(comp, pBuffer);
if (result != OMX_ErrorNone) {
fprintf(stderr, "OMX_FillThisBuffer failed.\n");
}
return result;
}
status_t OMXNodeInstance::fillBuffer(OMX::buffer_id buffer) {
Mutex::Autolock autoLock(mLock);
OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer;
header->nFilledLen = 0;
header->nOffset = 0;
header->nFlags = 0;
OMX_ERRORTYPE err = OMX_FillThisBuffer(mHandle, header);
return StatusFromOMXError(err);
}
OMX_ERRORTYPE my_fill_buffer_done(OMX_HANDLETYPE hComponent,
OMX_PTR pAppData, OMX_BUFFERHEADERTYPE* pBuffer)
{
appctx *ctx = (appctx *) pAppData;
if (OMX_FillThisBuffer(ctx->render, ctx->eglBuffer) != OMX_ErrorNone)
{
printf("OMX_FillThisBuffer failed in callback\n");
exit(1);
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE camera_sourceFillBufferDone(
OMX_HANDLETYPE hComponent,
OMX_PTR pAppData,
OMX_BUFFERHEADERTYPE* pBuffer) {
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s for camera component\n",__func__);
DEBUG(DEB_LEV_FULL_SEQ, "%s: Get returned buffer (0x%lX) from port[%ld], nFilledLen=%ld\n", __func__, (OMX_U32)pBuffer, pBuffer->nOutputPortIndex, pBuffer->nFilledLen);
if (pBuffer->nOutputPortIndex == OMX_CAMPORT_INDEX_CP) {
if ((pBuffer->nFlags & OMX_BUFFERFLAG_STARTTIME) != 0) {
DEBUG(DEB_LEV_FULL_SEQ, "%s: Get buffer flag OMX_BUFFERFLAG_STARTTIME!\n", __func__);
pBuffer->nFlags = 0;
}
/* Print time stamp of each buffer */
#ifndef OMX_SKIP64BIT
DEBUG(DEB_LEV_FULL_SEQ, "%s: buffer[0x%lX] time stamp: 0x%016llX\n", __func__, (OMX_U32)pBuffer, pBuffer->nTimeStamp);
#else
DEBUG(DEB_LEV_FULL_SEQ, "%s: buffer[0x%lX] time stamp: 0x%08lX%08lX\n", __func__, (OMX_U32)pBuffer, pBuffer->nTimeStamp.nHighPart, pBuffer->nTimeStamp.nLowPart);
#endif
}
if (pBuffer->nOutputPortIndex == OMX_CAMPORT_INDEX_CP && fCapture != NULL) {
DEBUG(DEB_LEV_FULL_SEQ, "%s: writing to file",__func__);
fwrite(pBuffer->pBuffer + pBuffer->nOffset, 1, pBuffer->nFilledLen, fCapture);
pBuffer->nFilledLen = 0;
pBuffer->nOffset = 0;
OMX_FillThisBuffer(appPriv->camerahandle, pBuffer);
}
else if (pBuffer->nOutputPortIndex == OMX_CAMPORT_INDEX_CP_T && fThumbnail != NULL) {
fwrite(pBuffer->pBuffer + pBuffer->nOffset, 1, pBuffer->nFilledLen, fThumbnail);
pBuffer->nFilledLen = 0;
pBuffer->nOffset = 0;
OMX_FillThisBuffer(appPriv->camerahandle, pBuffer);
}
DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s for camera component, return code: 0x%X\n",__func__, OMX_ErrorNone);
return OMX_ErrorNone;
}
void FillThisBuffer(iterator it) {
OMX_BUFFERHEADERTYPE* bh = it->buf;
bh->nFlags = 0;
bh->nOffset = 0;
bh->nFilledLen = 0;
//enum { Y0=1920*1080 };
//static char z16[16] = {0};
//memcpy(bh->pBuffer+Y0, z16, 16);
//memcmp(bh->pBuffer+Y0, z16, 16);
it->flags |= MSK_USED;
printf("%s:%s [%d] %d %d %x\n", __FUNCTION__,"OMX_FillThisBuffer", INDEX(it), bh->nFilledLen, bh->nOffset, bh->nFlags);
OMX_ERRORTYPE err = OMX_FillThisBuffer(component, bh);
ERR_EXIT_IF(err!=OMX_ErrorNone, "OMX_FillThisBuffer %d", int(err));
}
OMX_ERRORTYPE cFillBufferDone(
OMX_HANDLETYPE hComponent,
OMX_PTR pAppData,
OMX_BUFFERHEADERTYPE* pBuffer) {
fprintf(stderr, "Hi there, I am in the %s callback.\n", __func__);
if (bEOS) {
fprintf(stderr, "Buffers filled, exiting\n");
}
write(outFd, pBuffer->pBuffer, pBuffer->nFilledLen);
pBuffer->nFilledLen = 0;
err = OMX_FillThisBuffer(handle, pBuffer);
return OMX_ErrorNone;
}
/*========================================================*/
static int omx_fillthisbuffer(int index, int PortNum)
{
struct port_param *sPortParam;
sPortParam = &(pContext->sPortParam[PortNum]);
eError = OMX_FillThisBuffer(pContext->hComp,
sPortParam->bufferheader[index]);
OMX_TEST_BAIL_IF_ERROR(eError);
return eError;
OMX_TEST_BAIL:
if (eError != OMX_ErrorNone)
dprintf(0, "ERROR OMX_FillThisBuffer()\n");
return eError;
}
OMX_ERRORTYPE COMXCoreComponent::FillThisBuffer(OMX_BUFFERHEADERTYPE *omx_buffer)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
if(!m_handle || !omx_buffer)
return OMX_ErrorUndefined;
omx_err = OMX_FillThisBuffer(m_handle, omx_buffer);
if (omx_err != OMX_ErrorNone) {
Logger::LogOut(LOG_LEVEL_ERROR, "COMXCoreComponent::FillThisBuffer component(%s) - failed with result(0x%x)",
m_componentName.c_str(), omx_err);
}
return omx_err;
}
void
g_omx_port_release_buffer (GOmxPort *port,
OMX_BUFFERHEADERTYPE *omx_buffer)
{
switch (port->type)
{
case GOMX_PORT_INPUT:
OMX_EmptyThisBuffer (port->core->omx_handle, omx_buffer);
break;
case GOMX_PORT_OUTPUT:
OMX_FillThisBuffer (port->core->omx_handle, omx_buffer);
break;
default:
break;
}
}
static void* captureVideo (void* threadArg){
//The return value is not needed
OMXCAM_THREAD_ARG* arg = (OMXCAM_THREAD_ARG*)threadArg;
int stop = 0;
OMX_ERRORTYPE error;
safeRunning = 1;
while (safeRunning){
if (pthread_mutex_lock (&mutex)){
OMXCAM_error ("pthread_mutex_lock");
handleError ();
return (void*)0;
}
stop = !running;
if (pthread_mutex_unlock (&mutex)){
OMXCAM_error ("pthread_mutex_unlock");
handleError ();
return (void*)0;
}
if (stop) break;
if ((error = OMX_FillThisBuffer (arg->fillComponent->handle,
OMXCAM_ctx.outputBuffer))){
OMXCAM_error ("OMX_FillThisBuffer: %s",
OMXCAM_dump_OMX_ERRORTYPE (error));
handleError ();
return (void*)0;
}
//Wait until it's filled
if (OMXCAM_wait (arg->fillComponent, OMXCAM_EventFillBufferDone, 0)){
handleError ();
return (void*)0;
}
//Emit the buffer
arg->bufferCallback (OMXCAM_ctx.outputBuffer->pBuffer,
OMXCAM_ctx.outputBuffer->nFilledLen);
}
return (void*)0;
}
void BaseEngine::threadedFunction()
{
while (isThreadRunning())
{
if(bufferAvailable)
{
// The user wants to quit, but don't exit
// the loop until we are certain that we have processed
// a full frame till end of the frame, i.e. we're at the end
// of the current key frame if processing one or until
// the next key frame is detected. This way we should always
// avoid corruption of the last encoded at the expense of
// small delay in exiting.
if(stopRequested && !isStopping)
{
ofLogVerbose(__func__) << "Exit signal detected, waiting for next key frame boundry before exiting...";
isStopping = true;
isKeyframeValid = encoderOutputBuffer->nFlags & OMX_BUFFERFLAG_SYNCFRAME;
}
if(isStopping && (isKeyframeValid ^ (encoderOutputBuffer->nFlags & OMX_BUFFERFLAG_SYNCFRAME)))
{
ofLogVerbose(__func__) << "Key frame boundry reached, exiting loop...";
writeFile();
doFillBuffer = false;
}else
{
recordingFileBuffer.append((const char*) encoderOutputBuffer->pBuffer + encoderOutputBuffer->nOffset, encoderOutputBuffer->nFilledLen);
//ofLogVerbose(__func__) << "encoderOutputBuffer->nFilledLen: " << encoderOutputBuffer->nFilledLen;
doFillBuffer = true;
}
}
// Buffer flushed, request a new buffer to be filled by the encoder component
if(doFillBuffer)
{
doFillBuffer = false;
bufferAvailable = false;
OMX_ERRORTYPE error = OMX_FillThisBuffer(encoder, encoderOutputBuffer);
if(error != OMX_ErrorNone)
{
ofLog(OF_LOG_ERROR, "encoder OMX_FillThisBuffer FAIL error: 0x%08x", error);
close();
}
}
}
}
void * process_thread(void *ptr)
{
HTEST *hTest = (HTEST*)ptr;
OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
MSG sMsg;
while(1)
{
hTest->pMsgQ->Get(&sMsg);
if(sMsg.type == EVENT)
{
process_event(hTest, &sMsg);
}
else if(sMsg.type == EMPTY_DONE)
{
pBufferHdr = sMsg.data.buffer.pBuffer;
if(hTest->bHoldBuffers != OMX_TRUE)
{
OMX_EmptyThisBuffer(sMsg.hComponent, pBufferHdr);
}
}
else if(sMsg.type == FILL_DONE)
{
pBufferHdr = sMsg.data.buffer.pBuffer;
if (hTest->bAudioTrackStopped && hTest->bVideoTrackStopped)
break;
if (pBufferHdr->nOutputPortIndex == hTest->nAudioTrackNum)
{
if (hTest->bAudioTrackStopped)
continue;
}
else if (pBufferHdr->nOutputPortIndex == hTest->nVideoTrackNum)
{
if (hTest->bVideoTrackStopped)
continue;
}
if(hTest->bHoldBuffers != OMX_TRUE)
OMX_FillThisBuffer(sMsg.hComponent, pBufferHdr);
}
}
return NULL;
}
static void
release_buffer (GOmxPort *port, OMX_BUFFERHEADERTYPE *omx_buffer)
{
switch (port->type)
{
case GOMX_PORT_INPUT:
/* do nothing */
break;
case GOMX_PORT_OUTPUT:
GST_LOG ("FTB: omx_buffer=%p, pAppPrivate=%p, pBuffer=%p",
omx_buffer, omx_buffer ? omx_buffer->pAppPrivate : 0, omx_buffer ? omx_buffer->pBuffer : 0);
OMX_FillThisBuffer (port->core->omx_handle, omx_buffer);
break;
default:
break;
}
}
