// XXX: This function is here for backwards compatibility. Once the OMX
// implementations have been updated this can be removed and useGraphicBuffer2
// can be renamed to useGraphicBuffer.
status_t OMXNodeInstance::useGraphicBuffer(
OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer,
OMX::buffer_id *buffer) {
Mutex::Autolock autoLock(mLock);
// See if the newer version of the extension is present.
OMX_INDEXTYPE index;
if (OMX_GetExtensionIndex(
mHandle,
const_cast<OMX_STRING>("OMX.google.android.index.useAndroidNativeBuffer2"),
&index) == OMX_ErrorNone) {
return useGraphicBuffer2_l(portIndex, graphicBuffer, buffer);
}
OMX_STRING name = const_cast<OMX_STRING>(
"OMX.google.android.index.useAndroidNativeBuffer");
OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
if (err != OMX_ErrorNone) {
ALOGE("OMX_GetExtensionIndex %s failed", name);
return StatusFromOMXError(err);
}
BufferMeta *bufferMeta = new BufferMeta(graphicBuffer);
OMX_BUFFERHEADERTYPE *header;
OMX_VERSIONTYPE ver;
ver.s.nVersionMajor = 1;
ver.s.nVersionMinor = 0;
ver.s.nRevision = 0;
ver.s.nStep = 0;
UseAndroidNativeBufferParams params = {
sizeof(UseAndroidNativeBufferParams), ver, portIndex, bufferMeta,
&header, graphicBuffer,
};
err = OMX_SetParameter(mHandle, index, ¶ms);
if (err != OMX_ErrorNone) {
ALOGE("OMX_UseAndroidNativeBuffer failed with error %d (0x%08x)", err,
err);
delete bufferMeta;
bufferMeta = NULL;
*buffer = 0;
return UNKNOWN_ERROR;
}
CHECK_EQ(header->pAppPrivate, bufferMeta);
*buffer = header;
addActiveBuffer(portIndex, *buffer);
return OK;
}
status_t OMXNodeInstance::storeMetaDataInBuffers(
OMX_U32 portIndex,
OMX_BOOL enable) {
Mutex::Autolock autolock(mLock);
OMX_INDEXTYPE index;
OMX_STRING name = const_cast<OMX_STRING>(
"OMX.google.android.index.storeMetaDataInBuffers");
OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
if (err != OMX_ErrorNone) {
ALOGE("OMX_GetExtensionIndex %s failed", name);
return StatusFromOMXError(err);
}
StoreMetaDataInBuffersParams params;
memset(¶ms, 0, sizeof(params));
params.nSize = sizeof(params);
// Version: 1.0.0.0
params.nVersion.s.nVersionMajor = 1;
params.nPortIndex = portIndex;
params.bStoreMetaData = enable;
if ((err = OMX_SetParameter(mHandle, index, ¶ms)) != OMX_ErrorNone) {
ALOGE("OMX_SetParameter() failed for StoreMetaDataInBuffers: 0x%08x", err);
return UNKNOWN_ERROR;
}
return err;
}
status_t OMXNodeInstance::prepareForAdaptivePlayback(
OMX_U32 portIndex, OMX_BOOL enable, OMX_U32 maxFrameWidth,
OMX_U32 maxFrameHeight) {
Mutex::Autolock autolock(mLock);
OMX_INDEXTYPE index;
OMX_STRING name = const_cast<OMX_STRING>(
"OMX.google.android.index.prepareForAdaptivePlayback");
OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
if (err != OMX_ErrorNone) {
ALOGW_IF(enable, "OMX_GetExtensionIndex %s failed", name);
return StatusFromOMXError(err);
}
PrepareForAdaptivePlaybackParams params;
params.nSize = sizeof(params);
params.nVersion.s.nVersionMajor = 1;
params.nVersion.s.nVersionMinor = 0;
params.nVersion.s.nRevision = 0;
params.nVersion.s.nStep = 0;
params.nPortIndex = portIndex;
params.bEnable = enable;
params.nMaxFrameWidth = maxFrameWidth;
params.nMaxFrameHeight = maxFrameHeight;
if ((err = OMX_SetParameter(mHandle, index, ¶ms)) != OMX_ErrorNone) {
ALOGW("OMX_SetParameter failed for PrepareForAdaptivePlayback "
"with error %d (0x%08x)", err, err);
return UNKNOWN_ERROR;
}
return err;
}
status_t OMXNodeInstance::getExtensionIndex(
const char *parameterName, OMX_INDEXTYPE *index) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_GetExtensionIndex(
mHandle, const_cast<char *>(parameterName), index);
return StatusFromOMXError(err);
}
OMX_ERRORTYPE omxil_comp::GetExtensionIndex(OMX_STRING cParameterName, OMX_INDEXTYPE *pIndexType) const
{
OMX_ERRORTYPE result;
result = OMX_GetExtensionIndex(comp, cParameterName, pIndexType);
if (result != OMX_ErrorNone) {
fprintf(stderr, "OMX_GetExtensionIndex failed.\n");
}
return result;
}
OMX_ERRORTYPE EnableDataFlow::setAutoRotate(OMX_BOOL aEnaleAutoRotate)
{
DBGT_PROLOG("aEnaleAutoRotate: %d", aEnaleAutoRotate);
DBGT_ASSERT(NULL != mArmIvProc, "mArmIvProc is NULL");
DBGT_ASSERT(1 == mParamArmIvOutput.nPortIndex, "mParamArmIvOutput.nPortIndex is invalid");
OMX_ERRORTYPE err = OMX_ErrorNone;
OMX_INDEXTYPE index;
OmxUtils::StructContainer<OMX_SYMBIAN_CONFIG_BOOLEANTYPE> autoRotate;
err = OMX_GetExtensionIndex(mArmIvProc, (char *)OMX_SYMBIAN_INDEX_CONFIG_COMMON_AUTOROTATIONCONTROL_NAME, &index);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Still Auto Rotation OMX_GetExtensionIndex failed err = %d", err);
DBGT_EPILOG("");
return err;
}
autoRotate.ptr()->nPortIndex = mParamArmIvOutput.nPortIndex;
err = OMX_GetConfig(mArmIvProc, index, autoRotate.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Auto Rotation OMX_GetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
autoRotate.ptr()->bEnabled = aEnaleAutoRotate;
err = OMX_SetConfig(mArmIvProc, index, autoRotate.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Auto Rotation OMX_SetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE ImageRotHandler::setAutoRotate(OMX_HANDLETYPE aHandle, int aPort, OMX_BOOL aEnaleAutoRotate)
{
DBGT_PROLOG("aHandle: %p aPort: %d aEnaleAutoRotate: %d", aHandle, aPort, aEnaleAutoRotate);
DBGT_ASSERT(NULL != aHandle, "aHandle is NULL");
OMX_ERRORTYPE err = OMX_ErrorNone;
OMX_INDEXTYPE index;
OmxUtils::StructContainer<OMX_SYMBIAN_CONFIG_BOOLEANTYPE> autoRotate;
err = OMX_GetExtensionIndex(aHandle, (char *)OMX_SYMBIAN_INDEX_CONFIG_COMMON_AUTOROTATIONCONTROL_NAME, &index);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Still Auto Rotation OMX_GetExtensionIndex failed err = %d", err);
DBGT_EPILOG("");
return err;
}
autoRotate.ptr()->nPortIndex = aPort;
err = OMX_GetConfig(aHandle, index, autoRotate.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Auto Rotation OMX_GetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
autoRotate.ptr()->bEnabled = aEnaleAutoRotate;
err = OMX_SetConfig(aHandle, index, autoRotate.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Auto Rotation OMX_SetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
status_t OMXNodeInstance::getGraphicBufferUsage(
OMX_U32 portIndex, OMX_U32* usage) {
Mutex::Autolock autoLock(mLock);
OMX_INDEXTYPE index;
OMX_ERRORTYPE err = OMX_GetExtensionIndex(
mHandle,
const_cast<OMX_STRING>(
"OMX.google.android.index.getAndroidNativeBufferUsage"),
&index);
if (err != OMX_ErrorNone) {
ALOGE("OMX_GetExtensionIndex failed");
return StatusFromOMXError(err);
}
OMX_VERSIONTYPE ver;
ver.s.nVersionMajor = 1;
ver.s.nVersionMinor = 0;
ver.s.nRevision = 0;
ver.s.nStep = 0;
GetAndroidNativeBufferUsageParams params = {
sizeof(GetAndroidNativeBufferUsageParams), ver, portIndex, 0,
};
err = OMX_GetParameter(mHandle, index, ¶ms);
if (err != OMX_ErrorNone) {
ALOGE("OMX_GetAndroidNativeBufferUsage failed with error %d (0x%08x)",
err, err);
return UNKNOWN_ERROR;
}
*usage = params.nUsage;
return OK;
}
status_t OMXNodeInstance::enableGraphicBuffers(
OMX_U32 portIndex, OMX_BOOL enable) {
Mutex::Autolock autoLock(mLock);
OMX_STRING name = const_cast<OMX_STRING>(
"OMX.google.android.index.enableAndroidNativeBuffers");
OMX_INDEXTYPE index;
OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
if (err != OMX_ErrorNone) {
if (enable) {
ALOGE("OMX_GetExtensionIndex %s failed", name);
}
return StatusFromOMXError(err);
}
OMX_VERSIONTYPE ver;
ver.s.nVersionMajor = 1;
ver.s.nVersionMinor = 0;
ver.s.nRevision = 0;
ver.s.nStep = 0;
EnableAndroidNativeBuffersParams params = {
sizeof(EnableAndroidNativeBuffersParams), ver, portIndex, enable,
};
err = OMX_SetParameter(mHandle, index, ¶ms);
if (err != OMX_ErrorNone) {
ALOGE("OMX_EnableAndroidNativeBuffers failed with error %d (0x%08x)",
err, err);
return UNKNOWN_ERROR;
}
return OK;
}
static void
goo_ti_sparkdec_validate_ports_definitions (GooComponent* component)
{
g_assert (GOO_IS_TI_SPARKDEC (component));
GooTiSparkDec* self = GOO_TI_SPARKDEC (component);
g_assert (component->cur_state == OMX_StateLoaded);
OMX_INDEXTYPE index;
GOO_RUN (
OMX_GetExtensionIndex (component->handle,
"OMX.TI.VideoDecode.Param.IsSparkInput",
&index)
);
GOO_RUN (
OMX_SetParameter (component->handle,
index, &self->bIsSparkInput)
);
GOO_OBJECT_DEBUG (self, "is_spark_input = %d", self->bIsSparkInput);
OMX_PARAM_PORTDEFINITIONTYPE *param;
GOO_OBJECT_DEBUG (self, "Entering");
{ /* input */
GooIterator* iter =
goo_component_iterate_input_ports (component);
goo_iterator_nth (iter, 0);
GooPort* port = GOO_PORT (goo_iterator_get_current (iter));
g_assert (port != NULL);
param = GOO_PORT_GET_DEFINITION (port);
param->format.video.cMIMEType = "SPARK";
param->format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
param->format.video.bFlagErrorConcealment = OMX_FALSE;
switch (param->format.video.eColorFormat)
{
case OMX_COLOR_FormatCbYCrY:
param->nBufferSize =
param->format.video.nFrameWidth *
param->format.video.nFrameHeight * 2;
break;
case OMX_COLOR_FormatYUV420Planar:
param->nBufferSize =
(param->format.video.nFrameWidth *
param->format.video.nFrameHeight) * 1.5;
break;
default:
GOO_OBJECT_ERROR (self, "Not valid color format");
g_assert (FALSE);
break;
}
param->format.video.eColorFormat = OMX_VIDEO_CodingUnused;
GOO_OBJECT_DEBUG (self, " Input port nFrameWidth : %d nFrameHeight : %d",
param->format.video.nFrameWidth,
param->format.video.nFrameHeight);
g_object_unref (iter);
g_object_unref (port);
}
/* 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);
param = GOO_PORT_GET_DEFINITION (port);
param->format.video.cMIMEType = "video/x-raw-yuv";
param->format.video.pNativeRender = NULL;
param->format.video.bFlagErrorConcealment = OMX_FALSE;
param->format.video.eCompressionFormat =OMX_VIDEO_CodingUnused;
switch (param->format.video.eColorFormat)
{
case OMX_COLOR_FormatCbYCrY:
param->nBufferSize =
param->format.video.nFrameWidth *
param->format.video.nFrameHeight * 2;
break;
case OMX_COLOR_FormatYUV420Planar:
param->nBufferSize =
(param->format.video.nFrameWidth *
param->format.video.nFrameHeight) * 1.5;
break;
default:
GOO_OBJECT_ERROR (self, "Not valid color format");
g_assert (FALSE);
break;
}
GOO_OBJECT_DEBUG (self, "Output port nFrameWidth : %d nFrameHeight : %d",
param->format.video.nFrameWidth,
param->format.video.nFrameHeight);
g_object_unref (iter);
g_object_unref (port);
}
GOO_OBJECT_DEBUG (self, "Exit");
return;
}
static int init()
{
OMX_ERRORTYPE err;
OMX_PARAM_PORTDEFINITIONTYPE paramPort;
err = OMX_Init();
printf("om init %d\n", err);
if (err != OMX_ErrorNone) {
return 0;
}
sem_init(&wait_for_state, 0, 0);
sem_init(&wait_for_parameters, 0, 0);
sem_init(&buffer_out_filled, 0, 0);
err = OMX_GetHandle(&decoderhandle, COMPONENT, NULL, &decodercallbacks);
OMXE(err);
// set filepath
NVX_PARAM_FILENAME filename;
OMX_INDEXTYPE filename_idx;
err=OMX_GetExtensionIndex(decoderhandle, FILENAME, &filename_idx);
OMXE(err);
printf("filename: %d\n");
setHeader(&filename, sizeof(filename));
filename.pFilename = "test.mp4";
err=OMX_SetParameter(decoderhandle, filename_idx, &filename);
OMXE(err);
err = OMX_SendCommand(decoderhandle, OMX_CommandPortDisable, 1, 0);
OMXE(err);
setHeader(¶mPort, sizeof(paramPort));
paramPort.nPortIndex = 0;
err=OMX_GetParameter(decoderhandle, OMX_IndexParamPortDefinition, ¶mPort);
OMXE(err);
#ifdef DEBUG
printf("Codec=%d\n", paramPort.format.video.eCompressionFormat);
printf("Color=%d\n", paramPort.format.video.eColorFormat);
printf("Size=%dx%d\n", paramPort.format.video.nFrameWidth,
paramPort.format.video.nFrameHeight);
printf("Rate=%d\n", paramPort.format.video.xFramerate);
printf("Requesting %d buffers of %d bytes\n", paramPort.nBufferCountMin, paramPort.nBufferSize);
#endif
int i;
for(i=0; i<paramPort.nBufferCountMin; ++i) {
err = OMX_AllocateBuffer(decoderhandle, &omx_buffers_out[i], 0, NULL, paramPort.nBufferSize);
OMXE(err);
#ifdef DEBUG
printf("buf_out[%d]=%p\n", i, omx_buffers_out[i]);
#endif
}
buffer_out_nb = paramPort.nBufferCountMin;
buffer_out_ap = buffer_out_nb;
buffer_out_avp = 0;
buffer_out_pos=0;
buffer_out_size=paramPort.nBufferSize;
printf("idle\n");
GoToState(OMX_StateIdle);
printf("go executing\n");
GoToState(OMX_StateExecuting);
return 1;
}
bool JpegEncoder::StartFromLoadedState(unsigned char* pExifBuf, int ExifSize, int ThumbWidth, int ThumbHeight)
{
int nRetval;
int nIndex1;
int nIndex2;
int bitsPerPixel;
int nMultFactor = 0;
int nHeightNew, nWidthNew;
char strTIJpegEnc[] = "OMX.TI.JPEG.encoder";
char strQFactor[] = "OMX.TI.JPEG.encoder.Config.QFactor";
char strColorFormat[] = "OMX.TI.JPEG.encoder.Config.ColorFormatConvertion_420pTo422i";
char strPPLibEnable[] = "OMX.TI.JPEG.encoder.Config.PPLibEnable";
OMX_S32 nCompId = 300;
OMX_PORT_PARAM_TYPE PortType;
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_IMAGE_PARAM_QFACTORTYPE QfactorType;
OMX_BOOL b420pTo422i;
OMX_BOOL bPPLibEnable;
OMX_INDEXTYPE nCustomIndex = OMX_IndexMax;
OMX_CALLBACKTYPE JPEGCallBack ={OMX_JPEGE_EventHandler, OMX_JPEGE_EmptyBufferDone, OMX_JPEGE_FillBufferDone};
//[20100110 Ratnesh EXIF Inclusion
IMAGE_INFO* imageinfo = NULL;
imageinfo = (IMAGE_INFO*)malloc(sizeof(IMAGE_INFO));
memset((void *)imageinfo, 0, sizeof(IMAGE_INFO));
imageinfo->nThumbnailWidth_app1 = ThumbWidth;
imageinfo->nThumbnailHeight_app1 = ThumbHeight;
imageinfo->bAPP1 = OMX_TRUE;
imageinfo->nComment = OMX_TRUE;
imageinfo->pCommentString = "hello";
//]
eError = TIOMX_Init();
if ( eError != OMX_ErrorNone ) {
PRINTF("\n%d :: Error returned by OMX_Init()\n",__LINE__);
goto EXIT;
}
/* Load the JPEGEncoder Component */
PRINTF("\nCalling OMX_GetHandle\n");
eError = TIOMX_GetHandle(&pOMXHandle, strTIJpegEnc, (void *)this, &JPEGCallBack);
if ( (eError != OMX_ErrorNone) || (pOMXHandle == NULL) ) {
PRINTF ("Error in Get Handle function\n");
goto EXIT;
}
eError = OMX_GetParameter(pOMXHandle, OMX_IndexParamImageInit, &PortType);
if ( eError != OMX_ErrorNone ) {
goto EXIT;
}
nIndex1 = PortType.nStartPortNumber;
nIndex2 = nIndex1 + 1;
/**********************************************************************/
/* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (INPUT) */
/**********************************************************************/
InPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
InPortDef.nPortIndex = PortType.nStartPortNumber;
eError = OMX_GetParameter (pOMXHandle, OMX_IndexParamPortDefinition, &InPortDef);
if ( eError != OMX_ErrorNone ) {
eError = OMX_ErrorBadParameter;
goto EXIT;
}
InPortDef.nVersion.s.nVersionMajor = 0x1;
InPortDef.nVersion.s.nVersionMinor = 0x0;
InPortDef.nVersion.s.nRevision = 0x0;
InPortDef.nVersion.s.nStep = 0x0;
InPortDef.eDir = OMX_DirInput;
InPortDef.nBufferCountActual =1;
InPortDef.nBufferCountMin = 1;
InPortDef.bEnabled = OMX_TRUE;
InPortDef.bPopulated = OMX_FALSE;
InPortDef.eDomain = OMX_PortDomainImage;
InPortDef.format.image.pNativeRender = NULL;
InPortDef.format.image.nFrameWidth = mWidth;
InPortDef.format.image.nFrameHeight = mHeight;
InPortDef.format.image.nStride = -1;
InPortDef.format.image.nSliceHeight = -1;
InPortDef.format.image.bFlagErrorConcealment = OMX_FALSE;
InPortDef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
InPortDef.nBufferSize = mInBuffSize;
if(mIsPixelFmt420p){
InPortDef.format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
}
else{
InPortDef.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY;
}
if (InPortDef.eDir == nIndex1 ) {
InPortDef.nPortIndex = nIndex1;
}
else {
InPortDef.nPortIndex = nIndex2;
}
PRINTF("\nCalling OMX_SetParameter for input port \n");
eError = OMX_SetParameter (pOMXHandle, OMX_IndexParamPortDefinition, &InPortDef);
if ( eError != OMX_ErrorNone ) {
eError = OMX_ErrorBadParameter;
goto EXIT;
}
/***********************************************************************/
/* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (OUTPUT) */
/***********************************************************************/
PortType.nStartPortNumber++;
OutPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
OutPortDef.nPortIndex = PortType.nStartPortNumber;
eError = OMX_GetParameter (pOMXHandle, OMX_IndexParamPortDefinition, &OutPortDef);
if ( eError != OMX_ErrorNone ) {
eError = OMX_ErrorBadParameter;
goto EXIT;
}
OutPortDef.nVersion.s.nVersionMajor = 0x1;
OutPortDef.nVersion.s.nVersionMinor = 0x0;
OutPortDef.nVersion.s.nRevision = 0x0;
OutPortDef.nVersion.s.nStep = 0x0;
OutPortDef.eDir = OMX_DirOutput;
OutPortDef.nBufferCountActual = 1;
OutPortDef.nBufferCountMin = 1;
OutPortDef.bEnabled = OMX_TRUE;
OutPortDef.bPopulated = OMX_FALSE;
OutPortDef.eDomain = OMX_PortDomainImage;
OutPortDef.format.image.pNativeRender = NULL;
OutPortDef.format.image.nFrameWidth = mWidth;
OutPortDef.format.image.nFrameHeight = mHeight;
OutPortDef.format.image.nStride = -1;
OutPortDef.format.image.nSliceHeight = -1;
OutPortDef.format.image.bFlagErrorConcealment = OMX_FALSE;
OutPortDef.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
if(mIsPixelFmt420p){
OutPortDef.format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
}
else{
OutPortDef.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY;
}
OutPortDef.nBufferSize = mOutBuffSize;
if (OutPortDef.eDir == nIndex1 ) {
OutPortDef.nPortIndex = nIndex1;
}
else {
OutPortDef.nPortIndex = nIndex2;
}
eError = OMX_SetParameter (pOMXHandle, OMX_IndexParamPortDefinition, &OutPortDef);
if ( eError != OMX_ErrorNone ) {
eError = OMX_ErrorBadParameter;
goto EXIT;
}
if(mIsPixelFmt420p){
b420pTo422i = OMX_TRUE;
eError = OMX_GetExtensionIndex(pOMXHandle, strColorFormat, (OMX_INDEXTYPE*)&nCustomIndex);
if ( eError != OMX_ErrorNone ) {
PRINTF("%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
eError = OMX_SetConfig (pOMXHandle, nCustomIndex, &b420pTo422i);
if ( eError != OMX_ErrorNone ) {
PRINTF("%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
}
bPPLibEnable = OMX_TRUE;
eError = OMX_GetExtensionIndex(pOMXHandle, strPPLibEnable, (OMX_INDEXTYPE*)&nCustomIndex);
if ( eError != OMX_ErrorNone ) {
PRINTF("%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
eError = OMX_SetConfig (pOMXHandle, nCustomIndex, &bPPLibEnable);
if ( eError != OMX_ErrorNone ) {
PRINTF("%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
eError = OMX_UseBuffer(pOMXHandle, &pInBuffHead, InPortDef.nPortIndex, (void *)&nCompId, InPortDef.nBufferSize, (OMX_U8*)mInputBuffer);
if ( eError != OMX_ErrorNone ) {
PRINTF ("JPEGEnc test:: %d:error= %x\n", __LINE__, eError);
goto EXIT;
}
eError = OMX_UseBuffer(pOMXHandle, &pOutBuffHead, OutPortDef.nPortIndex, (void *)&nCompId, OutPortDef.nBufferSize, (OMX_U8*)mOutputBuffer);
if ( eError != OMX_ErrorNone ) {
PRINTF ("JPEGEnc test:: %d:error= %x\n", __LINE__, eError);
goto EXIT;
}
//[20100110 Ratnesh EXIF Inclusion
if (imageinfo->bAPP1) {
JPEG_APPTHUMB_MARKER sAPP1;
sAPP1.bMarkerEnabled = OMX_TRUE;
/* set JFIF marker buffer */
sAPP1.nThumbnailWidth = imageinfo->nThumbnailWidth_app1;
sAPP1.nThumbnailHeight = imageinfo->nThumbnailHeight_app1;
sAPP1.nMarkerSize = ExifSize + 4;
sAPP1.pMarkerBuffer = (OMX_U8*)pExifBuf;
eError = OMX_GetExtensionIndex(pOMXHandle, "OMX.TI.JPEG.encoder.Config.APP1", (OMX_INDEXTYPE*)&nCustomIndex);
if ( eError != OMX_ErrorNone ) {
printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
eError = OMX_ErrorUndefined;
goto EXIT;
}
eError = OMX_SetConfig(pOMXHandle, nCustomIndex, &sAPP1);
if ( eError != OMX_ErrorNone ) {
printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
eError = OMX_ErrorUndefined;
goto EXIT;
}
}
/* set comment marker */
if (imageinfo->nComment) {
eError = OMX_GetExtensionIndex(pOMXHandle, "OMX.TI.JPEG.encoder.Config.CommentFlag", (OMX_INDEXTYPE*)&nCustomIndex);
if ( eError != OMX_ErrorNone ) {
printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
eError = OMX_ErrorUndefined;
goto EXIT;
}
eError = OMX_SetConfig(pOMXHandle, nCustomIndex, &(imageinfo->nComment));
if ( eError != OMX_ErrorNone ) {
printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
eError = OMX_ErrorUndefined;
goto EXIT;
}
eError = OMX_GetExtensionIndex(pOMXHandle, "OMX.TI.JPEG.encoder.Config.CommentString", (OMX_INDEXTYPE*)&nCustomIndex);
if ( eError != OMX_ErrorNone ) {
printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
eError = OMX_ErrorUndefined;
goto EXIT;
}
eError = OMX_SetConfig(pOMXHandle, nCustomIndex, imageinfo->pCommentString);
if ( eError != OMX_ErrorNone ) {
printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
eError = OMX_ErrorUndefined;
goto EXIT;
}
}
//]
pInBuffHead->nFilledLen = pInBuffHead->nAllocLen;
eError = OMX_SendCommand(pOMXHandle, OMX_CommandStateSet, OMX_StateIdle ,NULL);
if ( eError != OMX_ErrorNone ) {
PRINTF ("Error from SendCommand-Idle(Init) State function\n");
goto EXIT;
}
QfactorType.nSize = sizeof(OMX_IMAGE_PARAM_QFACTORTYPE);
QfactorType.nQFactor = (OMX_U32) mQuality;
QfactorType.nVersion.s.nVersionMajor = 0x1;
QfactorType.nVersion.s.nVersionMinor = 0x0;
QfactorType.nVersion.s.nRevision = 0x0;
QfactorType.nVersion.s.nStep = 0x0;
QfactorType.nPortIndex = 0x0;
eError = OMX_GetExtensionIndex(pOMXHandle, strQFactor, (OMX_INDEXTYPE*)&nCustomIndex);
if ( eError != OMX_ErrorNone ) {
PRINTF("\n%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
eError = OMX_SetConfig (pOMXHandle, nCustomIndex, &QfactorType);
if ( eError != OMX_ErrorNone ) {
PRINTF("\n%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
Run();
if (imageinfo != NULL)
{
LOGD("imageinfo memory deallocation before exit");
free(imageinfo);
imageinfo = NULL;
}
return true;
EXIT:
if (imageinfo != NULL)
{
LOGD("imageinfo memory deallocation before exit");
free(imageinfo);
imageinfo = NULL;
}
eError = TIOMX_Deinit();
if ( eError != OMX_ErrorNone ) {
PRINTF("\nError returned by TIOMX_Deinit()\n");
}
return false;
}
bool JpegEncoder::StartFromLoadedState()
{
int nRetval;
int nIndex1;
int nIndex2;
int bitsPerPixel;
int nMultFactor = 0;
int nHeightNew, nWidthNew;
char strTIJpegEnc[] = "OMX.TI.JPEG.encoder";
char strQFactor[] = "OMX.TI.JPEG.encoder.Config.QFactor";
char strColorFormat[] = "OMX.TI.JPEG.encoder.Config.ColorFormatConvertion_420pTo422i";
char strPPLibEnable[] = "OMX.TI.JPEG.encoder.Config.PPLibEnable";
OMX_S32 nCompId = 300;
OMX_PORT_PARAM_TYPE PortType;
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_IMAGE_PARAM_QFACTORTYPE QfactorType;
OMX_BOOL b420pTo422i;
OMX_BOOL bPPLibEnable;
OMX_INDEXTYPE nCustomIndex = OMX_IndexMax;
OMX_CALLBACKTYPE JPEGCallBack ={OMX_JPEGE_EventHandler, OMX_JPEGE_EmptyBufferDone, OMX_JPEGE_FillBufferDone};
eError = TIOMX_Init();
if ( eError != OMX_ErrorNone ) {
PRINTF("\n%d :: Error returned by OMX_Init()\n",__LINE__);
goto EXIT;
}
/* Load the JPEGEncoder Component */
PRINTF("\nCalling OMX_GetHandle\n");
eError = TIOMX_GetHandle(&pOMXHandle, strTIJpegEnc, (void *)this, &JPEGCallBack);
if ( (eError != OMX_ErrorNone) || (pOMXHandle == NULL) ) {
PRINTF ("Error in Get Handle function\n");
goto EXIT;
}
eError = OMX_GetParameter(pOMXHandle, OMX_IndexParamImageInit, &PortType);
if ( eError != OMX_ErrorNone ) {
goto EXIT;
}
nIndex1 = PortType.nStartPortNumber;
nIndex2 = nIndex1 + 1;
/**********************************************************************/
/* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (INPUT) */
/**********************************************************************/
InPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
InPortDef.nPortIndex = PortType.nStartPortNumber;
eError = OMX_GetParameter (pOMXHandle, OMX_IndexParamPortDefinition, &InPortDef);
if ( eError != OMX_ErrorNone ) {
eError = OMX_ErrorBadParameter;
goto EXIT;
}
InPortDef.nVersion.s.nVersionMajor = 0x1;
InPortDef.nVersion.s.nVersionMinor = 0x0;
InPortDef.nVersion.s.nRevision = 0x0;
InPortDef.nVersion.s.nStep = 0x0;
InPortDef.eDir = OMX_DirInput;
InPortDef.nBufferCountActual =1;
InPortDef.nBufferCountMin = 1;
InPortDef.bEnabled = OMX_TRUE;
InPortDef.bPopulated = OMX_FALSE;
InPortDef.eDomain = OMX_PortDomainImage;
InPortDef.format.image.pNativeRender = NULL;
InPortDef.format.image.nFrameWidth = mWidth;
InPortDef.format.image.nFrameHeight = mHeight;
InPortDef.format.image.nStride = -1;
InPortDef.format.image.nSliceHeight = -1;
InPortDef.format.image.bFlagErrorConcealment = OMX_FALSE;
InPortDef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
InPortDef.nBufferSize = mInBuffSize;
if(mIsPixelFmt420p){
InPortDef.format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
}
else{
InPortDef.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY;
}
if (InPortDef.eDir == nIndex1 ) {
InPortDef.nPortIndex = nIndex1;
}
else {
InPortDef.nPortIndex = nIndex2;
}
PRINTF("\nCalling OMX_SetParameter\n");
eError = OMX_SetParameter (pOMXHandle, OMX_IndexParamPortDefinition, &InPortDef);
if ( eError != OMX_ErrorNone ) {
eError = OMX_ErrorBadParameter;
goto EXIT;
}
/***********************************************************************/
/* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (OUTPUT) */
/***********************************************************************/
PortType.nStartPortNumber++;
OutPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
OutPortDef.nPortIndex = PortType.nStartPortNumber;
eError = OMX_GetParameter (pOMXHandle, OMX_IndexParamPortDefinition, &OutPortDef);
if ( eError != OMX_ErrorNone ) {
eError = OMX_ErrorBadParameter;
goto EXIT;
}
OutPortDef.nVersion.s.nVersionMajor = 0x1;
OutPortDef.nVersion.s.nVersionMinor = 0x0;
OutPortDef.nVersion.s.nRevision = 0x0;
OutPortDef.nVersion.s.nStep = 0x0;
OutPortDef.eDir = OMX_DirOutput;
OutPortDef.nBufferCountActual = 1;
OutPortDef.nBufferCountMin = 1;
OutPortDef.bEnabled = OMX_TRUE;
OutPortDef.bPopulated = OMX_FALSE;
OutPortDef.eDomain = OMX_PortDomainImage;
OutPortDef.format.image.pNativeRender = NULL;
OutPortDef.format.image.nFrameWidth = mWidth;
OutPortDef.format.image.nFrameHeight = mHeight;
OutPortDef.format.image.nStride = -1;
OutPortDef.format.image.nSliceHeight = -1;
OutPortDef.format.image.bFlagErrorConcealment = OMX_FALSE;
OutPortDef.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
if(mIsPixelFmt420p){
OutPortDef.format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
}
else{
OutPortDef.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY;
}
OutPortDef.nBufferSize = mOutBuffSize;
if (OutPortDef.eDir == nIndex1 ) {
OutPortDef.nPortIndex = nIndex1;
}
else {
OutPortDef.nPortIndex = nIndex2;
}
eError = OMX_SetParameter (pOMXHandle, OMX_IndexParamPortDefinition, &OutPortDef);
if ( eError != OMX_ErrorNone ) {
eError = OMX_ErrorBadParameter;
goto EXIT;
}
QfactorType.nSize = sizeof(OMX_IMAGE_PARAM_QFACTORTYPE);
QfactorType.nQFactor = (OMX_U32) mQuality;
QfactorType.nVersion.s.nVersionMajor = 0x1;
QfactorType.nVersion.s.nVersionMinor = 0x0;
QfactorType.nVersion.s.nRevision = 0x0;
QfactorType.nVersion.s.nStep = 0x0;
QfactorType.nPortIndex = 0x0;
eError = OMX_GetExtensionIndex(pOMXHandle, strQFactor, (OMX_INDEXTYPE*)&nCustomIndex);
if ( eError != OMX_ErrorNone ) {
PRINTF("\n%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
eError = OMX_SetConfig (pOMXHandle, nCustomIndex, &QfactorType);
if ( eError != OMX_ErrorNone ) {
PRINTF("\n%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
if(mIsPixelFmt420p){
b420pTo422i = OMX_TRUE;
eError = OMX_GetExtensionIndex(pOMXHandle, strColorFormat, (OMX_INDEXTYPE*)&nCustomIndex);
if ( eError != OMX_ErrorNone ) {
PRINTF("%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
eError = OMX_SetConfig (pOMXHandle, nCustomIndex, &b420pTo422i);
if ( eError != OMX_ErrorNone ) {
PRINTF("%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
}
eError = OMX_SetConfig (pOMXHandle, nCustomIndex, &bPPLibEnable);
if ( eError != OMX_ErrorNone ) {
PRINTF("%d::APP_Error at function call: %x\n", __LINE__, eError);
goto EXIT;
}
eError = OMX_UseBuffer(pOMXHandle, &pInBuffHead, InPortDef.nPortIndex, (void *)&nCompId, InPortDef.nBufferSize, (OMX_U8*)mInputBuffer);
if ( eError != OMX_ErrorNone ) {
PRINTF ("JPEGEnc test:: %d:error= %x\n", __LINE__, eError);
goto EXIT;
}
eError = OMX_UseBuffer(pOMXHandle, &pOutBuffHead, OutPortDef.nPortIndex, (void *)&nCompId, OutPortDef.nBufferSize, (OMX_U8*)mOutputBuffer);
if ( eError != OMX_ErrorNone ) {
PRINTF ("JPEGEnc test:: %d:error= %x\n", __LINE__, eError);
goto EXIT;
}
pInBuffHead->nFilledLen = pInBuffHead->nAllocLen;
eError = OMX_SendCommand(pOMXHandle, OMX_CommandStateSet, OMX_StateIdle ,NULL);
if ( eError != OMX_ErrorNone ) {
PRINTF ("Error from SendCommand-Idle(Init) State function\n");
goto EXIT;
}
Run();
return true;
EXIT:
eError = TIOMX_Deinit();
if ( eError != OMX_ErrorNone ) {
PRINTF("\nError returned by TIOMX_Deinit()\n");
}
return false;
}
int Play_Decoder()
{
int i;
int Size=0;
DEBUG_PRINT("Inside %s \n", __FUNCTION__);
OMX_ERRORTYPE ret;
OMX_INDEXTYPE index;
DEBUG_PRINT("sizeof[%d]\n", sizeof(OMX_BUFFERHEADERTYPE));
/* open the i/p and o/p files based on the video file format passed */
if(open_audio_file()) {
DEBUG_PRINT("\n Returning -1");
return -1;
}
/* Configuration of Input Port definition */
/* Query the decoder input min buf requirements */
CONFIG_VERSION_SIZE(inputportFmt);
/* Port for which the Client needs to obtain info */
inputportFmt.nPortIndex = portParam.nStartPortNumber;
OMX_GetParameter(aac_dec_handle,OMX_IndexParamPortDefinition,&inputportFmt);
DEBUG_PRINT ("\nDec: Input Buffer Count %lu\n", inputportFmt.nBufferCountMin);
DEBUG_PRINT ("\nDec: Input Buffer Size %lu\n", inputportFmt.nBufferSize);
if(OMX_DirInput != inputportFmt.eDir) {
DEBUG_PRINT ("\nDec: Expect Input Port\n");
return -1;
}
inputportFmt.nBufferCountActual = inputportFmt.nBufferCountMin + 5;
OMX_SetParameter(aac_dec_handle,OMX_IndexParamPortDefinition,&inputportFmt);
OMX_GetExtensionIndex(aac_dec_handle,"OMX.Qualcomm.index.audio.sessionId",&index);
OMX_GetParameter(aac_dec_handle,index,&streaminfoparam);
#ifdef AUDIOV2
session_id = streaminfoparam.sessionId;
devmgr_fd = open("/data/omx_devmgr", O_WRONLY);
if(devmgr_fd >= 0)
{
control = 0;
write_devctlcmd(devmgr_fd, "-cmd=register_session_rx -sid=", session_id);
}
else
{
/*control = msm_mixer_open("/dev/snd/controlC0", 0);
if(control < 0)
printf("ERROR opening the device\n");
device_id = msm_get_device(device);
device_id = 2;
DEBUG_PRINT ("\ndevice_id = %d\n",device_id);
DEBUG_PRINT("\nsession_id = %d\n",session_id);
if (msm_en_device(device_id, 1))
{
perror("could not enable device\n");
return -1;
}
if (msm_route_stream(1,session_id,device_id, 1))
{
perror("could not set stream routing\n");
return -1;
}
*/
}
#endif
/* Configuration of Ouput Port definition */
/* Query the decoder outport's min buf requirements */
CONFIG_VERSION_SIZE(outputportFmt);
/* Port for which the Client needs to obtain info */
outputportFmt.nPortIndex = portParam.nStartPortNumber + 1;
OMX_GetParameter(aac_dec_handle,OMX_IndexParamPortDefinition,&outputportFmt);
DEBUG_PRINT ("\nDec: Output Buffer Count %lu\n", outputportFmt.nBufferCountMin);
DEBUG_PRINT ("\nDec: Output Buffer Size %lu\n", outputportFmt.nBufferSize);
if(OMX_DirOutput != outputportFmt.eDir) {
DEBUG_PRINT ("\nDec: Expect Output Port\n");
return -1;
}
outputportFmt.nBufferCountActual = outputportFmt.nBufferCountMin + 3;
OMX_SetParameter(aac_dec_handle,OMX_IndexParamPortDefinition,&outputportFmt);
CONFIG_VERSION_SIZE(aacparam);
aacparam.nPortIndex = 0;
aacparam.nChannels = channels; //2 ; /* 1-> mono 2-> stereo*/
aacparam.nBitRate = samplerate; //SAMPLE_RATE;
aacparam.nSampleRate = samplerate; //SAMPLE_RATE;
aacparam.eChannelMode = OMX_AUDIO_ChannelModeStereo;
if (sbr_ps_enabled == 0 )
aacparam.eAACProfile = OMX_AUDIO_AACObjectLC;
else if (sbr_ps_enabled == 1 )
aacparam.eAACProfile = OMX_AUDIO_AACObjectHE;
else if (sbr_ps_enabled == 2 )
aacparam.eAACProfile = OMX_AUDIO_AACObjectHE_PS;
aacparam.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP2ADTS;
OMX_SetParameter(aac_dec_handle,OMX_IndexParamAudioAac,&aacparam);
DEBUG_PRINT ("\nOMX_SendCommand Decoder -> IDLE\n");
OMX_SendCommand(aac_dec_handle, OMX_CommandStateSet, OMX_StateIdle,0);
/* wait_for_event(); should not wait here event complete status will
not come until enough buffer are allocated */
input_buf_cnt = inputportFmt.nBufferCountActual; // inputportFmt.nBufferCountMin + 5;
DEBUG_PRINT("Transition to Idle State succesful...\n");
/* Allocate buffer on decoder's i/p port */
error = Allocate_Buffer(aac_dec_handle, &pInputBufHdrs, inputportFmt.nPortIndex,
input_buf_cnt, inputportFmt.nBufferSize);
if (error != OMX_ErrorNone) {
DEBUG_PRINT ("\nOMX_AllocateBuffer Input buffer error\n");
return -1;
}
else {
DEBUG_PRINT ("\nOMX_AllocateBuffer Input buffer success\n");
}
output_buf_cnt = outputportFmt.nBufferCountActual; // outputportFmt.nBufferCountMin ;
/* Allocate buffer on decoder's O/Pp port */
error = Allocate_Buffer(aac_dec_handle, &pOutputBufHdrs, outputportFmt.nPortIndex,
output_buf_cnt, outputportFmt.nBufferSize);
if (error != OMX_ErrorNone) {
DEBUG_PRINT ("\nOMX_AllocateBuffer Output buffer error\n");
return -1;
}
else {
DEBUG_PRINT ("\nOMX_AllocateBuffer Output buffer success\n");
}
wait_for_event();
DEBUG_PRINT ("\nOMX_SendCommand Decoder -> Executing\n");
OMX_SendCommand(aac_dec_handle, OMX_CommandStateSet, OMX_StateExecuting,0);
wait_for_event();
DEBUG_PRINT(" Start sending OMX_FILLthisbuffer\n");
for(i=0; i < output_buf_cnt; i++) {
DEBUG_PRINT ("\nOMX_FillThisBuffer on output buf no.%d\n",i);
pOutputBufHdrs[i]->nOutputPortIndex = 1;
pOutputBufHdrs[i]->nFlags = 0;
ret = OMX_FillThisBuffer(aac_dec_handle, pOutputBufHdrs[i]);
if (OMX_ErrorNone != ret) {
DEBUG_PRINT("OMX_FillThisBuffer failed with result %d\n", ret);
}
else {
DEBUG_PRINT("OMX_FillThisBuffer success!\n");
}
}
DEBUG_PRINT(" Start sending OMX_emptythisbuffer\n");
for (i = 0;i < input_buf_cnt;i++) {
DEBUG_PRINT ("\nOMX_EmptyThisBuffer on Input buf no.%d\n",i);
pInputBufHdrs[i]->nInputPortIndex = 0;
Size = Read_Buffer(pInputBufHdrs[i]);
if(Size <=0 ){
DEBUG_PRINT("NO DATA READ\n");
//bInputEosReached = true;
bEosOnInputBuf = true;
pInputBufHdrs[i]->nFlags= OMX_BUFFERFLAG_EOS;
}
pInputBufHdrs[i]->nFilledLen = Size;
pInputBufHdrs[i]->nInputPortIndex = 0;
used_ip_buf_cnt++;
ret = OMX_EmptyThisBuffer(aac_dec_handle, pInputBufHdrs[i]);
if (OMX_ErrorNone != ret) {
DEBUG_PRINT("OMX_EmptyThisBuffer failed with result %d\n", ret);
}
else {
DEBUG_PRINT("OMX_EmptyThisBuffer success!\n");
}
if(Size <=0 ){
break;//eos reached
}
}
pthread_mutex_lock(&etb_lock);
if(etb_done)
{
DEBUG_PRINT("Component is waiting for EBD to be released.\n");
etb_event_complete();
}
else
{
DEBUG_PRINT("\n****************************\n");
DEBUG_PRINT("EBD not yet happened ...\n");
DEBUG_PRINT("\n****************************\n");
etb_done++;
}
pthread_mutex_unlock(&etb_lock);
while(1)
{
wait_for_event();
if(bOutputEosReached)
{
bReconfigureOutputPort = 0;
printf("bOutputEosReached breaking\n");
break;
}
else
{
if(bReconfigureOutputPort)
process_portreconfig();
}
}
return 0;
}
int main(int argc, char** argv) {
int argn_dec;
OMX_ERRORTYPE err;
OMX_INDEXTYPE eIndexParamFilename;
int gain=-1;
OMX_AUDIO_CONFIG_VOLUMETYPE sVolume;
OMX_TIME_CONFIG_TIMESTAMPTYPE sTimeStamp;
OMX_PARAM_COMPONENTROLETYPE sComponentRole;
char *stream_dir=NULL;
DIR *dirp;
struct dirent *dp;
int seek=1;
flagSetupTunnel = 1;
flagPlaybackOn = 1;
flagUsingFFMpeg = 1;
flagIsGain = 0;
if(argc <= 3) {
argn_dec = 1;
while (argn_dec<argc) {
if (*(argv[argn_dec]) =='-') {
switch (*(argv[argn_dec]+1)) {
case 's':
seek = 0;
break;
//case 't':
// flagSetupTunnel = 0;
// break;
default:
display_help();
}
} else {
stream_dir = malloc(strlen(argv[argn_dec]) * sizeof(char) + 1);
strcpy(stream_dir,argv[argn_dec]);
}
argn_dec++;
}
} else if(argc > 3) {
display_help();
}
if(stream_dir==NULL) {
stream_dir = malloc(strlen(getenv("HOME")) * sizeof(char) + 20);
memset(stream_dir, 0, sizeof(stream_dir));
strcat(stream_dir, getenv("HOME"));
strcat(stream_dir, "/stream/audio/");
}
DEBUG(DEFAULT_MESSAGES, "Directory Name=%s\n",stream_dir);
/* Populate the registry file */
dirp = opendir(stream_dir);
if(dirp == NULL){
int err = errno;
DEBUG(DEB_LEV_ERR, "Cannot open directory %s\n", stream_dir);
return err;
}
/** initializing appPriv structure */
appPriv = malloc(sizeof(appPrivateType));
appPriv->filereaderEventSem = malloc(sizeof(tsem_t));
appPriv->decoderEventSem = malloc(sizeof(tsem_t));
appPriv->eofSem = malloc(sizeof(tsem_t));
if (flagPlaybackOn) {
appPriv->sinkEventSem = malloc(sizeof(tsem_t));
tsem_init(appPriv->sinkEventSem, 0);
appPriv->volumeEventSem = malloc(sizeof(tsem_t));
tsem_init(appPriv->volumeEventSem, 0);
}
tsem_init(appPriv->filereaderEventSem, 0);
tsem_init(appPriv->decoderEventSem, 0);
tsem_init(appPriv->eofSem, 0);
/** initialising openmax */
err = OMX_Init();
if (err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "The OpenMAX core can not be initialized. Exiting...\n");
exit(1);
}
if(flagUsingFFMpeg) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Using File Reader\n");
/** file reader component name -- gethandle*/
err = OMX_GetHandle(&appPriv->filereaderhandle, FILE_READER, NULL , &filereadercallbacks);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "FileReader Component Not Found\n");
exit(1);
}
err = OMX_GetExtensionIndex(appPriv->filereaderhandle,"OMX.ST.index.param.inputfilename",&eIndexParamFilename);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"\n error in get extension index\n");
exit(1);
}
}
/** getting the handle of audio decoder */
err = OMX_GetHandle(&appPriv->audiodechandle, COMPONENT_NAME_BASE, NULL , &audiodeccallbacks);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Audio Decoder Component Not Found\n");
exit(1);
}
DEBUG(DEFAULT_MESSAGES, "Component %s opened\n", COMPONENT_NAME_BASE);
if (flagPlaybackOn) {
err = OMX_GetHandle(&appPriv->audiosinkhandle, SINK_NAME, NULL , &audiosinkcallbacks);
if(err != OMX_ErrorNone){
DEBUG(DEB_LEV_ERR, "No sink found. Exiting...\n");
exit(1);
}
DEBUG(DEFAULT_MESSAGES, "Getting Handle for Component %s\n", AUDIO_EFFECT);
err = OMX_GetHandle(&appPriv->volumehandle, AUDIO_EFFECT, NULL , &volumecallbacks);
if(err != OMX_ErrorNone){
DEBUG(DEB_LEV_ERR, "No sink found. Exiting...\n");
exit(1);
}
if((gain >= 0) && (gain <100)) {
err = OMX_GetConfig(appPriv->volumehandle, OMX_IndexConfigAudioVolume, &sVolume);
if(err!=OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"Error %08x In OMX_GetConfig 0 \n",err);
}
sVolume.sVolume.nValue = gain;
DEBUG(DEFAULT_MESSAGES, "Setting Gain %d \n", gain);
err = OMX_SetConfig(appPriv->volumehandle, OMX_IndexConfigAudioVolume, &sVolume);
if(err!=OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig 0 \n",err);
}
}
}
if (flagSetupTunnel) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Setting up Tunnel\n");
if(flagUsingFFMpeg) {
err = OMX_SetupTunnel(appPriv->filereaderhandle, 0, appPriv->audiodechandle, 0);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Set up Tunnel Failed\n");
exit(1);
}
}
err = OMX_SetupTunnel(appPriv->audiodechandle, 1, appPriv->volumehandle, 0);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Set up Tunnel Failed\n");
exit(1);
}
err = OMX_SetupTunnel(appPriv->volumehandle, 1, appPriv->audiosinkhandle, 0);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Set up Tunnel Failed\n");
exit(1);
}
DEBUG(DEB_LEV_SIMPLE_SEQ, "Set up Tunnel Completed\n");
}
if(flagUsingFFMpeg) {
/** now set the filereader component to idle and executing state */
OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
}
/*Send State Change Idle command to Audio Decoder*/
DEBUG(DEB_LEV_SIMPLE_SEQ, "Send Command Idle to Audio Dec\n");
err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
if (flagPlaybackOn) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Send Command Idle to Audio Sink\n");
err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
}
if(flagUsingFFMpeg) {
/*Wait for File reader state change to */
tsem_down(appPriv->filereaderEventSem);
DEBUG(DEFAULT_MESSAGES,"File reader idle state \n");
}
tsem_down(appPriv->decoderEventSem);
if (flagPlaybackOn) {
tsem_down(appPriv->volumeEventSem);
DEBUG(DEFAULT_MESSAGES,"volume state idle\n");
tsem_down(appPriv->sinkEventSem);
DEBUG(DEFAULT_MESSAGES,"audio sink state idle\n");
}
if (flagPlaybackOn) {
err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"volume state executing failed\n");
exit(1);
}
DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for volume state executing\n");
tsem_down(appPriv->volumeEventSem);
DEBUG(DEB_LEV_SIMPLE_SEQ,"sending audio sink state executing\n");
err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"audio sink state executing failed\n");
exit(1);
}
DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for audio sink state executing\n");
tsem_down(appPriv->sinkEventSem);
DEBUG(DEB_LEV_SIMPLE_SEQ, "audio sink state executing successful\n");
}
setHeader(&sComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
strcpy((char*)&sComponentRole.cRole[0], MP3_ROLE);
while((dp = readdir(dirp)) != NULL) {
int len = strlen(dp->d_name);
if(len >= 3){
if(strncmp(dp->d_name+len-4, ".mp3", 4) == 0){
if(input_file!=NULL) {
free(input_file);
input_file=NULL;
}
input_file = malloc(strlen(stream_dir) * sizeof(char) + sizeof(dp->d_name) +1);
strcpy(input_file,stream_dir);
strcat(input_file, dp->d_name);
DEBUG(DEFAULT_MESSAGES, "Input Mp3 File Name=%s\n",input_file);
flagUsingFFMpeg = 1;
strcpy((char*)&sComponentRole.cRole[0], MP3_ROLE);
} else if(strncmp(dp->d_name+len-4, ".ogg", 4) == 0){
if(input_file!=NULL) {
free(input_file);
input_file=NULL;
}
input_file = malloc(strlen(stream_dir) * sizeof(char) + sizeof(dp->d_name) +1);
strcpy(input_file,stream_dir);
strcat(input_file, dp->d_name);
DEBUG(DEFAULT_MESSAGES, "Input Vorbis File Name=%s\n",input_file);
flagUsingFFMpeg = 1;
strcpy((char*)&sComponentRole.cRole[0], VORBIS_ROLE);
} else if(strncmp(dp->d_name+len-4, ".aac", 4) == 0){
if(input_file!=NULL) {
free(input_file);
input_file=NULL;
}
input_file = malloc(strlen(stream_dir) * sizeof(char) + sizeof(dp->d_name) +1);
strcpy(input_file,stream_dir);
strcat(input_file, dp->d_name);
DEBUG(DEFAULT_MESSAGES, "Input AAC File Name=%s\n",input_file);
flagUsingFFMpeg = 1;
strcpy((char*)&sComponentRole.cRole[0], AAC_ROLE);
} else {
continue;
}
} else {
continue;
}
/*Reset Global Variables*/
tsem_reset(appPriv->eofSem);
bEOS=OMX_FALSE;
if (flagUsingFFMpeg) {
DEBUG(DEB_LEV_SIMPLE_SEQ,"Sending Port Disable Command State Idle\n");
/*Port Disable for filereader is sent from Port Settings Changed event of FileReader*/
err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandPortDisable, 0, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"file reader port disable failed\n");
exit(1);
}
err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandPortDisable, OMX_ALL, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"audio decoder port disable failed\n");
exit(1);
}
err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandPortDisable, 0, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"audio sink port disable failed\n");
exit(1);
}
DEBUG(DEB_LEV_SIMPLE_SEQ,"Waiting File reader Port Disable event \n");
/*Wait for File Reader Ports Disable Event*/
tsem_down(appPriv->filereaderEventSem);
DEBUG(DEB_LEV_SIMPLE_SEQ,"File reader Port Disable State Idle\n");
/*Wait for Audio Decoder Ports Disable Event*/
tsem_down(appPriv->decoderEventSem);
tsem_down(appPriv->decoderEventSem);
tsem_down(appPriv->volumeEventSem);
err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
tsem_down(appPriv->decoderEventSem);
}
DEBUG(DEB_LEV_SIMPLE_SEQ,"Setting Role\n");
err = OMX_SetParameter(appPriv->audiodechandle,OMX_IndexParamStandardComponentRole,&sComponentRole);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"\n error in input audio format - exiting\n");
exit(1);
}
if(flagUsingFFMpeg) {
/** setting the input audio format in file reader */
DEBUG(DEB_LEV_SIMPLE_SEQ,"FileName Param index : %x \n",eIndexParamFilename);
err = OMX_SetParameter(appPriv->filereaderhandle,eIndexParamFilename,input_file);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"\n error in input audio format - exiting\n");
exit(1);
}
}
if (flagUsingFFMpeg) {
DEBUG(DEB_LEV_SIMPLE_SEQ,"Sending Port Enable Command State Idle\n");
err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
tsem_down(appPriv->decoderEventSem);
err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandPortEnable, 0, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"file reader port enable failed\n");
exit(1);
}
err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandPortEnable, OMX_ALL, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"audio decoder port enable failed\n");
exit(1);
}
err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandPortEnable, 0, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"audio sink port enable failed\n");
exit(1);
}
DEBUG(DEB_LEV_SIMPLE_SEQ,"Waiting File reader Port Disable event \n");
/*Wait for File Reader Ports Disable Event*/
tsem_down(appPriv->filereaderEventSem);
DEBUG(DEB_LEV_SIMPLE_SEQ,"File reader Port Disable State Idle\n");
/*Wait for Audio Decoder Ports Disable Event*/
tsem_down(appPriv->decoderEventSem);
tsem_down(appPriv->decoderEventSem);
tsem_down(appPriv->volumeEventSem);
}
if(flagUsingFFMpeg) {
err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"file reader state executing failed\n");
exit(1);
}
/*Wait for File reader state change to executing*/
tsem_down(appPriv->filereaderEventSem);
DEBUG(DEFAULT_MESSAGES,"File reader executing state \n");
}
err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"audio decoder state executing failed\n");
exit(1);
}
DEBUG(DEB_LEV_SIMPLE_SEQ,"Waiting for audio dec state exec\n");
/*Wait for decoder state change to executing*/
tsem_down(appPriv->decoderEventSem);
DEBUG(DEB_LEV_SIMPLE_SEQ,"All Component state changed to Executing\n");
DEBUG(DEFAULT_MESSAGES,"Waiting for EOS = %d\n",appPriv->eofSem->semval);
if (seek==1) {
DEBUG(DEFAULT_MESSAGES,"Sleeping for 5 Secs \n");
/* Play for 5 Secs */
sleep(5);
DEBUG(DEFAULT_MESSAGES,"Sleep for 5 Secs is over\n");
/*Then Pause the filereader component*/
err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StatePause, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"file reader state executing failed\n");
exit(1);
}
/*Wait for File reader state change to Pause*/
tsem_down(appPriv->filereaderEventSem);
setHeader(&sTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
sTimeStamp.nPortIndex=0;
/*Seek to 30 secs and play for 10 secs*/
sTimeStamp.nTimestamp = 2351*38*30; // 23.51ms*38fps*30secs
//sTimeStamp.nTimestamp = 2351*38*60*3; // 23.51ms*38fps*60secs*4mins
DEBUG(DEFAULT_MESSAGES, "nTimestamp %llx \n", sTimeStamp.nTimestamp);
err = OMX_SetConfig(appPriv->filereaderhandle, OMX_IndexConfigTimePosition, &sTimeStamp);
if(err!=OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetParameter 0 \n",err);
}
err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"file reader state executing failed\n");
exit(1);
}
/*Wait for File reader state change to Pause*/
tsem_down(appPriv->filereaderEventSem);
DEBUG(DEFAULT_MESSAGES,"Sleeping for 10 Secs \n");
/*Play for 10 secs*/
sleep(10);
DEBUG(DEFAULT_MESSAGES,"Sleep for 10 Secs is over\n");
if(!bEOS) {
/*Then Pause the filereader component*/
err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StatePause, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"file reader state executing failed\n");
exit(1);
}
/*Wait for File reader state change to Pause*/
tsem_down(appPriv->filereaderEventSem);
/*Seek to 5 mins or EOF*/
sTimeStamp.nTimestamp = 2351*38*60*5; // 23.51ms*38fps*30secs
//sTimeStamp.nTimestamp = 2351*38*60*3; // 23.51ms*38fps*60secs*4mins
DEBUG(DEFAULT_MESSAGES, "nTimestamp %llx \n", sTimeStamp.nTimestamp);
err = OMX_SetConfig(appPriv->filereaderhandle, OMX_IndexConfigTimePosition, &sTimeStamp);
if(err!=OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetParameter 0 \n",err);
}
err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR,"file reader state executing failed\n");
exit(1);
}
/*Wait for File reader state change to Pause*/
tsem_down(appPriv->filereaderEventSem);
}
}
tsem_down(appPriv->eofSem);
DEBUG(DEFAULT_MESSAGES,"Received EOS \n");
/*Send Idle Command to all components*/
DEBUG(DEFAULT_MESSAGES, "The execution of the decoding process is terminated\n");
if(flagUsingFFMpeg) {
err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
}
err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(flagUsingFFMpeg) {
tsem_down(appPriv->filereaderEventSem);
DEBUG(DEFAULT_MESSAGES,"File reader idle state \n");
}
tsem_down(appPriv->decoderEventSem);
DEBUG(DEFAULT_MESSAGES, "All component Transitioned to Idle\n");
} /*Loop While Play List*/
if (flagPlaybackOn) {
err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
}
if (flagPlaybackOn) {
tsem_down(appPriv->volumeEventSem);
tsem_down(appPriv->sinkEventSem);
}
/*Send Loaded Command to all components*/
if(flagUsingFFMpeg) {
err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
}
err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
if (flagPlaybackOn) {
err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
}
DEBUG(DEFAULT_MESSAGES, "Audio dec to loaded\n");
if(flagUsingFFMpeg) {
tsem_down(appPriv->filereaderEventSem);
DEBUG(DEFAULT_MESSAGES,"File reader loaded state \n");
}
tsem_down(appPriv->decoderEventSem);
if (flagPlaybackOn) {
tsem_down(appPriv->volumeEventSem);
tsem_down(appPriv->sinkEventSem);
}
if(input_file!=NULL) {
free(input_file);
input_file=NULL;
}
closedir(dirp);
DEBUG(DEFAULT_MESSAGES, "All components released\n");
/** freeing all handles and deinit omx */
OMX_FreeHandle(appPriv->audiodechandle);
DEBUG(DEB_LEV_SIMPLE_SEQ, "audiodec dec freed\n");
if(flagUsingFFMpeg) {
OMX_FreeHandle(appPriv->filereaderhandle);
DEBUG(DEB_LEV_SIMPLE_SEQ, "filereader freed\n");
}
if (flagPlaybackOn) {
OMX_FreeHandle(appPriv->volumehandle);
DEBUG(DEB_LEV_SIMPLE_SEQ, "volume component freed\n");
OMX_FreeHandle(appPriv->audiosinkhandle);
DEBUG(DEB_LEV_SIMPLE_SEQ, "audiosink freed\n");
}
OMX_Deinit();
DEBUG(DEB_LEV_SIMPLE_SEQ, "All components freed. Closing...\n");
free(appPriv->filereaderEventSem);
appPriv->filereaderEventSem = NULL;
free(appPriv->decoderEventSem);
appPriv->decoderEventSem = NULL;
if (flagPlaybackOn) {
free(appPriv->volumeEventSem);
appPriv->volumeEventSem = NULL;
free(appPriv->sinkEventSem);
appPriv->sinkEventSem = NULL;
}
free(appPriv->eofSem);
appPriv->eofSem = NULL;
free(appPriv);
appPriv = NULL;
if(input_file) {
free(input_file);
}
return 0;
}
