OMX_ERRORTYPE volcEmptyBufferDone(
OMX_OUT OMX_HANDLETYPE hComponent,
OMX_OUT OMX_PTR pAppData,
OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer) {
int data_read;
static int iBufferDropped=0;
DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
data_read = read(fd, pBuffer->pBuffer, BUFFER_IN_SIZE);
pBuffer->nFilledLen = data_read;
pBuffer->nOffset = 0;
filesize -= data_read;
if (data_read <= 0) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "In the %s no more input data available\n", __func__);
iBufferDropped++;
if(iBufferDropped>=2) {
tsem_up(appPriv->eofSem);
return OMX_ErrorNone;
}
pBuffer->nFilledLen=0;
pBuffer->nFlags = OMX_BUFFERFLAG_EOS;
bEOS=OMX_TRUE;
err = OMX_EmptyThisBuffer(hComponent, pBuffer);
return OMX_ErrorNone;
}
if(!bEOS) {
DEBUG(DEB_LEV_FULL_SEQ, "Empty buffer %x\n", (int)pBuffer);
err = OMX_EmptyThisBuffer(hComponent, pBuffer);
}else {
DEBUG(DEB_LEV_FULL_SEQ, "In %s Dropping Empty This buffer to Audio Dec\n", __func__);
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE EmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
{
int readBytes =0;
/* To remove warning for unused variable to keep prototype same */
(void)pAppData;
ebd_cnt++;
used_ip_buf_cnt--;
pthread_mutex_lock(&etb_lock);
if(!etb_done)
{
DEBUG_PRINT("\n*********************************************\n");
DEBUG_PRINT("Wait till first set of buffers are given to component\n");
DEBUG_PRINT("\n*********************************************\n");
etb_done++;
pthread_mutex_unlock(&etb_lock);
etb_wait_for_event();
}
else
{
pthread_mutex_unlock(&etb_lock);
}
if(bInputEosReached)
{
DEBUG_PRINT("\n*********************************************\n");
DEBUG_PRINT(" EBD::EOS on input port\n ");
DEBUG_PRINT("*********************************************\n");
return OMX_ErrorNone;
}else if (bFlushing == true) {
DEBUG_PRINT("omx_evrc13_adec_test: bFlushing is set to TRUE used_ip_buf_cnt=%d\n",used_ip_buf_cnt);
if (used_ip_buf_cnt == 0) {
bFlushing = false;
} else {
DEBUG_PRINT("omx_evrc13_adec_test: more buffer to come back used_ip_buf_cnt=%d\n",used_ip_buf_cnt);
return OMX_ErrorNone;
}
}
if((readBytes = Read_Buffer(pBuffer)) > 0) {
pBuffer->nFilledLen = readBytes;
used_ip_buf_cnt++;
OMX_EmptyThisBuffer(hComponent,pBuffer);
}
else{
pBuffer->nFlags |= OMX_BUFFERFLAG_EOS;
used_ip_buf_cnt++;
bInputEosReached = true;
pBuffer->nFilledLen = 0;
OMX_EmptyThisBuffer(hComponent,pBuffer);
DEBUG_PRINT("EBD..Either EOS or Some Error while reading file\n");
}
return OMX_ErrorNone;
}
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 PortCommTest_WriteInBuffers(PortCommTestCtxt* pContext)
{
BufferList * pList;
OMX_BUFFERHEADERTYPE *pBufHeader;
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_U32 nPayload;
pList = pContext->pInBufferList;
while (pList && pList->pBufHdr)
{
pContext->nInBufBusy++;
LIST_CLEAR_ENTRY(pList, pBufHeader);
nPayload = (pContext->nBufFactor) ? pBufHeader->nAllocLen / pContext->nBufFactor : 1;
pBufHeader->nFilledLen = OMX_OSAL_ReadFromInputFile(pBufHeader->pBuffer, nPayload,
pBufHeader->nInputPortIndex);
if (pBufHeader->nFilledLen != nPayload)
{
pBufHeader->nFlags |= OMX_BUFFERFLAG_EOS;
}
OMX_CONF_BAIL_IF_ERROR(OMX_EmptyThisBuffer(pContext->hWComp, pBufHeader));
}
OMX_CONF_TEST_BAIL:
return eError;
}
void* audio_exec(void* udata) {
float buffer_time_us = (float)(1e6 * NUM_SAMPLES) / SAMPLE_FREQ;
while(1) {
/* get a buffer */
OMX_BUFFERHEADERTYPE *hdr;
while((hdr = ilclient_get_input_buffer(audio_render, 100, 0)) == NULL) {
usleep(buffer_time_us / 4); // wait 1/4 of the time to drain a buffer
}
// fill the buffer
audio_fill_buffer((int16_t*)hdr->pBuffer, NUM_SAMPLES * 2);
hdr->nOffset = 0;
hdr->nFilledLen = scaled_buffer_size(NUM_SAMPLES);
// submit the buffer
OMX_ERRORTYPE error;
error = OMX_EmptyThisBuffer(ILC_GET_HANDLE(audio_render), hdr);
assert(error == OMX_ErrorNone);
// drive down the latency to a buffer's length or less
uint32_t latency;
while(audio_get_latency() > NUM_SAMPLES) {
usleep(buffer_time_us / 2);
}
}
}
OMX_ERRORTYPE read_into_buffer_and_empty(FILE *fp,
COMPONENT_T *component,
OMX_BUFFERHEADERTYPE *buff_header,
int *toread)
{
OMX_ERRORTYPE r;
int buff_size = buff_header->nAllocLen;
int nread = fread(buff_header->pBuffer, 1, buff_size, fp);
buff_header->nFilledLen = nread;
*toread -= nread;
printf("Read %d, %d still left\n", nread, *toread);
if (*toread <= 0)
{
printf("Setting EOS on input\n");
buff_header->nFlags |= OMX_BUFFERFLAG_EOS;
}
r = OMX_EmptyThisBuffer(ilclient_get_handle(component),
buff_header);
if (r != OMX_ErrorNone)
{
fprintf(stderr, "Empty buffer error %s\n",
err2str(r));
}
return r;
}
OMX_ERRORTYPE omxSetAudioExtraData(struct OMX_COMPONENT_T *component, uint8_t *extraData, int extraSize)
{
OMX_ERRORTYPE omxErr = OMX_ErrorNotReady;
if ((extraSize <= 0) || (extraData == NULL)) {
return OMX_ErrorNone;
}
OMX_BUFFERHEADERTYPE *omxBuffer = omxGetInputBuffer(component, 0);
if(omxBuffer == NULL) {
logInfo(LOG_OMX, "Error getting inputbuffer on component %s\n", component->componentName);
return omxErr;
}
omxBuffer->nOffset = 0;
omxBuffer->nFilledLen = extraSize;
if(omxBuffer->nFilledLen > omxBuffer->nAllocLen) {
logInfo(LOG_OMX, "Error omxBuffer->nFilledLen > omxBuffer->nAllocLen on component %s\n", component->componentName);
return omxErr;
}
memset((unsigned char *)omxBuffer->pBuffer, 0x0, omxBuffer->nAllocLen);
memcpy((unsigned char *)omxBuffer->pBuffer, extraData, omxBuffer->nFilledLen);
omxBuffer->nFlags = OMX_BUFFERFLAG_CODECCONFIG | OMX_BUFFERFLAG_ENDOFFRAME;
omxErr = OMX_EmptyThisBuffer(component->handle, omxBuffer);
if (omxErr != OMX_ErrorNone) {
logInfo(LOG_OMX, "Error OMX_EmptyThisBuffer on component %s (Error=0x%08x)\n", component->componentName, omxErr);
return omxErr;
}
return OMX_ErrorNone;
}
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_DirInput)
{
read_frame(hTest, hTest->pBufferHdr[nPortIndex][i]);
OMX_EmptyThisBuffer(hTest->hComponent, hTest->pBufferHdr[nPortIndex][i]);
}
}
printf("port enable done.\n");
return OMX_ErrorNone;
}
static void wait_complition(player_ctx_t *ctx)
{
media_buffer_t *buf;
OMX_BUFFERHEADERTYPE *hdr;
OMX_ERRORTYPE err;
if (ctx->common.stop)
return; /* Force stop player by user */
buf = decode_get_free_video_buffer(ctx->common.demux_ctx);
if (!buf)
{
DBG_E("Unable to get free video buffer\n");
return;
}
hdr = (OMX_BUFFERHEADERTYPE *)buf->app_data;
hdr->pAppPrivate = buf;
hdr->nOffset = 0;
hdr->nFilledLen = 0;
hdr->nTimeStamp = to_omx_time(0);
hdr->nFlags = OMX_BUFFERFLAG_ENDOFFRAME | OMX_BUFFERFLAG_EOS | OMX_BUFFERFLAG_TIME_UNKNOWN;
err = OMX_EmptyThisBuffer(ilcore_get_handle(ctx->decoder), hdr);
if (err != OMX_ErrorNone)
{
DBG_E("OMX_EmptyThisBuffer failed. err=0x%08x\n", err);
return;
}
DBG_I("Waiting for end of stream\n");
while (!ctx->eos)
{
usleep(100000);
}
}
OMX_ERRORTYPE AnatomyOMXClient::OnEmptyBufferDone(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE *pBuffer) {
AnatomyOMXClient* omxclient = reinterpret_cast<AnatomyOMXClient*>(pAppData);
int nSize = 0;
omxclient->addOMXBufferInfo(kPortIndexInput, pBuffer);
CHECK(NULL != omxclient);
CHECK( NULL != pBuffer );
if( pBuffer->nFlags & OMX_BUFFERFLAG_EOS )
{
return OMX_ErrorNone;
}
omxclient->read(pBuffer->pBuffer, &nSize);
if( nSize <= 0 ) {
pBuffer->nSize = 0;
pBuffer->nFlags |= OMX_BUFFERFLAG_EOS;
}
else {
pBuffer->nSize = nSize;
}
OMX_EmptyThisBuffer(hComponent, pBuffer);
omxclient->removeOMXBufferInfo(kPortIndexInput, pBuffer);
return OMX_ErrorNone;
}
int
renderImage(OPENMAX_JPEG_DECODER * decoder) {
int ret;
printf("Rendering image\n");
printState(decoder->imageDecoder->handle);
// setup render buffer
decoder->ppRenderInputBufferHeader[0]->nFilledLen =
decoder->pOutputBufferHeader->nFilledLen;
decoder->ppRenderInputBufferHeader[0]->nFlags = OMX_BUFFERFLAG_EOS;
printf("Render buffer has %d\n",
decoder->ppRenderInputBufferHeader[0]->nFilledLen);
ret = OMX_EmptyThisBuffer(decoder->imageRender->handle,
decoder->ppRenderInputBufferHeader[0]);
if (ret != OMX_ErrorNone) {
perror("Emptying render input buffer");
fprintf(stderr, "Error code %s\n", err2str(ret));
return OMXJPEG_ERROR_MEMORY;
} else {
printf("Called to empty render input buffer\n");
}
return OMXJPEG_OK;
}
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;
}
static void
rpi_codec_decode(struct media_codec *mc, struct video_decoder *vd,
struct media_queue *mq, struct media_buf *mb, int reqsize)
{
media_pipe_t *mp = vd->vd_mp;
rpi_video_codec_t *rvc = mc->opaque;
const void *data = mb->mb_data;
size_t len = mb->mb_size;
while(len > 0) {
OMX_BUFFERHEADERTYPE *buf = omx_get_buffer(rvc->rvc_decoder);
buf->nOffset = 0;
buf->nFilledLen = MIN(len, buf->nAllocLen);
memcpy(buf->pBuffer, data, buf->nFilledLen);
buf->nFlags = 0;
if(rvc->rvc_last_epoch != mb->mb_epoch) {
buf->nFlags |= OMX_BUFFERFLAG_DISCONTINUITY;
rvc->rvc_last_epoch = mb->mb_epoch;
}
if(len <= buf->nAllocLen)
buf->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
data += buf->nFilledLen;
len -= buf->nFilledLen;
if(mb->mb_pts != PTS_UNSET)
buf->nTimeStamp = omx_ticks_from_s64(mb->mb_pts);
else {
buf->nFlags |= OMX_BUFFERFLAG_TIME_UNKNOWN;
buf->nTimeStamp = omx_ticks_from_s64(0);
}
if(mb->mb_skip)
buf->nFlags |= OMX_BUFFERFLAG_DECODEONLY;
if(rvc->rvc_decoder->oc_port_settings_changed) {
rvc->rvc_decoder->oc_port_settings_changed = 0;
frame_info_t fi;
memset(&fi, 0, sizeof(fi));
fi.fi_type = 'omx';
fi.fi_data[0] = (void *)rvc->rvc_decoder;
mp->mp_video_frame_deliver(&fi, mp->mp_video_frame_opaque);
}
omxchk(OMX_EmptyThisBuffer(rvc->rvc_decoder->oc_handle, buf));
}
frame_info_t fi;
memset(&fi, 0, sizeof(fi));
fi.fi_drive_clock = mb->mb_drive_clock;
fi.fi_epoch = mb->mb_epoch;
fi.fi_pts = PTS_UNSET;
fi.fi_delta = mb->mb_delta;
fi.fi_type = 'omx';
mp->mp_video_frame_deliver(&fi, mp->mp_video_frame_opaque);
}
/*========================================================*/
OMX_ERRORTYPE SampleTest_WriteInBuffers(SampleCompTestCtxt * pContext)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
BufferList *pList;
OMX_BUFFERHEADERTYPE *pBufHeader;
#ifdef OMX_SAMPLE_TILER_TEST
OMX_U8 *pTmpBuffer = NULL, *pOrigTmpBuffer = NULL;
#endif
pList = pContext->pInBufferList;
while (pList && pList->pBufHdr)
{
BUFFERLIST_CLEAR_ENTRY(pList, pBufHeader);
printf("\nAbout to read from input file\n");
#if defined(OMX_SAMPLE_TILER_TEST)
//OMX_SAMPLE_BUFFER_SIZE is the total amt of data to be sent in the buffer
pTmpBuffer =
TIMM_OSAL_Malloc(OMX_SAMPLE_BUFFER_SIZE, 0, 0, 0);
if (pTmpBuffer == NULL)
OMX_TEST_SET_ERROR_BAIL
(OMX_ErrorInsufficientResources,
"malloc failed \n");
pOrigTmpBuffer = pTmpBuffer;
SampleTest_ReadInputFile(pContext, pTmpBuffer,
OMX_SAMPLE_BUFFER_SIZE, pContext->pInputfile);
Test_Util_Memcpy_1Dto2D(pBufHeader->pBuffer, pTmpBuffer,
OMX_SAMPLE_BUFFER_SIZE, OMX_SAMPLE_IN_HEIGHT,
OMX_SAMPLE_IN_WIDTH, STRIDE_LINUX);
pBufHeader->nFilledLen = OMX_SAMPLE_BUFFER_SIZE;
printf("\nBefore ETB pBufHeader->nInputPortIndex = %d\n",
pBufHeader->nInputPortIndex);
TIMM_OSAL_Free(pOrigTmpBuffer);
#else
SampleTest_ReadInputFile(pContext, pBufHeader->pBuffer,
pBufHeader->nAllocLen, pContext->pInputfile);
pBufHeader->nFilledLen = pBufHeader->nAllocLen;
#endif
if (pContext->bEOS == OMX_TRUE)
{
pBufHeader->nFlags |= OMX_BUFFERFLAG_EOS;
}
eError = OMX_EmptyThisBuffer(pContext->hComp, pBufHeader);
OMX_TEST_BAIL_IF_ERROR(eError);
}
OMX_TEST_BAIL:
return eError;
}
OMX_ERRORTYPE EmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
{
int readBytes =0;
DEBUG_PRINT("\nFunction %s cnt[%d]\n", __FUNCTION__, ebd_cnt);
ebd_cnt++;
used_ip_buf_cnt--;
if(bInputEosReached) {
DEBUG_PRINT("\n*********************************************\n");
DEBUG_PRINT(" EBD::EOS on input port\n ");
DEBUG_PRINT(" TBD:::De Init the open max here....!!!\n");
DEBUG_PRINT("*********************************************\n");
if(tunnel)
event_complete();
return OMX_ErrorNone;
} else if (bFlushing == true) {
DEBUG_PRINT("omx_aac_adec_test: bFlushing is set to TRUE used_ip_buf_cnt=%d\n",used_ip_buf_cnt);
if (used_ip_buf_cnt == 0) {
//fseek(inputBufferFile, 0, 0);
bFlushing = false;
} else {
DEBUG_PRINT("omx_aac_adec_test: more buffer to come back used_ip_buf_cnt=%d\n",used_ip_buf_cnt);
return OMX_ErrorNone;
}
}
if((readBytes = Read_Buffer(pBuffer)) > 0) {
pBuffer->nFilledLen = readBytes;
used_ip_buf_cnt++;
OMX_EmptyThisBuffer(hComponent,pBuffer);
}
else{
pBuffer->nFlags |= OMX_BUFFERFLAG_EOS;
bInputEosReached = true;
pBuffer->nFilledLen = 0;
OMX_EmptyThisBuffer(hComponent,pBuffer);
DEBUG_PRINT("EBD..Either EOS or Some Error while reading file\n");
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE omxil_comp::EmptyThisBuffer(OMX_BUFFERHEADERTYPE *pBuffer)
{
OMX_ERRORTYPE result;
result = OMX_EmptyThisBuffer(comp, pBuffer);
if (result != OMX_ErrorNone) {
fprintf(stderr, "OMX_EmptyThisBuffer failed.\n");
}
return result;
}
static void UnlockSurface(picture_t *picture)
{
picture_sys_t *picsys = picture->p_sys;
vout_display_sys_t *p_sys = picsys->sys;
OMX_BUFFERHEADERTYPE *p_buffer = picsys->buf;
if (!p_buffer->nFilledLen)
OMX_FIFO_PUT(&p_sys->port.fifo, p_buffer);
else
OMX_EmptyThisBuffer(p_sys->omx_handle, p_buffer);
}
OMX_ERRORTYPE volumeFillBufferDone(
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 no sink component then write buffer content in output file, in non tunneled case
* else in non tunneled case, call the sink comp handle to process this buffer as its input buffer
*/
if(flagIsSinkRequested && (!flagSetupTunnel)) {
if(pInBufferSink[0]->pBuffer == pBuffer->pBuffer) {
pInBufferSink[0]->nFilledLen = pBuffer->nFilledLen;
err = OMX_EmptyThisBuffer(appPriv->alsasink_handle, pInBufferSink[0]);
} else {
pInBufferSink[1]->nFilledLen = pBuffer->nFilledLen;
err = OMX_EmptyThisBuffer(appPriv->alsasink_handle, pInBufferSink[1]);
}
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
}
} 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 && !flagIsSinkRequested && (!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 COMXCoreComponent::EmptyThisBuffer(OMX_BUFFERHEADERTYPE *omx_buffer)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
if(!m_handle || !omx_buffer)
return OMX_ErrorUndefined;
omx_err = OMX_EmptyThisBuffer(m_handle, omx_buffer);
if (omx_err != OMX_ErrorNone) {
Logger::LogOut(LOG_LEVEL_ERROR, "COMXCoreComponent::EmptyThisBuffer component(%s) - failed with result(0x%x)",
m_componentName.c_str(), omx_err);
}
return omx_err;
}
int32_t ilctts_send_audio(TTSRENDER_STATE_T *st, uint8_t *buffer, uint32_t length) {
OMX_BUFFERHEADERTYPE *hdr = NULL, *prev = NULL;
int32_t ret = -1;
if(length % st->bytes_per_sample) {
ERROR("length invalid in ilctts_send_audio: %d", length);
return -1;
}
if (length > st->buffer_size) {
ERROR("length exceeds component buffer size in ilctts_send_audio: %d, buffer size: %d", length, st->buffer_size);
return -1;
}
sem_wait(&st->buffer_list_sema);
// search through user list for the right buffer header
hdr = st->user_buffer_list;
while(hdr != NULL && hdr->pBuffer != buffer && hdr->nAllocLen < length) {
prev = hdr;
hdr = hdr->pAppPrivate;
}
if(hdr) {
// we found it, remove from list
ret = 0;
if(prev)
prev->pAppPrivate = hdr->pAppPrivate;
else
st->user_buffer_list = hdr->pAppPrivate;
}
sem_post(&st->buffer_list_sema);
if(hdr) {
OMX_ERRORTYPE omx_err;
hdr->pAppPrivate = NULL;
hdr->nOffset = 0;
hdr->nFilledLen = length;
INFO(LOGLEVEL_5, "Calling empty_this_buffer");
omx_err = OMX_EmptyThisBuffer(ILC_GET_HANDLE(st->audio_render), hdr);
if (omx_err != OMX_ErrorNone) {
ERROR("OMX_EmptyThisBuffer returned error in ilctts_send_audio: %d", omx_err);
return -1;
}
}
return ret;
} // end ilctts_send_audio
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;
}
}
/* -------------------------------------------------
/ audioplay_play_buffer()
/ TODO why?>
/---------------------------------------------------*/
INT32 audioplay_play_buffer(
AUDIOPLAY_STATE_T *st,
UINT8 *buffer,
UINT32 length
){
OMX_BUFFERHEADERTYPE *hdr = NULL, *prev = NULL;
INT32 ret = -1;
if(length % st->bytes_per_sample)
return ret;
sem_wait(&st->sema);
/* search through user list for the right buffer header */
hdr = st->user_buffer_list;
while(hdr != NULL && hdr->pBuffer != buffer && hdr->nAllocLen < length){
prev = hdr;
hdr = hdr->pAppPrivate;
}
/* we found it , remove from list */
if(hdr){
ret = 0;
if(prev){
prev->pAppPrivate = hdr->pAppPrivate;
}else{
st->user_buffer_list = hdr->pAppPrivate;
}
}
sem_post(&st->sema);
if(hdr){
OMX_ERRORTYPE error;
hdr->pAppPrivate = NULL;
hdr->nOffset = 0;
hdr->nFilledLen = length;
error = OMX_EmptyThisBuffer(ILC_GET_HANDLE(st->audio_render), hdr);
assert(error == OMX_ErrorNone);
}
return ret;
}
OMX_ERRORTYPE Component::EmptyThisBuffer(OMX_BUFFERHEADERTYPE *omxBuffer)
{
if(!handle)
{
ofLogError(__func__) << getName() << " NO HANDLE";
return OMX_ErrorNone;
}
if(!omxBuffer)
{
return OMX_ErrorUndefined;
}
OMX_ERRORTYPE error = OMX_EmptyThisBuffer(handle, omxBuffer);
OMX_TRACE(error);
return error;
}
static void omx_renderer_decode_and_play_sample(char* data, int length) {
int decodeLen = opus_multistream_decode(decoder, data, length, pcmBuffer, FRAME_SIZE, 0);
if (decodeLen > 0) {
buf = ilclient_get_input_buffer(component, 100, 1);
buf->nOffset = 0;
buf->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN;
int bufLength = decodeLen * sizeof(short) * channelCount;
memcpy(buf->pBuffer, pcmBuffer, bufLength);
buf->nFilledLen = bufLength;
int r = OMX_EmptyThisBuffer(ilclient_get_handle(component), buf);
if (r != OMX_ErrorNone) {
fprintf(stderr, "Empty buffer error\n");
}
} else {
printf("Opus error from decode: %d\n", decodeLen);
}
}
/* output */
{
GooIterator* iter =
goo_component_iterate_output_ports (component);
goo_iterator_nth (iter, 0);
GooPort* port = GOO_PORT (goo_iterator_get_current (iter));
g_assert (port != NULL);
GOO_PORT_GET_DEFINITION (port)->nBufferSize =
OUTPUT_BUFFERSIZE;
GOO_PORT_GET_DEFINITION (port)->nBufferCountActual = OUTPUT_NUM_BUFFERS;
GOO_PORT_GET_DEFINITION (port)->format.audio.eEncoding =
OMX_AUDIO_CodingPCM;
g_object_unref (iter);
g_object_unref (port);
}
return;
}
#if 0 /* i think it is not necessary now */
static void
goo_ti_mp3dec_release_buffer (GooComponent* self,
OMX_BUFFERHEADERTYPE* buffer)
{
g_assert (GOO_IS_COMPONENT (self));
g_assert (buffer != NULL);
g_assert (self->cur_state == OMX_StateExecuting ||
self->cur_state == OMX_StateIdle);
GooPort* port = GOO_PORT (g_object_ref (buffer->pAppPrivate));
if (goo_port_is_eos (port) || goo_port_is_tunneled (port))
{
g_object_unref (port);
return;
}
if ((buffer->nFlags & OMX_BUFFERFLAG_EOS) == 0x1)
{
GOO_OBJECT_INFO (port, "eos found!");
goo_port_set_eos (port);
}
/* We should always push the EOS buffer */
GOO_OBJECT_NOTICE (self, "OMX_EmptyThisBuffer, 0x%x", buffer);
if (self->cur_state != OMX_StateIdle)
{
GOO_OBJECT_LOCK (self);
GOO_RUN (
OMX_EmptyThisBuffer (self->handle, buffer)
);
GOO_OBJECT_UNLOCK (self);
}
else
{
g_print("INFORMATION (workaround): Implementing workaround "
"for DR OMAPS00143083\n");
}
g_object_unref (port);
GOO_OBJECT_DEBUG (self, "");
return;
}
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;
}
// like emptyBuffer, but the data is already in header->pBuffer
status_t OMXNodeInstance::emptyDirectBuffer(
OMX_BUFFERHEADERTYPE *header,
OMX_U32 rangeOffset, OMX_U32 rangeLength,
OMX_U32 flags, OMX_TICKS timestamp) {
Mutex::Autolock autoLock(mLock);
header->nFilledLen = rangeLength;
header->nOffset = rangeOffset;
header->nFlags = flags;
header->nTimeStamp = timestamp;
OMX_ERRORTYPE err = OMX_EmptyThisBuffer(mHandle, header);
if (err != OMX_ErrorNone) {
ALOGW("emptyDirectBuffer failed, OMX err=0x%x", err);
}
return StatusFromOMXError(err);
}
iterator EmptyThis(uint8_t const* beg, uint8_t const* end, int flags) {
auto it = FindFreeBuffer(input_port);
if (it == input_port.end()) {
ERR_EXIT("%s",__FUNCTION__);
} else {
OMX_BUFFERHEADERTYPE* bh = it->buf;
bh->nFlags = flags;
bh->nOffset = 0;
bh->nFilledLen = end - beg;
memcpy(bh->pBuffer, beg, bh->nFilledLen);
// OMX_BUFFERFLAG_CODECCONFIG OMX_BUFFERFLAG_ENDOFFRAME OMX_BUFFERFLAG_DECODEONLY
it->flags |= MSK_USED;
OMX_ERRORTYPE err = OMX_EmptyThisBuffer(component, bh);
ERR_EXIT_IF(err!=OMX_ErrorNone, "OMX_EmptyThisBuffer %d", int(err));
printf("%s: P0[%d] len %u\n",__FUNCTION__, INDEX(it), bh->nFilledLen);
}
return it;
}
static u32 omx_push(void* frame, u32 samples, bool wait)
{
if(audio_buffers == NULL)
return 1;
size_t data_size = samples * 4;
while(data_size > 0)
{
size_t copy_size = std::min(buffer_size, data_size);
// Don't have more than maximum audio latency
u32 latency = omx_get_latency();
if(latency > latency_max)
{
usleep((latency - latency_max) * 1000);
}
else if(latency == 0)
{
fprintf(stderr, "OMX: underrun occurred\n");
}
memcpy(audio_buffers[audio_buffer_idx]->pBuffer + buffer_length, frame, copy_size);
buffer_length += copy_size;
// Flush buffer and swap
if(buffer_length >= buffer_size)
{
audio_buffers[audio_buffer_idx]->nOffset = 0;
audio_buffers[audio_buffer_idx]->nFilledLen = buffer_size;
OMX_ERRORTYPE error = OMX_EmptyThisBuffer(omx_handle, audio_buffers[audio_buffer_idx]);
if(error != OMX_ErrorNone)
fprintf(stderr, "OMX: failed to empty buffer[%u]. Error 0x%X\n", audio_buffer_idx, error);
audio_buffer_idx = (audio_buffer_idx + 1) % buffer_count;
buffer_length = 0;
}
data_size -= copy_size;
}
return 1;
}
void AnatomyOMXClient::excute() {
int nSize = 0;
OMX_BUFFERHEADERTYPE *pInputHeader = NULL;
OMX_BUFFERHEADERTYPE *pOutputHeader = NULL;
for(size_t i = 0; i < mBufferInfo.size(); i++) {
if( mBufferInfo[i].mPortIndex == kPortIndexInput ) {
pInputHeader = mBufferInfo[i].mBufferHeader;
read((char*)(pInputHeader->pBuffer), &nSize);
OMX_EmptyThisBuffer(mComponentHandle, pInputHeader);
removeOMXBufferInfo(kPortIndexInput, mBufferInfo[i].mBufferHeader);
}
if( mBufferInfo[i].mPortIndex == kPortIndexOutput ) {
pOutputHeader = mBufferInfo[i].mBufferHeader;
OMX_FillThisBuffer(mComponentHandle, pOutputHeader);
removeOMXBufferInfo(kPortIndexOutput, mBufferInfo[i].mBufferHeader);
}
}
}