static void
port_allocate_buffers (GOmxPort *port)
{
guint i;
gsize size;
size = port->buffer_size;
for (i = 0; i < port->num_buffers; i++)
{
if (port->omx_allocate)
{
GST_DEBUG_OBJECT (port->core->object, "%d: OMX_AllocateBuffer(), size=%"G_GSIZE_FORMAT, i, size);
OMX_AllocateBuffer (port->core->omx_handle,
&port->buffers[i],
port->port_index,
NULL,
size);
}
else
{
gpointer buffer_data;
buffer_data = g_malloc (size);
GST_DEBUG_OBJECT (port->core->object, "%d: OMX_UseBuffer(), size=%"G_GSIZE_FORMAT, i, size);
OMX_UseBuffer (port->core->omx_handle,
&port->buffers[i],
port->port_index,
NULL,
size,
buffer_data);
}
}
}
status_t OMXNodeInstance::useBuffer(
OMX_U32 portIndex, const sp<IMemory> ¶ms,
OMX::buffer_id *buffer) {
Mutex::Autolock autoLock(mLock);
BufferMeta *buffer_meta = new BufferMeta(params);
OMX_BUFFERHEADERTYPE *header;
OMX_ERRORTYPE err = OMX_UseBuffer(
mHandle, &header, portIndex, buffer_meta,
params->size(), static_cast<OMX_U8 *>(params->pointer()));
if (err != OMX_ErrorNone) {
ALOGE("OMX_UseBuffer failed with error %d (0x%08x)", err, err);
delete buffer_meta;
buffer_meta = NULL;
*buffer = 0;
return UNKNOWN_ERROR;
}
CHECK_EQ(header->pAppPrivate, buffer_meta);
*buffer = header;
addActiveBuffer(portIndex, *buffer);
return OK;
}
static OMX_BUFFERHEADERTYPE *allocbufs(OMX_HANDLETYPE h, int port, int enable)
{
int i;
OMX_BUFFERHEADERTYPE *list = NULL, **end = &list;
OMX_PARAM_PORTDEFINITIONTYPE *portdef;
MAKEME(portdef, OMX_PARAM_PORTDEFINITIONTYPE);
portdef->nPortIndex = port;
OERRq(OMX_GetParameter(h, OMX_IndexParamPortDefinition, portdef));
if (enable)
OERRq(OMX_SendCommand(h, OMX_CommandPortEnable, port, NULL));
for (i = 0; i < portdef->nBufferCountActual; i++) {
OMX_U8 *buf;
buf = vcos_malloc_aligned(portdef->nBufferSize,
portdef->nBufferAlignment, "buffer");
// printf("Allocated a buffer of %d bytes\n", portdef->nBufferSize);
OERRq(OMX_UseBuffer(h, end, port, NULL, portdef->nBufferSize,
buf));
end = (OMX_BUFFERHEADERTYPE **) &((*end)->pAppPrivate);
}
free(portdef);
return list;
}
/* Based on allocbufs from omxtx.
Buffers are connected as a one-way linked list using pAppPrivate as the pointer to the next element */
void omx_alloc_buffers(struct omx_component_t *component, int port)
{
int i;
OMX_BUFFERHEADERTYPE *list = NULL, **end = &list;
OMX_PARAM_PORTDEFINITIONTYPE portdef;
OMX_INIT_STRUCTURE(portdef);
portdef.nPortIndex = port;
OERR(OMX_GetParameter(component->h, OMX_IndexParamPortDefinition, &portdef));
if (component == &component->pipe->audio_render) {
DEBUGF("Allocating %d buffers of %d bytes\n",(int)portdef.nBufferCountActual,(int)portdef.nBufferSize);
DEBUGF("portdef.bEnabled=%d\n",portdef.bEnabled);
}
for (i = 0; i < portdef.nBufferCountActual; i++) {
OMX_U8 *buf;
buf = vcos_malloc_aligned(portdef.nBufferSize, portdef.nBufferAlignment, "buffer");
// printf("Allocated a buffer of %u bytes\n",(unsigned int)portdef.nBufferSize);
OERR(OMX_UseBuffer(component->h, end, port, NULL, portdef.nBufferSize, buf));
end = (OMX_BUFFERHEADERTYPE **) &((*end)->pAppPrivate);
}
component->buffers = list;
}
OMX_ERRORTYPE prepare_port_buffers(HTEST *hTest, OMX_U32 nPortIndex)
{
OMX_COMPONENTTYPE *hComponent = NULL;
OMX_PARAM_PORTDEFINITIONTYPE sPortDef;
OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
OMX_U8 *pBuffer = NULL;
OMX_U32 i;
hComponent = hTest->hComponent;
OMX_INIT_STRUCT(&sPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
sPortDef.nPortIndex = nPortIndex;
OMX_GetParameter(hComponent, OMX_IndexParamPortDefinition, &sPortDef);
for(i=0; i<sPortDef.nBufferCountActual; i++) {
if(hTest->bAllocater[nPortIndex] == OMX_TRUE) {
OMX_AllocateBuffer(hComponent, &pBufferHdr, nPortIndex, NULL, sPortDef.nBufferSize);
printf("Allocate buffer done.\n");
}
else {
pBuffer = (OMX_U8*)FSL_MALLOC(sPortDef.nBufferSize);
OMX_UseBuffer(hComponent, &pBufferHdr, nPortIndex, NULL, sPortDef.nBufferSize, pBuffer);
printf("Use buffer done.\n");
}
hTest->pBufferHdr[nPortIndex][i] = pBufferHdr;
}
hTest->nBufferHdr[nPortIndex] = sPortDef.nBufferCountActual;
return OMX_ErrorNone;
}
static int portSettingsChanged(JPEG_DECODER *decoder, IMAGE *jpeg){
OMX_PARAM_PORTDEFINITIONTYPE portdef;
int ret;
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = decoder->outPort;
OMX_GetParameter(decoder->handle,OMX_IndexParamPortDefinition, &portdef);
jpeg->width = portdef.format.image.nFrameWidth;
jpeg->height = portdef.format.image.nFrameHeight;
jpeg->nData = portdef.nBufferSize;
jpeg->colorSpace = COLOR_SPACE_YUV420P;
OMX_SendCommand(decoder->handle, OMX_CommandPortEnable, decoder->outPort, NULL);
jpeg->pData=malloc(jpeg->nData);
if(jpeg->pData == NULL){
jpeg->nData=0;
return OMX_IMAGE_ERROR_MEMORY;
}
ret = OMX_UseBuffer(decoder->handle, &decoder->pOutputBufferHeader,
decoder->outPort, NULL, portdef.nBufferSize, (OMX_U8 *) jpeg->pData);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_MEMORY;
}
return OMX_IMAGE_OK;
}
static GstMemory *
gst_droid_codec_gralloc_allocator_alloc (GstAllocator * allocator, gsize size,
GstAllocationParams * params)
{
GstMemory *gralloc;
OMX_ERRORTYPE err;
GstDroidCodecGrallocMemory *mem;
struct ANativeWindowBuffer *native;
GstDroidCodecGrallocAllocator *alloc = GST_GRALLOC_ALLOCATOR (allocator);
OMX_BUFFERHEADERTYPE *omx_buf = NULL;
if (size != alloc->port->def.nBufferSize) {
GST_ERROR_OBJECT (alloc->port->comp->parent,
"invalid size passed %i vs requested %li", size,
alloc->port->def.nBufferSize);
return NULL;
}
gralloc = gst_gralloc_allocator_alloc (alloc->gralloc,
alloc->port->def.format.video.nFrameWidth,
alloc->port->def.format.video.nFrameHeight,
alloc->port->def.format.video.eColorFormat, alloc->port->usage);
if (!gralloc) {
GST_ERROR_OBJECT (alloc->port->comp->parent,
"error allocating gralloc memory");
return NULL;
}
mem = g_slice_new0 (GstDroidCodecGrallocMemory);
native = gst_memory_get_native_buffer (gralloc);
err =
OMX_UseBuffer (alloc->port->comp->omx, &omx_buf,
alloc->port->def.nPortIndex, mem, alloc->port->def.nBufferSize,
(OMX_U8 *) native->handle);
if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (alloc->port->comp->parent,
"Failed to use buffer for port %li: %s (0x%08x)",
alloc->port->def.nPortIndex, gst_omx_error_to_string (err), err);
gst_memory_unref (gralloc);
g_slice_free (GstDroidCodecGrallocMemory, mem);
return NULL;
}
mem->gralloc = gralloc;
mem->omx_buf = omx_buf;
gst_memory_init (GST_MEMORY_CAST (mem), GST_MEMORY_FLAG_NO_SHARE, allocator,
NULL, omx_buf->nAllocLen, alloc->port->def.nBufferAlignment, 0,
omx_buf->nAllocLen);
GST_DEBUG_OBJECT (alloc->port->comp->parent,
"Allocated buffer for port %li", alloc->port->def.nPortIndex);
return GST_MEMORY_CAST (mem);
}
static int resizePortSettingsChanged(OMX_RESIZER *resizer, IMAGE *outImage){
OMX_PARAM_PORTDEFINITIONTYPE portdef;
int ret;
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = resizer->outPort;
OMX_GetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
portdef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
portdef.format.image.bFlagErrorConcealment = OMX_FALSE;
if(outImage->colorSpace == COLOR_SPACE_YUV420P)
portdef.format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
else if(outImage->colorSpace == COLOR_SPACE_RGBA)
portdef.format.image.eColorFormat = OMX_COLOR_Format32bitABGR8888;
else if(outImage->colorSpace == COLOR_SPACE_RGB16)
portdef.format.image.eColorFormat = OMX_COLOR_Format16bitRGB565;
portdef.format.image.nFrameWidth = outImage->width;
portdef.format.image.nFrameHeight = outImage->height;
portdef.format.image.nStride = 0;
portdef.format.image.nSliceHeight = 0;
ret = OMX_SetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_PARAMETER;
}
ret = OMX_GetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_PARAMETER;
}
ret = OMX_SendCommand(resizer->handle, OMX_CommandPortEnable, resizer->outPort, NULL);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_PORTS;
}
outImage->nData = portdef.nBufferSize;
outImage->pData=malloc(outImage->nData);
if(outImage->pData == NULL){
outImage->nData=0;
return OMX_IMAGE_ERROR_MEMORY;
}
ret = OMX_UseBuffer(resizer->handle, &resizer->pOutputBufferHeader,
resizer->outPort, NULL, portdef.nBufferSize, (OMX_U8 *) outImage->pData);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_MEMORY;
}
return OMX_IMAGE_OK;
}
OMX_ERRORTYPE omxil_comp::UseBuffer(OMX_BUFFERHEADERTYPE **ppBufferHdr, OMX_U32 nPortIndex, OMX_PTR pAppPrivate, OMX_U32 nSizeBytes, OMX_U8 *pBuffer)
{
OMX_ERRORTYPE result;
result = OMX_UseBuffer(comp, ppBufferHdr, nPortIndex, pAppPrivate, nSizeBytes, pBuffer);
if (result != OMX_ErrorNone) {
fprintf(stderr, "OMX_UseBuffer failed.\n");
}
return result;
}
static int startupResizer(OMX_RESIZER *resizer, IMAGE *inImage){
OMX_PARAM_PORTDEFINITIONTYPE portdef;
int ret;
ilclient_change_component_state(resizer->component, OMX_StateIdle);
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = resizer->inPort;
ret = OMX_GetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_PARAMETER;
}
portdef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
portdef.format.image.bFlagErrorConcealment = OMX_FALSE;
portdef.format.image.nFrameWidth = inImage->width;
portdef.format.image.nFrameHeight = inImage->height;
portdef.format.image.nStride = 0;
portdef.format.image.nSliceHeight = 0;
if(inImage->colorSpace == COLOR_SPACE_YUV420P)
portdef.format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
else if(inImage->colorSpace == COLOR_SPACE_RGBA)
portdef.format.image.eColorFormat = OMX_COLOR_Format32bitABGR8888;
else if(inImage->colorSpace == COLOR_SPACE_RGB16)
portdef.format.image.eColorFormat = OMX_COLOR_Format16bitRGB565;
portdef.nBufferSize=inImage->nData;
ret = OMX_SetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_PARAMETER;
}
ret = OMX_SendCommand(resizer->handle, OMX_CommandPortEnable, resizer->inPort, NULL);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_PORTS;
}
ret = OMX_UseBuffer(resizer->handle,&resizer->pInputBufferHeader,resizer->inPort,
NULL, portdef.nBufferSize, (OMX_U8 *) inImage->pData);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_MEMORY;
}
ilclient_change_component_state(resizer->component, OMX_StateExecuting);
return OMX_IMAGE_OK;
}
status_t OMXNodeInstance::useGraphicBuffer2_l(
OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer,
OMX::buffer_id *buffer) {
// port definition
OMX_PARAM_PORTDEFINITIONTYPE def;
def.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
def.nVersion.s.nVersionMajor = 1;
def.nVersion.s.nVersionMinor = 0;
def.nVersion.s.nRevision = 0;
def.nVersion.s.nStep = 0;
def.nPortIndex = portIndex;
OMX_ERRORTYPE err = OMX_GetParameter(mHandle, OMX_IndexParamPortDefinition, &def);
if (err != OMX_ErrorNone)
{
ALOGE("%s::%d:Error getting OMX_IndexParamPortDefinition", __FUNCTION__, __LINE__);
return err;
}
BufferMeta *bufferMeta = new BufferMeta(graphicBuffer);
OMX_BUFFERHEADERTYPE *header = NULL;
OMX_U8* bufferHandle = const_cast<OMX_U8*>(
reinterpret_cast<const OMX_U8*>(graphicBuffer->handle));
err = OMX_UseBuffer(
mHandle,
&header,
portIndex,
bufferMeta,
def.nBufferSize,
bufferHandle);
if (err != OMX_ErrorNone) {
ALOGE("OMX_UseBuffer failed with error %d (0x%08x)", err, err);
delete bufferMeta;
bufferMeta = NULL;
*buffer = 0;
return UNKNOWN_ERROR;
}
CHECK_EQ(header->pBuffer, bufferHandle);
CHECK_EQ(header->pAppPrivate, bufferMeta);
*buffer = header;
addActiveBuffer(portIndex, *buffer);
return OK;
}
OMX_ERRORTYPE _plugin_use_buffer_anb(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
OMX_IN OMX_U32 nPortIndex,
OMX_IN OMX_PTR pAppPrivate,
OMX_IN OMX_U32 nSizeBytes,
OMX_IN OMX_U8 *pBuffer)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
ret = OMX_UseBuffer(
hComponent, ppBufferHdr, nPortIndex,
pAppPrivate, nSizeBytes, pBuffer);
return ret;
}
static OMX_ERRORTYPE
OMXDecoder_allocateBuffers
(OMXDecoder *thiz,
OMX_BUFFERHEADERTYPE ***buffers, OMX_U32 count,
OMX_U32 portIndex, OMX_U32 size)
{
OMX_BUFFERHEADERTYPE **buffers_;
OMX_ERRORTYPE omxerr;
buffers_ = calloc(count, sizeof(OMX_BUFFERHEADERTYPE *));
if (buffers_)
{
OMX_U32 i;
OMX_HANDLETYPE component = thiz->component;
omxerr = OMX_ErrorNone;
for (i = 0; i < count; i++)
{
OMX_U8 *buffer = malloc(size * sizeof(OMX_U8));
if (buffer)
{
omxerr
= OMX_UseBuffer(
component,
buffers_ + i,
portIndex, NULL, size, buffer);
if (OMX_ErrorNone != omxerr)
free(buffer);
}
else
omxerr = OMX_ErrorInsufficientResources;
if (OMX_ErrorNone != omxerr)
break;
}
}
else
omxerr = OMX_ErrorInsufficientResources;
*buffers = buffers_;
return omxerr;
}
OMX_ERRORTYPE EnableDataFlow::useBuffer()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
DBGT_PTRACE("\n Calling OMX_SetConfig before OMX_UseBuffer ArmIV Chunk\n");
err = OMX_SetConfig(mArmIvProc, (OMX_INDEXTYPE)OMX_OsiIndexConfigSharedChunkMetadata, &mChunkData_ArmIvProc);
if (err != OMX_ErrorNone) {
DBGT_PTRACE("OMX_SetConfig Failed \n");
}
mArmIvInBuffer = NULL;
DBGT_PTRACE("usebuffer mArmIvProc ");
err = OMX_UseBuffer(mArmIvProc, // hComponent
&mArmIvInBuffer, // address where ptr to buffer header will be stored
0, // port index (for port for which buffer is provided)
(void *)(&mArmIvOmxBuffInfo), // App. private data = pointer to beginning of allocated data
// to have a context when component returns with a callback (i.e. to know
// what to free etc.
(OMX_U32)(mParamArmIvInput.nBufferSize), // buffer size
(OMX_U8 *)(mArmIvOmxBuffInfo.mMMHwBufferInfo.iLogAddr) // buffer data ptr
);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_UseBuffer failed for mArmIvProc port 0 failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_ASSERT(NULL != mArmIvInBuffer->pBuffer, "Buffer is NULL");
mArmIvOmxBuffInfo.mCamMemoryBase.get()->setOmxBufferHeaderType(mArmIvInBuffer);
DBGT_EPILOG("");
return err;
}
void
g_omx_core_prepare (GOmxCore *core)
{
change_state (core, OMX_StateIdle);
/* Allocate buffers. */
{
gint index;
gint i;
for (index = 0; index < core->ports->len; index++)
{
GOmxPort *port;
port = g_omx_core_get_port (core, index);
if (port)
{
for (i = 0; i < port->num_buffers; i++)
{
gpointer buffer_data;
guint size;
size = port->buffer_size;
buffer_data = g_malloc (size);
OMX_UseBuffer (core->omx_handle,
&port->buffers[i],
index,
NULL,
size,
buffer_data);
}
}
}
}
wait_for_state (core, OMX_StateIdle);
}
OMX_ERRORTYPE COpenMaxVideo::AllocOMXInputBuffers(void)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
// Obtain the information about the decoder input port.
OMX_PARAM_PORTDEFINITIONTYPE port_format;
OMX_INIT_STRUCTURE(port_format);
port_format.nPortIndex = m_omx_input_port;
OMX_GetParameter(m_omx_decoder, OMX_IndexParamPortDefinition, &port_format);
#if defined(OMX_DEBUG_VERBOSE)
CLog::Log(LOGDEBUG,
"%s::%s - iport(%d), nBufferCountMin(%lu), nBufferSize(%lu)\n",
CLASSNAME, __func__, m_omx_input_port, port_format.nBufferCountMin, port_format.nBufferSize);
#endif
for (size_t i = 0; i < port_format.nBufferCountMin; i++)
{
OMX_BUFFERHEADERTYPE *buffer = NULL;
// use an external buffer that's sized according to actual demux
// packet size, start at internal's buffer size, will get deleted when
// we start pulling demuxer packets and using demux packet sized buffers.
OMX_U8* data = new OMX_U8[port_format.nBufferSize];
omx_err = OMX_UseBuffer(m_omx_decoder, &buffer, m_omx_input_port, NULL, port_format.nBufferSize, data);
if (omx_err)
{
CLog::Log(LOGERROR, "%s::%s - OMX_UseBuffer failed with omx_err(0x%x)\n",
CLASSNAME, __func__, omx_err);
return(omx_err);
}
m_omx_input_buffers.push_back(buffer);
// don't have to lock/unlock here, we are not decoding
m_omx_input_avaliable.push(buffer);
}
m_omx_input_eos = false;
return(omx_err);
}
/** mm_jpegdec_session_send_buffers:
*
* Arguments:
* @data: job session
*
* Return:
* OMX error values
*
* Description:
* Send the buffers to OMX layer
*
**/
OMX_ERRORTYPE mm_jpegdec_session_send_buffers(void *data)
{
uint32_t i = 0;
mm_jpeg_job_session_t* p_session = (mm_jpeg_job_session_t *)data;
OMX_ERRORTYPE ret = OMX_ErrorNone;
QOMX_BUFFER_INFO lbuffer_info;
mm_jpeg_decode_params_t *p_params = &p_session->dec_params;
memset(&lbuffer_info, 0x0, sizeof(QOMX_BUFFER_INFO));
for (i = 0; i < p_params->num_src_bufs; i++) {
CDBG("%s:%d] Source buffer %d", __func__, __LINE__, i);
lbuffer_info.fd = (OMX_U32)p_params->src_main_buf[i].fd;
ret = OMX_UseBuffer(p_session->omx_handle, &(p_session->p_in_omx_buf[i]), 0,
&lbuffer_info, p_params->src_main_buf[i].buf_size,
p_params->src_main_buf[i].buf_vaddr);
if (ret) {
CDBG_ERROR("%s:%d] Error %d", __func__, __LINE__, ret);
return ret;
}
}
CDBG("%s:%d]", __func__, __LINE__);
return ret;
}
static void
setup_tunnel(rpi_pixmap_decoder_t *rpd)
{
int dst_width, dst_height;
OMX_PARAM_PORTDEFINITIONTYPE portdef;
if(rpd->rpd_tunnel != NULL)
return;
OMX_INIT_STRUCTURE(portdef);
portdef.nPortIndex = rpd->rpd_decoder->oc_outport;
omxchk(OMX_GetParameter(rpd->rpd_decoder->oc_handle,
OMX_IndexParamPortDefinition, &portdef));
pixmap_compute_rescale_dim(rpd->rpd_im,
portdef.format.image.nFrameWidth,
portdef.format.image.nFrameHeight,
&dst_width, &dst_height);
portdef.nPortIndex = rpd->rpd_resizer->oc_inport;
omxchk(OMX_SetParameter(rpd->rpd_resizer->oc_handle,
OMX_IndexParamPortDefinition, &portdef));
rpd->rpd_tunnel = omx_tunnel_create(rpd->rpd_decoder,
rpd->rpd_decoder->oc_outport,
rpd->rpd_resizer,
rpd->rpd_resizer->oc_inport,
"decoder -> resizer");
OMX_INIT_STRUCTURE(portdef);
portdef.nPortIndex = rpd->rpd_resizer->oc_outport;
omxchk(OMX_GetParameter(rpd->rpd_resizer->oc_handle,
OMX_IndexParamPortDefinition, &portdef));
int stride = (dst_width * 4 + PIXMAP_ROW_ALIGN - 1) & ~(PIXMAP_ROW_ALIGN - 1);
portdef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
portdef.format.image.eColorFormat = OMX_COLOR_Format32bitABGR8888;
portdef.format.image.nFrameWidth = dst_width;
portdef.format.image.nFrameHeight = dst_height;
portdef.format.image.nStride = stride;
portdef.format.image.nSliceHeight = 0;
portdef.format.image.bFlagErrorConcealment = OMX_FALSE;
omxchk(OMX_SetParameter(rpd->rpd_resizer->oc_handle,
OMX_IndexParamPortDefinition, &portdef));
omxchk(OMX_GetParameter(rpd->rpd_resizer->oc_handle,
OMX_IndexParamPortDefinition, &portdef));
omx_set_state(rpd->rpd_resizer, OMX_StateExecuting);
omx_port_enable(rpd->rpd_resizer, rpd->rpd_resizer->oc_outport);
pixmap_t *pm = rpd->rpd_pm = calloc(1, sizeof(pixmap_t));
pm->pm_refcount = 1;
pm->pm_width = portdef.format.image.nFrameWidth;
pm->pm_height = portdef.format.image.nFrameHeight;
pm->pm_linesize = portdef.format.image.nStride;
pm->pm_type = PIXMAP_BGR32;
pm->pm_data = mymemalign(portdef.nBufferAlignment, portdef.nBufferSize);
pm->pm_aspect = (float)pm->pm_width / (float)pm->pm_height;
omxchk(OMX_UseBuffer(rpd->rpd_resizer->oc_handle, &rpd->rpd_buf,
rpd->rpd_resizer->oc_outport,
NULL, portdef.nBufferSize, pm->pm_data));
omx_wait_command(rpd->rpd_resizer);
omxchk(OMX_FillThisBuffer(rpd->rpd_resizer->oc_handle, rpd->rpd_buf));
}
static pixmap_t *
rpi_pixmap_decode(pixmap_t *pm, const image_meta_t *im,
char *errbuf, size_t errlen)
{
if(pm->pm_type != PIXMAP_JPEG)
return NULL;
#ifdef TIMING
int64_t ts = showtime_get_ts(), ts2;
#endif
rpi_pixmap_decoder_t *rpd = pixmap_decoder_create(OMX_IMAGE_CodingJPEG);
if(rpd == NULL)
return NULL;
rpd->rpd_im = im;
#ifdef NOCOPY
#error check rpd->rpd_decoder->oc_stream_corrupt
OMX_PARAM_PORTDEFINITIONTYPE portdef;
memset(&portdef, 0, sizeof(portdef));
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = rpd->rpd_decoder->oc_inport;
omxchk(OMX_GetParameter(rpd->rpd_decoder->oc_handle,
OMX_IndexParamPortDefinition, &portdef));
omx_send_command(rpd->rpd_decoder, OMX_CommandPortEnable,
rpd->rpd_decoder->oc_inport, NULL, 0);
OMX_BUFFERHEADERTYPE *buf;
for(int i = 0; i < portdef.nBufferCountActual; i++) {
omxchk(OMX_UseBuffer(rpd->rpd_decoder->oc_handle, &buf,
rpd->rpd_decoder->oc_inport,
NULL, pm->pm_size, pm->pm_data));
}
// Waits for the OMX_CommandPortEnable command
omx_wait_command(rpd->rpd_decoder);
omx_set_state(rpd->rpd_decoder, OMX_StateExecuting);
CHECKPOINT("Initialized");
buf->nOffset = 0;
buf->nFilledLen = pm->pm_size;
buf->nFlags |= OMX_BUFFERFLAG_EOS;
rpd->rpd_decoder->oc_inflight_buffers++;
omxchk(OMX_EmptyThisBuffer(rpd->rpd_decoder->oc_handle, buf));
hts_mutex_lock(&rpd->rpd_mtx);
while(rpd->rpd_change == 0)
hts_cond_wait(&rpd->rpd_cond, &rpd->rpd_mtx);
hts_mutex_unlock(&rpd->rpd_mtx);
CHECKPOINT("Setup tunnel");
setup_tunnel(rpd);
#else
const void *data = pm->pm_data;
size_t len = pm->pm_size;
hts_mutex_lock(&rpd->rpd_mtx);
while(len > 0) {
OMX_BUFFERHEADERTYPE *buf;
if(rpd->rpd_decoder->oc_stream_corrupt)
break;
if(rpd->rpd_change == 1) {
rpd->rpd_change = 2;
hts_mutex_unlock(&rpd->rpd_mtx);
setup_tunnel(rpd);
hts_mutex_lock(&rpd->rpd_mtx);
continue;
}
if(rpd->rpd_decoder->oc_avail == NULL) {
hts_cond_wait(&rpd->rpd_cond, &rpd->rpd_mtx);
continue;
}
buf = rpd->rpd_decoder->oc_avail;
rpd->rpd_decoder->oc_avail = buf->pAppPrivate;
rpd->rpd_decoder->oc_inflight_buffers++;
hts_mutex_unlock(&rpd->rpd_mtx);
buf->nOffset = 0;
buf->nFilledLen = MIN(len, buf->nAllocLen);
memcpy(buf->pBuffer, data, buf->nFilledLen);
buf->nFlags = 0;
if(len <= buf->nAllocLen)
buf->nFlags |= OMX_BUFFERFLAG_EOS;
data += buf->nFilledLen;
len -= buf->nFilledLen;
omxchk(OMX_EmptyThisBuffer(rpd->rpd_decoder->oc_handle, buf));
hts_mutex_lock(&rpd->rpd_mtx);
}
if(rpd->rpd_decoder->oc_stream_corrupt) {
hts_mutex_unlock(&rpd->rpd_mtx);
goto err;
}
if(rpd->rpd_change != 2) {
while(rpd->rpd_change == 0 && !rpd->rpd_decoder->oc_stream_corrupt)
hts_cond_wait(&rpd->rpd_cond, &rpd->rpd_mtx);
hts_mutex_unlock(&rpd->rpd_mtx);
if(rpd->rpd_decoder->oc_stream_corrupt)
goto err;
setup_tunnel(rpd);
} else {
hts_mutex_unlock(&rpd->rpd_mtx);
}
#endif
omx_wait_fill_buffer(rpd->rpd_resizer, rpd->rpd_buf);
CHECKPOINT("Got buffer");
err:
omx_flush_port(rpd->rpd_decoder, rpd->rpd_decoder->oc_inport);
omx_flush_port(rpd->rpd_decoder, rpd->rpd_decoder->oc_outport);
omx_flush_port(rpd->rpd_resizer, rpd->rpd_resizer->oc_inport);
omx_flush_port(rpd->rpd_resizer, rpd->rpd_resizer->oc_outport);
if(rpd->rpd_tunnel != NULL) {
omx_tunnel_destroy(rpd->rpd_tunnel);
rpd->rpd_tunnel = NULL;
}
omx_set_state(rpd->rpd_decoder, OMX_StateIdle);
omx_set_state(rpd->rpd_resizer, OMX_StateIdle);
if(rpd->rpd_buf != NULL) {
omxchk(OMX_FreeBuffer(rpd->rpd_resizer->oc_handle,
rpd->rpd_resizer->oc_outport, rpd->rpd_buf));
}
omx_release_buffers(rpd->rpd_decoder, rpd->rpd_decoder->oc_inport);
omx_set_state(rpd->rpd_resizer, OMX_StateLoaded);
omx_set_state(rpd->rpd_decoder, OMX_StateLoaded);
omx_component_destroy(rpd->rpd_resizer);
omx_component_destroy(rpd->rpd_decoder);
hts_cond_destroy(&rpd->rpd_cond);
hts_mutex_destroy(&rpd->rpd_mtx);
pixmap_t *out = rpd->rpd_pm;
if(out) {
pixmap_release(pm);
} else {
snprintf(errbuf, errlen, "Load error");
}
free(rpd);
CHECKPOINT("All done");
return out;
}
OMX_ERRORTYPE COMXCoreComponent::AllocOutputBuffers(bool use_buffers /* = false */)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
if(!m_handle)
return OMX_ErrorUndefined;
m_omx_output_use_buffers = use_buffers;
OMX_PARAM_PORTDEFINITIONTYPE portFormat;
OMX_INIT_STRUCTURE(portFormat);
portFormat.nPortIndex = m_output_port;
omx_err = OMX_GetParameter(m_handle, OMX_IndexParamPortDefinition, &portFormat);
if(omx_err != OMX_ErrorNone)
return omx_err;
if(GetState() != OMX_StateIdle)
{
if(GetState() != OMX_StateLoaded)
SetStateForComponent(OMX_StateLoaded);
SetStateForComponent(OMX_StateIdle);
}
omx_err = EnablePort(m_output_port, false);
if(omx_err != OMX_ErrorNone)
return omx_err;
m_output_alignment = portFormat.nBufferAlignment;
m_output_buffer_count = portFormat.nBufferCountActual;
m_output_buffer_size = portFormat.nBufferSize;
CLog::Log(LOGDEBUG, "COMXCoreComponent::AllocOutputBuffers component(%s) - port(%d), nBufferCountMin(%lu), nBufferCountActual(%lu), nBufferSize(%lu) nBufferAlignmen(%lu)\n",
m_componentName.c_str(), m_output_port, portFormat.nBufferCountMin,
portFormat.nBufferCountActual, portFormat.nBufferSize, portFormat.nBufferAlignment);
for (size_t i = 0; i < portFormat.nBufferCountActual; i++)
{
OMX_BUFFERHEADERTYPE *buffer = NULL;
OMX_U8* data = NULL;
if(m_omx_output_use_buffers)
{
data = (OMX_U8*)_aligned_malloc(portFormat.nBufferSize, m_output_alignment);
omx_err = OMX_UseBuffer(m_handle, &buffer, m_output_port, NULL, portFormat.nBufferSize, data);
}
else
{
omx_err = OMX_AllocateBuffer(m_handle, &buffer, m_output_port, NULL, portFormat.nBufferSize);
}
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXCoreComponent::AllocOutputBuffers component(%s) - OMX_UseBuffer failed with omx_err(0x%x)\n",
m_componentName.c_str(), omx_err);
if(m_omx_output_use_buffers && data)
_aligned_free(data);
return omx_err;
}
buffer->nOutputPortIndex = m_output_port;
buffer->nFilledLen = 0;
buffer->nOffset = 0;
buffer->pAppPrivate = (void*)i;
m_omx_output_buffers.push_back(buffer);
m_omx_output_available.push(buffer);
}
omx_err = WaitForCommand(OMX_CommandPortEnable, m_output_port);
m_flush_output = false;
return omx_err;
}
int
portSettingsChanged(OPENMAX_JPEG_DECODER * decoder)
{
OMX_PARAM_PORTDEFINITIONTYPE portdef, rportdef;;
int ret;
// CLEANUP
printf("Pport settings changed\n");
// need to setup the input for the render with the output of the
// decoder
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = decoder->imageDecoder->outPort;
OMX_GetParameter(decoder->imageDecoder->handle,
OMX_IndexParamPortDefinition, &portdef);
// Get default values of render
rportdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
rportdef.nVersion.nVersion = OMX_VERSION;
rportdef.nPortIndex = decoder->imageRender->inPort;
rportdef.nBufferSize = portdef.nBufferSize;
ret = OMX_GetParameter(decoder->imageRender->handle,
OMX_IndexParamPortDefinition, &rportdef);
if (ret != OMX_ErrorNone) {
fprintf(stderr, "Error getting render port params %s\n", err2str(ret));
return OMXJPEG_ERROR_MEMORY;
}
// tell render input what the decoder output will be providing
//Copy some
rportdef.format.video.nFrameWidth = portdef.format.image.nFrameWidth;
rportdef.format.video.nFrameHeight = portdef.format.image.nFrameHeight;
rportdef.format.video.nStride = portdef.format.image.nStride;
rportdef.format.video.nSliceHeight = portdef.format.image.nSliceHeight;
ret = OMX_SetParameter(decoder->imageRender->handle,
OMX_IndexParamPortDefinition, &rportdef);
if (ret != OMX_ErrorNone) {
fprintf(stderr, "Error setting render port params %s\n", err2str(ret));
return OMXJPEG_ERROR_MEMORY;
} else {
printf("Render port params set up ok\n");
}
unsigned int uWidth =
(unsigned int) portdef.format.image.nFrameWidth;
unsigned int uHeight =
(unsigned int) portdef.format.image.nFrameHeight;
printf
("Getting format Compression 0x%x Color Format: 0x%x\n",
(unsigned int) portdef.format.image.eCompressionFormat,
(unsigned int) portdef.format.image.eColorFormat);
printColorFormat(portdef.format.image.eColorFormat);
// enable ports
OMX_SendCommand(decoder->imageDecoder->handle,
OMX_CommandPortEnable,
decoder->imageDecoder->outPort, NULL);
// once the state changes, both ports should become enabled and the
// render
// output should generate a settings changed event
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventCmdComplete,
OMX_CommandPortEnable, 1,
decoder->imageDecoder->outPort, 1, 0,
TIMEOUT_MS);
printf("Decoder output port enabled\n");
OMX_SendCommand(decoder->imageRender->handle,
OMX_CommandPortEnable,
decoder->imageRender->inPort, NULL);
// once the state changes, both ports should become enabled and the
// render
// output should generate a settings changed event
ilclient_wait_for_event(decoder->imageRender->component,
OMX_EventCmdComplete,
OMX_CommandPortEnable, 1,
decoder->imageRender->inPort, 1, 0,
TIMEOUT_MS);
printf("Render input port enabled\n");
ret = OMX_AllocateBuffer(decoder->imageDecoder->handle,
&decoder->pOutputBufferHeader,
decoder->imageDecoder->
outPort,
NULL,
portdef.nBufferSize);
printf("Output port buffer allocated\n");
if (ret != OMX_ErrorNone) {
perror("Eror allocating buffer");
return OMXJPEG_ERROR_MEMORY;
}
// and share it with the renderer
// which has 3 default buffers, 2 minimum
decoder->ppRenderInputBufferHeader =
(OMX_BUFFERHEADERTYPE **) malloc(sizeof(void) *
decoder->renderInputBufferHeaderCount);
printState(decoder->imageRender->handle);
decoder->imageRender->inPort,
ret = OMX_UseBuffer(decoder->imageRender->handle,
&decoder->ppRenderInputBufferHeader[0],
decoder->imageRender->inPort,
NULL,
rportdef.nBufferSize,
decoder->pOutputBufferHeader->pBuffer);
if (ret != OMX_ErrorNone) {
fprintf(stderr, "Eror sharing buffer %s\n", err2str(ret));
return OMXJPEG_ERROR_MEMORY;
}
decoder->ppRenderInputBufferHeader[0]->nAllocLen =
decoder->pOutputBufferHeader->nAllocLen;
int n;
for (n = 1; n < decoder->renderInputBufferHeaderCount; n++) {
printState(decoder->imageRender->handle);
ret = OMX_UseBuffer(decoder->imageRender->handle,
&decoder->ppRenderInputBufferHeader[n],
decoder->imageRender->inPort,
NULL,
0,
NULL);
if (ret != OMX_ErrorNone) {
fprintf(stderr, "Eror sharing null buffer %s\n", err2str(ret));
return OMXJPEG_ERROR_MEMORY;
}
}
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventCmdComplete,
OMX_CommandPortEnable, 1,
decoder->imageDecoder->outPort, 1, 0,
TIMEOUT_MS);
printf("Decoder output port rnabled\n");
return OMXJPEG_OK;
}
/** mm_jpegdec_session_decode:
*
* Arguments:
* @p_session: encode session
*
* Return:
* OMX_ERRORTYPE
*
* Description:
* Start the encoding
*
**/
static OMX_ERRORTYPE mm_jpegdec_session_decode(mm_jpeg_job_session_t *p_session)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
mm_jpeg_decode_params_t *p_params = &p_session->dec_params;
mm_jpeg_decode_job_t *p_jobparams = &p_session->decode_job;
OMX_EVENTTYPE lEvent;
uint32_t i;
QOMX_BUFFER_INFO lbuffer_info;
pthread_mutex_lock(&p_session->lock);
p_session->abort_state = MM_JPEG_ABORT_NONE;
p_session->encoding = OMX_FALSE;
pthread_mutex_unlock(&p_session->lock);
if (OMX_FALSE == p_session->config) {
ret = mm_jpegdec_session_configure(p_session);
if (ret) {
CDBG_ERROR("%s:%d] Error", __func__, __LINE__);
goto error;
}
p_session->config = OMX_TRUE;
}
pthread_mutex_lock(&p_session->lock);
p_session->encoding = OMX_TRUE;
pthread_mutex_unlock(&p_session->lock);
MM_JPEG_CHK_ABORT(p_session, ret, error);
p_session->event_pending = OMX_TRUE;
ret = OMX_EmptyThisBuffer(p_session->omx_handle,
p_session->p_in_omx_buf[p_jobparams->src_index]);
if (ret) {
CDBG_ERROR("%s:%d] Error", __func__, __LINE__);
goto error;
}
// Wait for port settings changed
pthread_mutex_lock(&p_session->lock);
if (p_session->event_pending == OMX_TRUE) {
CDBG("%s:%d] before wait", __func__, __LINE__);
pthread_cond_wait(&p_session->cond, &p_session->lock);
}
lEvent = p_session->omxEvent;
CDBG("%s:%d] after wait", __func__, __LINE__);
pthread_mutex_unlock(&p_session->lock);
if (lEvent != OMX_EventPortSettingsChanged) {
CDBG("%s:%d] Unexpected event %d", __func__, __LINE__,lEvent);
goto error;
}
// Disable output port (wait)
mm_jpeg_session_port_disable(p_session,
p_session->outputPort.nPortIndex,
OMX_TRUE);
// Get port definition
ret = OMX_GetParameter(p_session->omx_handle, OMX_IndexParamPortDefinition,
&p_session->outputPort);
if (ret) {
CDBG_ERROR("%s:%d] failed", __func__, __LINE__);
return ret;
}
// Set port definition
p_session->outputPort.format.image.nFrameWidth =
(OMX_U32)p_jobparams->main_dim.dst_dim.width;
p_session->outputPort.format.image.nFrameHeight =
(OMX_U32)p_jobparams->main_dim.dst_dim.height;
p_session->outputPort.format.image.eColorFormat =
map_jpeg_format(p_params->color_format);
p_session->outputPort.nBufferSize =
p_params->dest_buf[p_jobparams->dst_index].buf_size;
p_session->outputPort.nBufferCountActual = (OMX_U32)p_params->num_dst_bufs;
p_session->outputPort.format.image.nSliceHeight =
(OMX_U32)
p_params->dest_buf[p_jobparams->dst_index].offset.mp[0].scanline;
p_session->outputPort.format.image.nStride =
p_params->dest_buf[p_jobparams->dst_index].offset.mp[0].stride;
ret = OMX_SetParameter(p_session->omx_handle, OMX_IndexParamPortDefinition,
&p_session->outputPort);
if (ret) {
CDBG_ERROR("%s:%d] failed", __func__, __LINE__);
return ret;
}
// Enable port (no wait)
mm_jpeg_session_port_enable(p_session,
p_session->outputPort.nPortIndex,
OMX_FALSE);
memset(&lbuffer_info, 0x0, sizeof(QOMX_BUFFER_INFO));
// Use buffers
for (i = 0; i < p_params->num_dst_bufs; i++) {
lbuffer_info.fd = (OMX_U32)p_params->dest_buf[i].fd;
CDBG("%s:%d] Dest buffer %d", __func__, __LINE__, (unsigned int)i);
ret = OMX_UseBuffer(p_session->omx_handle, &(p_session->p_out_omx_buf[i]),
1, &lbuffer_info, p_params->dest_buf[i].buf_size,
p_params->dest_buf[i].buf_vaddr);
if (ret) {
CDBG_ERROR("%s:%d] Error", __func__, __LINE__);
return ret;
}
}
// Wait for port enable completion
pthread_mutex_lock(&p_session->lock);
if (p_session->event_pending == OMX_TRUE) {
CDBG("%s:%d] before wait", __func__, __LINE__);
pthread_cond_wait(&p_session->cond, &p_session->lock);
lEvent = p_session->omxEvent;
CDBG("%s:%d] after wait", __func__, __LINE__);
}
lEvent = p_session->omxEvent;
pthread_mutex_unlock(&p_session->lock);
if (lEvent != OMX_EventCmdComplete) {
CDBG("%s:%d] Unexpected event %d", __func__, __LINE__,lEvent);
goto error;
}
ret = OMX_FillThisBuffer(p_session->omx_handle,
p_session->p_out_omx_buf[p_jobparams->dst_index]);
if (ret) {
CDBG_ERROR("%s:%d] Error", __func__, __LINE__);
goto error;
}
MM_JPEG_CHK_ABORT(p_session, ret, error);
error:
CDBG("%s:%d] X ", __func__, __LINE__);
return ret;
}
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;
}
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;
}
int useBufTest()
{
OMX_ERRORTYPE err = OMX_ErrorNone;
OMX_BOOL bOmxInitialized = OMX_FALSE;
OMX_PARAM_PORTDEFINITIONTYPE sOmxPortDefinition;
OMX_CONFIG_BOOLEANTYPE sOmxCapturing;
OMX_CONFIG_BOOLEANTYPE sOmxAutoPause;
OMX_STATETYPE sOmxState;
OMX_U32 nBufferCount;
OMX_U32 nBufferSize;
OMX_U32 nPortIndex;
OMX_U32 i;
unsigned int nPreviewTime = 5;/* By default, running for 5 sec for preview */
unsigned int nCaptureTime = 5;/* By default, running for 5 sec for video capture */
OMX_BOOL bCameraStillImageMode = OMX_FALSE; /* By default, the camera is running in video capture mode */
OMX_BOOL bCameraAutoPause = OMX_FALSE; /* By default, the camera is not running in autopause mode */
unsigned int nMaxRunCount = 1;/* By default, running once */
unsigned int nRunCount = 0;
OMX_U8 *buf = NULL;
surface_display_main_init(DEFAULT_FRAME_WIDTH, DEFAULT_FRAME_HEIGHT);
/* Init the Omx core */
DEBUG(DEB_LEV_SIMPLE_SEQ, "Init the OMX core\n");
if ((err = OMX_Init()) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR,
"The OpenMAX core can not be initialized. Exiting...\n");
goto EXIT;
}
bOmxInitialized = OMX_TRUE;
/* Initialize application private data */
appPriv = malloc(sizeof(appPrivateType));
if (appPriv == NULL)
{
DEBUG(DEB_LEV_ERR, "Allocate app private data failed!Exiting...\n");
err = OMX_ErrorInsufficientResources;
goto EXIT;
}
memset(appPriv, 0, sizeof(appPrivateType));
memset(&sCameraPortBufferList, 0,
NUM_CAMERAPORTS * sizeof(OMX_PORTBUFFERCTXT));
/* Getting camera component handle */
if ((err = OMX_GetHandle(&appPriv->camerahandle,
"OMX.Action.Camera.Yuv", appPriv, &camera_source_callbacks))
!= OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR,
"Getting camera component handle failed!Exiting...\n");
goto EXIT;
}
/* Setting parameters for camera component */
if ((err = setCameraParameters(bCameraStillImageMode)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR,
"Set camera parameters failed! Use default settings...\n");
/* Do not exit! */
}
/* Allocate and init semaphores */
appPriv->cameraSourceEventSem = malloc(sizeof(tsem_t));
if (appPriv->cameraSourceEventSem == NULL)
{
DEBUG(DEB_LEV_ERR,
"Allocate camera event semaphore failed!Exiting...\n");
err = OMX_ErrorInsufficientResources;
goto EXIT;
}
tsem_init(appPriv->cameraSourceEventSem, 0);
RUN_AGAIN:
for (nPortIndex = OMX_CAMPORT_INDEX_VF; nPortIndex <= OMX_CAMPORT_INDEX_CP; nPortIndex++)
{
if ((err = OMX_SendCommand(appPriv->camerahandle,
OMX_CommandPortEnable, nPortIndex, NULL)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Camera Idle-->Exec failed!Exiting...\n");
goto EXIT;
}
tsem_down(appPriv->cameraSourceEventSem);
}
/* Transition camera component Loaded-->Idle */
if ((err = OMX_SendCommand(appPriv->camerahandle, OMX_CommandStateSet,
OMX_StateIdle, NULL)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Camera Loaded-->Idle failed!Exiting...\n");
goto EXIT;
}
/* Allocate port buffers for camera component */
for (nPortIndex = OMX_CAMPORT_INDEX_VF; nPortIndex <= OMX_CAMPORT_INDEX_CP; nPortIndex++)
{
setHeader(&sOmxPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
sOmxPortDefinition.nPortIndex = nPortIndex;
if ((err = OMX_GetParameter(appPriv->camerahandle,
OMX_IndexParamPortDefinition, &sOmxPortDefinition))
!= OMX_ErrorNone)
{
DEBUG(
DEB_LEV_ERR,
"OMX_GetParameter for camera on OMX_IndexParamPortDefinition index failed!Exiting...\n");
goto EXIT;
}
nBufferCount = sOmxPortDefinition.nBufferCountActual;
nBufferSize = sOmxPortDefinition.nBufferSize;
DEBUG(
DEB_LEV_SIMPLE_SEQ,
"Camera port[%ld] needs %ld buffers each of which is %ld bytes\n",
nPortIndex, nBufferCount, nBufferSize);
for (i = 0; i < nBufferCount; i++)
{
buf = (OMX_U8 *)malloc(nBufferSize);
if(buf == NULL){
DEBUG(DEB_LEV_ERR,
"Allocate port buffer for camera failed!Exiting...\n");
goto EXIT;
}
if ((err = OMX_UseBuffer(appPriv->camerahandle,
&sCameraPortBufferList[nPortIndex].pBufHeaderList[i],
nPortIndex, NULL, nBufferSize, buf)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR,
"Allocate port buffer for camera failed!Exiting...\n");
goto EXIT;
}
sCameraPortBufferList[nPortIndex].nBufferCountActual++;
}
}
/* Wait camera (Loaded-->Idle) to complete */
tsem_down(appPriv->cameraSourceEventSem);
/* Transition camera component Idle-->Exec */
if ((err = OMX_SendCommand(appPriv->camerahandle, OMX_CommandStateSet,
OMX_StateExecuting, NULL)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Camera Idle-->Exec failed!Exiting...\n");
goto EXIT;
}
/* Wait camera (Idle-->Exec) to complete */
tsem_down(appPriv->cameraSourceEventSem);
/* Fill buffers to camera preview port */
for (i = 0; i
< sCameraPortBufferList[OMX_CAMPORT_INDEX_VF].nBufferCountActual; i++)
{
sCameraPortBufferList[OMX_CAMPORT_INDEX_VF].pBufHeaderList[i]->nFilledLen
= 0;
sCameraPortBufferList[OMX_CAMPORT_INDEX_VF].pBufHeaderList[i]->nOffset
= 0;
if ((err = OMX_FillThisBuffer(appPriv->camerahandle,
sCameraPortBufferList[OMX_CAMPORT_INDEX_VF].pBufHeaderList[i]))
!= OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR,
"Fill buffer to camera capture port failed!Exiting...\n");
goto EXIT;
}
DEBUG(
DEB_LEV_SIMPLE_SEQ,
"%s: Fill buffer[%ld] (0x%lX) to camera capture port\n",
__func__,
i,
(OMX_U32) sCameraPortBufferList[OMX_CAMPORT_INDEX_VF].pBufHeaderList[i]);
}
/* Fill buffers to camera capture port */
for (i = 0; i
< sCameraPortBufferList[OMX_CAMPORT_INDEX_CP].nBufferCountActual; i++)
{
sCameraPortBufferList[OMX_CAMPORT_INDEX_CP].pBufHeaderList[i]->nFilledLen
= 0;
sCameraPortBufferList[OMX_CAMPORT_INDEX_CP].pBufHeaderList[i]->nOffset
= 0;
if ((err = OMX_FillThisBuffer(appPriv->camerahandle,
sCameraPortBufferList[OMX_CAMPORT_INDEX_CP].pBufHeaderList[i]))
!= OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR,
"Fill buffer to camera capture port failed!Exiting...\n");
goto EXIT;
}
DEBUG(
DEB_LEV_SIMPLE_SEQ,
"%s: Fill buffer[%ld] (0x%lX) to camera capture port\n",
__func__,
i,
(OMX_U32) sCameraPortBufferList[OMX_CAMPORT_INDEX_CP].pBufHeaderList[i]);
}
fprintf(stdout, "Start preview, for %d sec...\n", nPreviewTime);
sleep(nPreviewTime);
/* Set up autopause mode */
setHeader(&sOmxAutoPause, sizeof(OMX_CONFIG_BOOLEANTYPE));
sOmxAutoPause.bEnabled = bCameraAutoPause;
if ((err = OMX_SetConfig(appPriv->camerahandle,
OMX_IndexAutoPauseAfterCapture, &sOmxAutoPause)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR,
"Set autopause mode failed!Use default settings...\n");
/* Do not exit */
}
/* Start capturing */
setHeader(&sOmxCapturing, sizeof(OMX_CONFIG_BOOLEANTYPE));
sOmxCapturing.bEnabled = OMX_TRUE;
if ((err = OMX_SetConfig(appPriv->camerahandle, OMX_IndexConfigCapturing,
&sOmxCapturing)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Start capturing failed!Exiting...\n");
goto EXIT;
}
fprintf(stdout, "Start capturing, for %d sec...\n", nCaptureTime);
sleep(nCaptureTime);
/* Stop capturing */
if (!bCameraStillImageMode)
{
setHeader(&sOmxCapturing, sizeof(OMX_CONFIG_BOOLEANTYPE));
sOmxCapturing.bEnabled = OMX_FALSE;
if ((err = OMX_SetConfig(appPriv->camerahandle,
OMX_IndexConfigCapturing, &sOmxCapturing)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Stop capturing failed!Exiting...\n");
goto EXIT;
}
fprintf(stdout, "Stop capturing...\n");
}
/* If in autopause mode, stay for a while before exit */
if (bCameraAutoPause)
{
fprintf( stdout,"pause state for capture, sleep(%d)\n",5);
sleep(5);
/* Stop autopause mode */
if ((err = OMX_GetState(appPriv->camerahandle, &sOmxState))
!= OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Get camera state failed!Exiting...\n");
goto EXIT;
}
if (sOmxState == OMX_StatePause)
{
if ((err = OMX_SendCommand(appPriv->camerahandle,
OMX_CommandStateSet, OMX_StateExecuting, 0))
!= OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Pause-->Exec failed!Exiting...\n");
goto EXIT;
}
/* Wait camera (Pause-->Exec) to complete */
tsem_down(appPriv->cameraSourceEventSem);
fprintf(
stdout,
"Now the camera is out of autopause mode, wait for %d sec before exit...\n",
5);
sleep(5);
}
else
{
DEBUG(DEB_LEV_ERR,
"The camera is not in Pause state in autopause mode, ignore...\n");
}
}
#if 1
/* Transition camera component Exec-->Idle */
if ((err = OMX_SendCommand(appPriv->camerahandle, OMX_CommandStateSet,
OMX_StateIdle, NULL)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Camera Exec-->Idle failed!Exiting...\n");
goto EXIT;
}
/* Wait camera (Exec-->Idle) to complete */
tsem_down(appPriv->cameraSourceEventSem);
/* Transition camera component Idle-->Exec */
if ((err = OMX_SendCommand(appPriv->camerahandle, OMX_CommandStateSet,
OMX_StateExecuting, NULL)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Camera Idle-->Exec failed!Exiting...\n");
goto EXIT;
}
/* Wait camera (Idle-->Exec) to complete */
tsem_down(appPriv->cameraSourceEventSem);
/* Fill buffers to camera preview port */
for (i = 0; i
< sCameraPortBufferList[OMX_CAMPORT_INDEX_VF].nBufferCountActual; i++)
{
sCameraPortBufferList[OMX_CAMPORT_INDEX_VF].pBufHeaderList[i]->nFilledLen
= 0;
sCameraPortBufferList[OMX_CAMPORT_INDEX_VF].pBufHeaderList[i]->nOffset
= 0;
if ((err = OMX_FillThisBuffer(appPriv->camerahandle,
sCameraPortBufferList[OMX_CAMPORT_INDEX_VF].pBufHeaderList[i]))
!= OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR,
"Fill buffer to camera capture port failed!Exiting...\n");
goto EXIT;
}
DEBUG(
DEB_LEV_SIMPLE_SEQ,
"%s: Fill buffer[%ld] (0x%lX) to camera capture port\n",
__func__,
i,
(OMX_U32) sCameraPortBufferList[OMX_CAMPORT_INDEX_VF].pBufHeaderList[i]);
}
/* Fill buffers to camera capture port */
for (i = 0; i
< sCameraPortBufferList[OMX_CAMPORT_INDEX_CP].nBufferCountActual; i++)
{
sCameraPortBufferList[OMX_CAMPORT_INDEX_CP].pBufHeaderList[i]->nFilledLen
= 0;
sCameraPortBufferList[OMX_CAMPORT_INDEX_CP].pBufHeaderList[i]->nOffset
= 0;
if ((err = OMX_FillThisBuffer(appPriv->camerahandle,
sCameraPortBufferList[OMX_CAMPORT_INDEX_CP].pBufHeaderList[i]))
!= OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR,
"Fill buffer to camera capture port failed!Exiting...\n");
goto EXIT;
}
DEBUG(
DEB_LEV_SIMPLE_SEQ,
"%s: Fill buffer[%ld] (0x%lX) to camera capture port\n",
__func__,
i,
(OMX_U32) sCameraPortBufferList[OMX_CAMPORT_INDEX_CP].pBufHeaderList[i]);
}
fprintf(stdout, "Continue to preview, for %d sec...\n", nPreviewTime);
sleep(nPreviewTime);
#endif
/* Transition camera component Exec-->Idle */
if ((err = OMX_SendCommand(appPriv->camerahandle, OMX_CommandStateSet,
OMX_StateIdle, NULL)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Camera Exec-->Idle failed!Exiting...\n");
goto EXIT;
}
/* Wait camera (Exec-->Idle) to complete */
tsem_down(appPriv->cameraSourceEventSem);
/* Transition camera component Idle-->Loaded */
if ((err = OMX_SendCommand(appPriv->camerahandle, OMX_CommandStateSet,
OMX_StateLoaded, NULL)) != OMX_ErrorNone)
{
DEBUG(DEB_LEV_ERR, "Camera Idle-->Loaded failed!Exiting...\n");
goto EXIT;
}
#if 1
/* Free bufers for each non-tunneled port of camera component */
for (nPortIndex = OMX_CAMPORT_INDEX_VF; nPortIndex <= OMX_CAMPORT_INDEX_CP; nPortIndex++)
{
for (i = 0; i < sCameraPortBufferList[nPortIndex].nBufferCountActual; i++)
{
if (sCameraPortBufferList[nPortIndex].pBufHeaderList[i] != NULL)
{
buf = sCameraPortBufferList[nPortIndex].pBufHeaderList[i]->pBuffer;
OMX_FreeBuffer(appPriv->camerahandle, nPortIndex,
sCameraPortBufferList[nPortIndex].pBufHeaderList[i]);
if(buf){
free(buf);
}
sCameraPortBufferList[nPortIndex].pBufHeaderList[i]=NULL;
}
}
sCameraPortBufferList[nPortIndex].nBufferCountActual = 0;
}
#endif
/* Wait camera (Idle-->Loaded) to complete */
tsem_down(appPriv->cameraSourceEventSem);
nRunCount++;
if (nRunCount < nMaxRunCount)
{
goto RUN_AGAIN;
}
EXIT:
for (nPortIndex = OMX_CAMPORT_INDEX_VF; nPortIndex <= OMX_CAMPORT_INDEX_CP; nPortIndex++)
{
for (i = 0; i < sCameraPortBufferList[nPortIndex].nBufferCountActual; i++)
{
if (sCameraPortBufferList[nPortIndex].pBufHeaderList[i] != NULL)
{
buf = sCameraPortBufferList[nPortIndex].pBufHeaderList[i]->pBuffer;
OMX_FreeBuffer(appPriv->camerahandle, nPortIndex,
sCameraPortBufferList[nPortIndex].pBufHeaderList[i]);
if(buf){
free(buf);
}
sCameraPortBufferList[nPortIndex].pBufHeaderList[i]=NULL;
}
}
sCameraPortBufferList[nPortIndex].nBufferCountActual = 0;
}
/* Free app private data */
if (appPriv != NULL)
{
/* Free semaphores */
if (appPriv->cameraSourceEventSem != NULL)
{
tsem_deinit(appPriv->cameraSourceEventSem);
free(appPriv->cameraSourceEventSem);
}
/* Free camera component handle */
if (appPriv->camerahandle != NULL)
{
OMX_FreeHandle(appPriv->camerahandle);
}
free(appPriv);
}
/* Deinit the Omx core */
if (bOmxInitialized)
{
OMX_Deinit();
}
return (int) err;
}
OMX_ERRORTYPE videosrc_port_AllocateTunnelBuffer(omx_base_PortType *openmaxStandPort,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_U32 nSizeBytes)
{
int i;
OMX_COMPONENTTYPE* omxComponent = openmaxStandPort->standCompContainer;
omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
omx_videosrc_component_PrivateType* omx_videosrc_component_Private = (omx_videosrc_component_PrivateType*)omx_base_component_Private;
OMX_U8* pBuffer=NULL;
OMX_ERRORTYPE eError=OMX_ErrorNone;
OMX_U32 numRetry=0;
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
if (nPortIndex != openmaxStandPort->sPortParam.nPortIndex) {
DEBUG(DEB_LEV_ERR, "In %s: Bad Port Index\n", __func__);
return OMX_ErrorBadPortIndex;
}
if (! PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) {
DEBUG(DEB_LEV_ERR, "In %s: Port is not tunneled Flag=%x\n", __func__, (int)openmaxStandPort->nTunnelFlags);
return OMX_ErrorBadPortIndex;
}
if (omx_base_component_Private->transientState != OMX_TransStateLoadedToIdle) {
if (!openmaxStandPort->bIsTransientToEnabled) {
DEBUG(DEB_LEV_ERR, "In %s: The port is not allowed to receive buffers\n", __func__);
return OMX_ErrorIncorrectStateTransition;
}
}
for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++){
if (openmaxStandPort->bBufferStateAllocated[i] == BUFFER_FREE) {
/* Map the buffer with the device's memory area*/
if(i > n_buffers) {
DEBUG(DEB_LEV_ERR, "In %s returning error i=%d, nframe=%d\n", __func__,i,n_buffers);
return OMX_ErrorInsufficientResources;
}
omx_videosrc_component_Private->bOutBufferMemoryMapped = OMX_TRUE;
pBuffer = omx_videosrc_component_Private->buffers[i].start;
/*Retry more than once, if the tunneled component is not in Loaded->Idle State*/
while(numRetry <TUNNEL_USE_BUFFER_RETRY) {
eError=OMX_UseBuffer(openmaxStandPort->hTunneledComponent,&openmaxStandPort->pInternalBufferStorage[i],
openmaxStandPort->nTunneledPort,NULL,nSizeBytes,pBuffer);
if(eError!=OMX_ErrorNone) {
DEBUG(DEB_LEV_FULL_SEQ,"Tunneled Component Couldn't Use buffer %i From Comp=%s Retry=%d\n",
i,omx_base_component_Private->name,(int)numRetry);
if((eError == OMX_ErrorIncorrectStateTransition) && numRetry<TUNNEL_USE_BUFFER_RETRY) {
DEBUG(DEB_LEV_FULL_SEQ,"Waiting for next try %i \n",(int)numRetry);
usleep(TUNNEL_USE_BUFFER_RETRY_USLEEP_TIME);
numRetry++;
continue;
}
return eError;
}
else {
break;
}
}
openmaxStandPort->bBufferStateAllocated[i] = BUFFER_ALLOCATED;
openmaxStandPort->nNumAssignedBuffers++;
DEBUG(DEB_LEV_PARAMS, "openmaxStandPort->nNumAssignedBuffers %i\n", (int)openmaxStandPort->nNumAssignedBuffers);
if (openmaxStandPort->sPortParam.nBufferCountActual == openmaxStandPort->nNumAssignedBuffers) {
openmaxStandPort->sPortParam.bPopulated = OMX_TRUE;
openmaxStandPort->bIsFullOfBuffers = OMX_TRUE;
DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s nPortIndex=%d\n",__func__, (int)nPortIndex);
}
queue(openmaxStandPort->pBufferQueue, openmaxStandPort->pInternalBufferStorage[i]);
}
}
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s Allocated all buffers\n",__func__);
return OMX_ErrorNone;
}
int main(int argc, char** argv) {
OMX_ERRORTYPE err;
int argn_dec;
OMX_STRING full_component_name;
int isRate=0,isChannel=0;
OMX_AUDIO_PARAM_PCMMODETYPE sPCMModeParam;
if(argc < 2) {
display_help();
} else {
flagIsOutputExpected = 0;
flagDecodedOutputReceived = 0;
flagIsVolCompRequested = 0;
flagSetupTunnel = 0;
flagIsSinkRequested = 0;
argn_dec = 1;
while (argn_dec < argc) {
if (*(argv[argn_dec]) == '-') {
if (flagIsOutputExpected) {
display_help();
}
switch (*(argv[argn_dec] + 1)) {
case 'h' :
display_help();
break;
case 't' :
flagSetupTunnel = 1;
flagIsSinkRequested = 1;
flagIsVolCompRequested = 1;
break;
case 's':
flagIsSinkRequested = 1;
break;
case 'o':
flagIsOutputExpected = 1;
break;
case 'v':
flagIsVolCompRequested = 1;
break;
case 'r' :
isRate = 1;
break;
case 'n' :
isChannel = 1;
break;
default:
display_help();
}
} else {
if (flagIsOutputExpected) {
if(strstr(argv[argn_dec], ".pcm") == NULL) {
output_file = malloc(strlen(argv[argn_dec]) + 5);
strcpy(output_file,argv[argn_dec]);
strcat(output_file, ".pcm");
} else {
output_file = malloc(strlen(argv[argn_dec]) + 1);
strcpy(output_file,argv[argn_dec]);
}
flagIsOutputExpected = 0;
flagDecodedOutputReceived = 1;
} else if(isRate) {
rate=atoi(argv[argn_dec]);
isRate=0;
if(rate <0 || rate >48000) {
DEBUG(DEB_LEV_ERR, "Bad Parameter rate\n");
display_help();
}
} else if(isChannel) {
channel=atoi(argv[argn_dec]);
isChannel = 0;
if(channel <0 || channel >6) {
DEBUG(DEB_LEV_ERR, "Bad Parameter channel\n");
display_help();
}
}
}
argn_dec++;
}
/** if volume componenterter component is not selected then sink component will not work, even if specified */
if(!flagIsVolCompRequested && flagIsSinkRequested) {
DEBUG(DEB_LEV_ERR, "You requested for sink - not producing any output file\n");
flagIsVolCompRequested = 1;
flagDecodedOutputReceived = 0;
}
/** output file name check */
//case 1 - user did not specify any output file
if(!flagIsOutputExpected && !flagDecodedOutputReceived && !flagIsSinkRequested) {
DEBUG(DEB_LEV_ERR,"\n you did not enter any output file name");
output_file = malloc(20);
strcpy(output_file,"output.pcm");
DEBUG(DEB_LEV_ERR,"\n the decoded output file name will be %s \n", output_file);
} else if(flagDecodedOutputReceived) {
if(flagIsSinkRequested || flagSetupTunnel) {
flagDecodedOutputReceived = 0;
DEBUG(DEB_LEV_ERR, "Sink Requested or Components are tunneled. No FILE Output will be produced\n");
} else {
//case 2 - user has given wrong format
if(flagIsVolCompRequested && strstr(output_file, ".pcm") == NULL) {
output_file[strlen(output_file) - strlen(strstr(output_file, "."))] = '\0';
strcat(output_file, ".rgb");
DEBUG(DEB_LEV_ERR,"\n volume component option is selected - so the output file is %s \n", output_file);
}
}
}
if(flagSetupTunnel) {
DEBUG(DEFAULT_MESSAGES,"The components are tunneled between themselves\n");
}
}
if(!flagIsSinkRequested) {
outfile = fopen(output_file, "wb");
if(outfile == NULL) {
DEBUG(DEB_LEV_ERR, "Error in opening output file %s\n", output_file);
exit(1);
}
}
/* Initialize application private data */
appPriv = malloc(sizeof(appPrivateType));
appPriv->sourceEventSem = malloc(sizeof(tsem_t));
if(flagIsVolCompRequested == 1) {
if(flagIsSinkRequested == 1) {
appPriv->alsasinkEventSem = malloc(sizeof(tsem_t));
}
appPriv->volumeEventSem = malloc(sizeof(tsem_t));
}
appPriv->eofSem = malloc(sizeof(tsem_t));
tsem_init(appPriv->sourceEventSem, 0);
if(flagIsVolCompRequested == 1) {
if(flagIsSinkRequested == 1) {
tsem_init(appPriv->alsasinkEventSem, 0);
}
tsem_init(appPriv->volumeEventSem, 0);
}
tsem_init(appPriv->eofSem, 0);
DEBUG(DEB_LEV_SIMPLE_SEQ, "Init the Omx core\n");
err = OMX_Init();
if (err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "The OpenMAX core can not be initialized. Exiting...\n");
exit(1);
} else {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Omx core is initialized \n");
}
DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
test_OMX_ComponentNameEnum();
DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
test_OMX_RoleEnum(COMPONENT_NAME_BASE);
DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
test_OMX_ComponentEnumByRole(BASE_ROLE);
DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
test_OpenClose(COMPONENT_NAME_BASE);
DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
full_component_name = malloc(OMX_MAX_STRINGNAME_SIZE);
strcpy(full_component_name, "OMX.st.alsa.alsasrc");
DEBUG(DEFAULT_MESSAGES, "The component selected for decoding is %s\n", full_component_name);
/** getting audio source handle */
err = OMX_GetHandle(&appPriv->audiosrchandle, full_component_name, NULL, &audiosrccallbacks);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "No audio source component found. Exiting...\n");
exit(1);
} else {
DEBUG(DEFAULT_MESSAGES, "Found The component for capturing is %s\n", full_component_name);
}
/** getting volume componenterter component handle, if specified */
if(flagIsVolCompRequested == 1) {
err = OMX_GetHandle(&appPriv->volume_handle, "OMX.st.volume.component", NULL, &volume_callbacks);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "No volume componenterter component found. Exiting...\n");
exit(1);
} else {
DEBUG(DEFAULT_MESSAGES, "Found The component for volume componenterter \n");
}
/** getting sink component handle - if reqd' */
if(flagIsSinkRequested == 1) {
err = OMX_GetHandle(&appPriv->alsasink_handle, "OMX.st.alsa.alsasink", NULL, &alsasink_callbacks);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "No audio sink component component found. Exiting...\n");
exit(1);
} else {
DEBUG(DEFAULT_MESSAGES, "Found The audio sink component for volume componenterter \n");
}
}
}
if(rate >0 || channel >0) {
setHeader(&sPCMModeParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
err = OMX_GetParameter(appPriv->audiosrchandle,OMX_IndexParamAudioPcm,&sPCMModeParam);
if (err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Err in GetParameter OMX_AUDIO_PARAM_PCMMODETYPE in AlsaSrc. Exiting...\n");
exit(1);
}
sPCMModeParam.nChannels = (channel >0 ) ? channel:sPCMModeParam.nChannels;
sPCMModeParam.nSamplingRate = (rate >0 ) ? rate:sPCMModeParam.nSamplingRate;
err = OMX_SetParameter(appPriv->audiosrchandle,OMX_IndexParamAudioPcm,&sPCMModeParam);
if (err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Err in SetParameter OMX_AUDIO_PARAM_PCMMODETYPE in AlsaSrc. Exiting...\n");
exit(1);
}
if(flagIsSinkRequested) {
err = OMX_SetParameter(appPriv->alsasink_handle,OMX_IndexParamAudioPcm,&sPCMModeParam);
if (err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Err in SetParameter OMX_AUDIO_PARAM_PCMMODETYPE in AlsaSink. Exiting...\n");
exit(1);
}
}
} else if(flagIsSinkRequested) {
setHeader(&sPCMModeParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
err = OMX_GetParameter(appPriv->audiosrchandle,OMX_IndexParamAudioPcm,&sPCMModeParam);
if (err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Err in GetParameter OMX_AUDIO_PARAM_PCMMODETYPE in AlsaSrc. Exiting...\n");
exit(1);
}
err = OMX_SetParameter(appPriv->alsasink_handle,OMX_IndexParamAudioPcm,&sPCMModeParam);
if (err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Err in SetParameter OMX_AUDIO_PARAM_PCMMODETYPE in AlsaSink. Exiting...\n");
exit(1);
}
}
/** output buffer size calculation based on input dimension speculation */
DEBUG(DEB_LEV_SIMPLE_SEQ, "\n buffer_out_size : %d \n", (int)buffer_out_size);
/** if tunneling option is given then set up the tunnel between the components */
if (flagSetupTunnel) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Setting up Tunnel\n");
err = OMX_SetupTunnel(appPriv->audiosrchandle, 0, appPriv->volume_handle, 0);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Set up Tunnel between audio src & volume component Failed\n");
exit(1);
}
err = OMX_SetupTunnel(appPriv->volume_handle, 1, appPriv->alsasink_handle, 0);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Set up Tunnel between volume component & audio sink Failed\n");
exit(1);
}
DEBUG(DEFAULT_MESSAGES, "Set up Tunnel Completed\n");
}
/** sending command to audio source component to go to idle state */
err = OMX_SendCommand(appPriv->audiosrchandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
/** in tunnel case, change the volume component and sink comp state to idle */
if(flagIsVolCompRequested && flagSetupTunnel) {
err = OMX_SendCommand(appPriv->volume_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(flagIsSinkRequested && flagSetupTunnel) {
err = OMX_SendCommand(appPriv->alsasink_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
}
}
if(flagSetupTunnel) {
if(flagIsSinkRequested) {
tsem_down(appPriv->alsasinkEventSem);
}
if(flagIsVolCompRequested) {
tsem_down(appPriv->volumeEventSem);
}
}
/** if tunneling option is not given then allocate buffers on audio source output port */
if (!flagSetupTunnel) {
pOutBuffer[0] = pOutBuffer[1] = NULL;
err = OMX_AllocateBuffer(appPriv->audiosrchandle, &pOutBuffer[0], 0, NULL, buffer_out_size);
err = OMX_AllocateBuffer(appPriv->audiosrchandle, &pOutBuffer[1], 0, NULL, buffer_out_size);
}
DEBUG(DEB_LEV_SIMPLE_SEQ, "Before locking on idle wait semaphore\n");
tsem_down(appPriv->sourceEventSem);
DEBUG(DEB_LEV_SIMPLE_SEQ, "source Sem free\n");
if(!flagSetupTunnel) {
if(flagIsVolCompRequested == 1) {
pOutBufferVolc[0] = pOutBufferVolc[1] = NULL;
err = OMX_SendCommand(appPriv->volume_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
/** in non tunneled case, using buffers in volume component input port, allocated by audio dec component output port */
err = OMX_UseBuffer(appPriv->volume_handle, &pInBufferVolc[0], 0, NULL, buffer_out_size, pOutBuffer[0]->pBuffer);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Unable to use the volume component comp allocate buffer\n");
exit(1);
}
err = OMX_UseBuffer(appPriv->volume_handle, &pInBufferVolc[1], 0, NULL, buffer_out_size, pOutBuffer[1]->pBuffer);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Unable to use the volume component comp allocate buffer\n");
exit(1);
}
/** allocating buffers in the volume componenterter compoennt output port */
err = OMX_AllocateBuffer(appPriv->volume_handle, &pOutBufferVolc[0], 1, NULL, buffer_out_size);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in volume component\n");
exit(1);
}
err = OMX_AllocateBuffer(appPriv->volume_handle, &pOutBufferVolc[1], 1, NULL, buffer_out_size);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in colro conv\n");
exit(1);
}
DEBUG(DEB_LEV_SIMPLE_SEQ, "Before locking on idle wait semaphore\n");
tsem_down(appPriv->volumeEventSem);
DEBUG(DEFAULT_MESSAGES, "volume Event Sem free\n");
if(flagIsSinkRequested == 1) {
err = OMX_SendCommand(appPriv->alsasink_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
err = OMX_UseBuffer(appPriv->alsasink_handle, &pInBufferSink[0], 0, NULL, buffer_out_size, pOutBufferVolc[0]->pBuffer);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Unable to use the alsasink_handle comp allocate buffer\n");
exit(1);
}
err = OMX_UseBuffer(appPriv->alsasink_handle, &pInBufferSink[1], 0, NULL, buffer_out_size, pOutBufferVolc[1]->pBuffer);
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "Unable to use the alsasink_handle comp allocate buffer\n");
exit(1);
}
DEBUG(DEB_LEV_SIMPLE_SEQ, "Before locking on idle wait semaphore\n");
tsem_down(appPriv->alsasinkEventSem);
DEBUG(DEB_LEV_SIMPLE_SEQ, "audio sink comp Sem free\n");
}
}
if(flagIsVolCompRequested == 1) {
err = OMX_SendCommand(appPriv->volume_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
tsem_down(appPriv->volumeEventSem);
if(flagIsSinkRequested == 1) {
err = OMX_SendCommand(appPriv->alsasink_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
tsem_down(appPriv->alsasinkEventSem);
}
}
}
/** send command to change color onv and sink comp in executing state */
if(flagIsVolCompRequested == 1 && flagSetupTunnel) {
err = OMX_SendCommand(appPriv->volume_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
tsem_down(appPriv->volumeEventSem);
if(flagIsSinkRequested == 1) {
err = OMX_SendCommand(appPriv->alsasink_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
tsem_down(appPriv->alsasinkEventSem);
}
}
/** sending command to audio source component to go to executing state */
err = OMX_SendCommand(appPriv->audiosrchandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
tsem_down(appPriv->sourceEventSem);
if(flagIsVolCompRequested == 1 && !flagSetupTunnel) {
err = OMX_FillThisBuffer(appPriv->volume_handle, pOutBufferVolc[0]);
err = OMX_FillThisBuffer(appPriv->volume_handle, pOutBufferVolc[1]);
DEBUG(DEFAULT_MESSAGES, "---> After fill this buffer function calls to the volume component output buffers\n");
}
if (!flagSetupTunnel) {
err = OMX_FillThisBuffer(appPriv->audiosrchandle, pOutBuffer[0]);
err = OMX_FillThisBuffer(appPriv->audiosrchandle, pOutBuffer[1]);
}
DEBUG(DEB_LEV_SIMPLE_SEQ, "---> Before locking on condition and sourceMutex\n");
DEBUG(DEFAULT_MESSAGES,"Enter 'q' or 'Q' to exit\n");
while(1) {
if('Q' == toupper(getchar())) {
DEBUG(DEFAULT_MESSAGES,"Stoping capture\n");
bEOS = OMX_TRUE;
usleep(10000);
break;
}
}
DEBUG(DEFAULT_MESSAGES, "The execution of the audio decoding process is terminated\n");
/** state change of all components from executing to idle */
err = OMX_SendCommand(appPriv->audiosrchandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(flagIsVolCompRequested == 1) {
err = OMX_SendCommand(appPriv->volume_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(flagIsSinkRequested == 1) {
err = OMX_SendCommand(appPriv->alsasink_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
}
}
tsem_down(appPriv->sourceEventSem);
if(flagIsVolCompRequested == 1) {
tsem_down(appPriv->volumeEventSem);
if(flagIsSinkRequested == 1) {
tsem_down(appPriv->alsasinkEventSem);
}
}
DEBUG(DEFAULT_MESSAGES, "All audio components Transitioned to Idle\n");
/** sending command to all components to go to loaded state */
err = OMX_SendCommand(appPriv->audiosrchandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
if(flagIsVolCompRequested == 1) {
err = OMX_SendCommand(appPriv->volume_handle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
if(flagIsSinkRequested == 1) {
err = OMX_SendCommand(appPriv->alsasink_handle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
}
}
/** freeing buffers of volume component and sink component */
if(flagIsVolCompRequested == 1 && !flagSetupTunnel) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "volume component to loaded\n");
err = OMX_FreeBuffer(appPriv->volume_handle, 0, pInBufferVolc[0]);
err = OMX_FreeBuffer(appPriv->volume_handle, 0, pInBufferVolc[1]);
err = OMX_FreeBuffer(appPriv->volume_handle, 1, pOutBufferVolc[0]);
err = OMX_FreeBuffer(appPriv->volume_handle, 1, pOutBufferVolc[1]);
if(flagIsSinkRequested == 1) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Audio sink to loaded\n");
err = OMX_FreeBuffer(appPriv->alsasink_handle, 0, pInBufferSink[0]);
err = OMX_FreeBuffer(appPriv->alsasink_handle, 0, pInBufferSink[1]);
}
}
/** freeing buffers of audio source input ports */
DEBUG(DEB_LEV_SIMPLE_SEQ, "Audio dec to loaded\n");
if(!flagSetupTunnel) {
DEBUG(DEB_LEV_PARAMS, "Free Audio dec output ports\n");
err = OMX_FreeBuffer(appPriv->audiosrchandle, 0, pOutBuffer[0]);
err = OMX_FreeBuffer(appPriv->audiosrchandle, 0, pOutBuffer[1]);
}
if(flagIsVolCompRequested == 1) {
if(flagIsSinkRequested == 1) {
tsem_down(appPriv->alsasinkEventSem);
}
tsem_down(appPriv->volumeEventSem);
}
tsem_down(appPriv->sourceEventSem);
DEBUG(DEB_LEV_SIMPLE_SEQ, "All components released\n");
OMX_FreeHandle(appPriv->audiosrchandle);
if(flagIsVolCompRequested == 1) {
if(flagIsSinkRequested == 1) {
OMX_FreeHandle(appPriv->alsasink_handle);
}
OMX_FreeHandle(appPriv->volume_handle);
}
DEBUG(DEB_LEV_SIMPLE_SEQ, "audio dec freed\n");
OMX_Deinit();
DEBUG(DEFAULT_MESSAGES, "All components freed. Closing...\n");
free(appPriv->sourceEventSem);
if(flagIsVolCompRequested == 1) {
if(flagIsSinkRequested == 1) {
free(appPriv->alsasinkEventSem);
}
free(appPriv->volumeEventSem);
}
free(appPriv->eofSem);
free(appPriv);
free(full_component_name);
/** closing the output file */
if(!flagIsSinkRequested) {
fclose(outfile);
}
if(output_file) {
free(output_file);
}
return 0;
}
static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
{
OMXCodecContext *s = avctx->priv_data;
OMX_PARAM_COMPONENTROLETYPE role_params = { 0 };
OMX_PORT_PARAM_TYPE video_port_params = { 0 };
OMX_PARAM_PORTDEFINITIONTYPE in_port_params = { 0 }, out_port_params = { 0 };
OMX_VIDEO_PARAM_PORTFORMATTYPE video_port_format = { 0 };
OMX_VIDEO_PARAM_BITRATETYPE vid_param_bitrate = { 0 };
OMX_ERRORTYPE err;
int i;
s->version.s.nVersionMajor = 1;
s->version.s.nVersionMinor = 1;
s->version.s.nRevision = 2;
err = s->omx_context->ptr_GetHandle(&s->handle, s->component_name, s, (OMX_CALLBACKTYPE*) &callbacks);
if (err != OMX_ErrorNone) {
av_log(avctx, AV_LOG_ERROR, "OMX_GetHandle(%s) failed: %x\n", s->component_name, err);
return AVERROR_UNKNOWN;
}
// This one crashes the mediaserver on qcom, if used over IOMX
INIT_STRUCT(role_params);
av_strlcpy(role_params.cRole, role, sizeof(role_params.cRole));
// Intentionally ignore errors on this one
OMX_SetParameter(s->handle, OMX_IndexParamStandardComponentRole, &role_params);
INIT_STRUCT(video_port_params);
err = OMX_GetParameter(s->handle, OMX_IndexParamVideoInit, &video_port_params);
CHECK(err);
s->in_port = s->out_port = -1;
for (i = 0; i < video_port_params.nPorts; i++) {
int port = video_port_params.nStartPortNumber + i;
OMX_PARAM_PORTDEFINITIONTYPE port_params = { 0 };
INIT_STRUCT(port_params);
port_params.nPortIndex = port;
err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &port_params);
if (err != OMX_ErrorNone) {
av_log(avctx, AV_LOG_WARNING, "port %d error %x\n", port, err);
break;
}
if (port_params.eDir == OMX_DirInput && s->in_port < 0) {
in_port_params = port_params;
s->in_port = port;
} else if (port_params.eDir == OMX_DirOutput && s->out_port < 0) {
out_port_params = port_params;
s->out_port = port;
}
}
if (s->in_port < 0 || s->out_port < 0) {
av_log(avctx, AV_LOG_ERROR, "No in or out port found (in %d out %d)\n", s->in_port, s->out_port);
return AVERROR_UNKNOWN;
}
s->color_format = 0;
for (i = 0; ; i++) {
INIT_STRUCT(video_port_format);
video_port_format.nIndex = i;
video_port_format.nPortIndex = s->in_port;
if (OMX_GetParameter(s->handle, OMX_IndexParamVideoPortFormat, &video_port_format) != OMX_ErrorNone)
break;
if (video_port_format.eColorFormat == OMX_COLOR_FormatYUV420Planar ||
video_port_format.eColorFormat == OMX_COLOR_FormatYUV420PackedPlanar) {
s->color_format = video_port_format.eColorFormat;
break;
}
}
if (s->color_format == 0) {
av_log(avctx, AV_LOG_ERROR, "No supported pixel formats (%d formats available)\n", i);
return AVERROR_UNKNOWN;
}
in_port_params.bEnabled = OMX_TRUE;
in_port_params.bPopulated = OMX_FALSE;
in_port_params.eDomain = OMX_PortDomainVideo;
in_port_params.format.video.pNativeRender = NULL;
in_port_params.format.video.bFlagErrorConcealment = OMX_FALSE;
in_port_params.format.video.eColorFormat = s->color_format;
s->stride = avctx->width;
s->plane_size = avctx->height;
// If specific codecs need to manually override the stride/plane_size,
// that can be done here.
in_port_params.format.video.nStride = s->stride;
in_port_params.format.video.nSliceHeight = s->plane_size;
in_port_params.format.video.nFrameWidth = avctx->width;
in_port_params.format.video.nFrameHeight = avctx->height;
if (avctx->framerate.den > 0 && avctx->framerate.num > 0)
in_port_params.format.video.xFramerate = (1 << 16) * avctx->framerate.num / avctx->framerate.den;
else
in_port_params.format.video.xFramerate = (1 << 16) * avctx->time_base.den / avctx->time_base.num;
err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
CHECK(err);
err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
CHECK(err);
s->stride = in_port_params.format.video.nStride;
s->plane_size = in_port_params.format.video.nSliceHeight;
s->num_in_buffers = in_port_params.nBufferCountActual;
err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
out_port_params.bEnabled = OMX_TRUE;
out_port_params.bPopulated = OMX_FALSE;
out_port_params.eDomain = OMX_PortDomainVideo;
out_port_params.format.video.pNativeRender = NULL;
out_port_params.format.video.nFrameWidth = avctx->width;
out_port_params.format.video.nFrameHeight = avctx->height;
out_port_params.format.video.nStride = 0;
out_port_params.format.video.nSliceHeight = 0;
out_port_params.format.video.nBitrate = avctx->bit_rate;
out_port_params.format.video.xFramerate = in_port_params.format.video.xFramerate;
out_port_params.format.video.bFlagErrorConcealment = OMX_FALSE;
if (avctx->codec->id == AV_CODEC_ID_MPEG4)
out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
else if (avctx->codec->id == AV_CODEC_ID_H264)
out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
CHECK(err);
err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
CHECK(err);
s->num_out_buffers = out_port_params.nBufferCountActual;
INIT_STRUCT(vid_param_bitrate);
vid_param_bitrate.nPortIndex = s->out_port;
vid_param_bitrate.eControlRate = OMX_Video_ControlRateVariable;
vid_param_bitrate.nTargetBitrate = avctx->bit_rate;
err = OMX_SetParameter(s->handle, OMX_IndexParamVideoBitrate, &vid_param_bitrate);
if (err != OMX_ErrorNone)
av_log(avctx, AV_LOG_WARNING, "Unable to set video bitrate parameter\n");
if (avctx->codec->id == AV_CODEC_ID_H264) {
OMX_VIDEO_PARAM_AVCTYPE avc = { 0 };
INIT_STRUCT(avc);
avc.nPortIndex = s->out_port;
err = OMX_GetParameter(s->handle, OMX_IndexParamVideoAvc, &avc);
CHECK(err);
avc.nBFrames = 0;
avc.nPFrames = avctx->gop_size - 1;
switch (s->profile == FF_PROFILE_UNKNOWN ? avctx->profile : s->profile) {
case FF_PROFILE_H264_BASELINE:
avc.eProfile = OMX_VIDEO_AVCProfileBaseline;
break;
case FF_PROFILE_H264_MAIN:
avc.eProfile = OMX_VIDEO_AVCProfileMain;
break;
case FF_PROFILE_H264_HIGH:
avc.eProfile = OMX_VIDEO_AVCProfileHigh;
break;
default:
break;
}
err = OMX_SetParameter(s->handle, OMX_IndexParamVideoAvc, &avc);
CHECK(err);
}
err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
CHECK(err);
s->in_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
s->free_in_buffers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
s->out_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
s->done_out_buffers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
if (!s->in_buffer_headers || !s->free_in_buffers || !s->out_buffer_headers || !s->done_out_buffers)
return AVERROR(ENOMEM);
for (i = 0; i < s->num_in_buffers && err == OMX_ErrorNone; i++) {
if (s->input_zerocopy)
err = OMX_UseBuffer(s->handle, &s->in_buffer_headers[i], s->in_port, s, in_port_params.nBufferSize, NULL);
else
err = OMX_AllocateBuffer(s->handle, &s->in_buffer_headers[i], s->in_port, s, in_port_params.nBufferSize);
if (err == OMX_ErrorNone)
s->in_buffer_headers[i]->pAppPrivate = s->in_buffer_headers[i]->pOutputPortPrivate = NULL;
}
CHECK(err);
s->num_in_buffers = i;
for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
err = OMX_AllocateBuffer(s->handle, &s->out_buffer_headers[i], s->out_port, s, out_port_params.nBufferSize);
CHECK(err);
s->num_out_buffers = i;
if (wait_for_state(s, OMX_StateIdle) < 0) {
av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateIdle\n");
return AVERROR_UNKNOWN;
}
err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
CHECK(err);
if (wait_for_state(s, OMX_StateExecuting) < 0) {
av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateExecuting\n");
return AVERROR_UNKNOWN;
}
for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
err = OMX_FillThisBuffer(s->handle, s->out_buffer_headers[i]);
if (err != OMX_ErrorNone) {
for (; i < s->num_out_buffers; i++)
s->done_out_buffers[s->num_done_out_buffers++] = s->out_buffer_headers[i];
}
for (i = 0; i < s->num_in_buffers; i++)
s->free_in_buffers[s->num_free_in_buffers++] = s->in_buffer_headers[i];
return err != OMX_ErrorNone ? AVERROR_UNKNOWN : 0;
}
static int brcm_omx_vc03_recd_init(void)
{
OMX_ERRORTYPE error;
OMX_PARAM_PORTDEFINITIONTYPE param;
OMX_AUDIO_PARAM_PCMMODETYPE param1;
int i,size;
DEBUG("\n %lx:brcm_omx_vc03_recd_init\n",jiffies);
g_brcm_alsa_chip->pcm_ptr[1] = 0;
//recorder stuff
memset(&st_recd,0,sizeof(COMPONENT_T));
error = ilclient_create_component(client, &st_recd, "audio_record", 0, 1, 1);
ERROR_RETURN("ilclient_create_component record",error);
ilclient_disable_port(&st_recd,181);
//
memset(¶m, 0, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
param.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
param.nVersion.nVersion = OMX_VERSION;
param.nPortIndex = 180;
error = OMX_GetParameter(st_recd.comp, OMX_IndexParamPortDefinition, ¶m);
ERROR_RETURN("OMX_GetParameter record param",error);
DEBUG("\n brcm_omx_vc03_recd_init:nBufferCountActual=%d\n",
(int)param.nBufferCountActual);
param.nBufferSize = g_brcm_alsa_chip->period_bytes[1];
error = OMX_SetParameter(st_recd.comp, OMX_IndexParamPortDefinition, ¶m);
ERROR_RETURN("OMX_SetParameter record param",error);
//
memset(¶m1, 0, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
param1.nSize = sizeof(OMX_AUDIO_PARAM_PCMMODETYPE);
param1.nVersion.nVersion = OMX_VERSION;
param1.nPortIndex = 180;
error = OMX_GetParameter(st_recd.comp, OMX_IndexParamAudioPcm, ¶m1);
ERROR_RETURN("OMX_GetParameter record param",error);
param1.nSamplingRate = 16000;//support 16000 only?
error = OMX_SetParameter(st_recd.comp, OMX_IndexParamAudioPcm, ¶m1);
ERROR_RETURN("OMX_SetParameter record param1",error);
//
error = OMX_SendCommand(st_recd.comp, OMX_CommandStateSet, OMX_StateIdle, NULL);
ERROR_RETURN("OMX_SendCommand",error);
//
size = g_brcm_alsa_chip->period_bytes[1];
for(i=0; i<param.nBufferCountActual; i++)
{
error = OMX_UseBuffer(st_recd.comp, &st_recd.out_list, 180, st_recd.out_list, size, NULL);
ERROR_RETURN("OMX_UseBuffer",error);
DEBUG("\n record %lx:st.out_list=%x st.out_list->private=%x\n",jiffies,
(unsigned int)st_recd.out_list,(unsigned int)st_recd.out_list->pAppPrivate);
}
recd_buffer = st_recd.out_list;
error = ilclient_wait_for_event(&st_recd, OMX_EventCmdComplete, OMX_CommandStateSet,
0, OMX_StateIdle, 0,
ILCLIENT_STATE_CHANGED, PLATFORM_EVENTGROUP_SUSPEND);
ERROR_RETURN("ilclient_wait_for_event record",error);
if (alsa_pcm_event & PCM_EVENT_RECD_START)
{
error = ilclient_change_component_state(&st_recd, OMX_StateExecuting);
ERROR_RETURN("ilclient_change_component_state record",error);
}
return 0;
}
static int brcm_omx_vc03_play_init(void)
{
OMX_ERRORTYPE error;
OMX_PARAM_PORTDEFINITIONTYPE param;
OMX_AUDIO_PARAM_PCMMODETYPE param1;
int size;
DEBUG("\n %lx:brcm_omx_vc03_play_init\n",jiffies);
g_brcm_alsa_chip->pcm_ptr[0] = 0;
// playback stuff
memset(&st_play,0,sizeof(COMPONENT_T));
error = ilclient_create_component(client, &st_play, "audio_render", 0, 1, 1);
ERROR_RETURN("ilclient_create_component",error);
ilclient_disable_port(&st_play,101);
//
memset(¶m, 0, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
param.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
param.nVersion.nVersion = OMX_VERSION;
param.nPortIndex = 100;
param.nBufferCountActual = 1;
param.nBufferSize = g_brcm_alsa_chip->period_bytes[0];//20*AUDIO_SAMPLE*2;
param.eDir = OMX_DirInput;
param.eDomain = OMX_PortDomainAudio;
param.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
error = OMX_SetParameter(st_play.comp, OMX_IndexParamPortDefinition, ¶m);
ERROR_RETURN("OMX_SetParameter",error);
//
memset(¶m1, 0, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
param1.nSize = sizeof(OMX_AUDIO_PARAM_PCMMODETYPE);
param1.nVersion.nVersion = OMX_VERSION;
param1.nPortIndex = 100;
param1.nChannels = 2;
param1.eEndian = OMX_EndianLittle;
param1.bInterleaved = OMX_TRUE;
param1.nBitPerSample = 16; //32
param1.nSamplingRate = g_brcm_alsa_chip->rate[0];//8000;//44100;
param1.eNumData = OMX_NumericalDataSigned;
param1.ePCMMode = OMX_AUDIO_PCMModeLinear;
error = OMX_SetParameter(st_play.comp, OMX_IndexParamAudioPcm, ¶m1);
ERROR_RETURN("OMX_SetParameter",error);
//
error = OMX_SendCommand(st_play.comp, OMX_CommandStateSet, OMX_StateIdle, NULL);
ERROR_RETURN("OMX_SendCommand",error);
//
size = g_brcm_alsa_chip->period_bytes[0];
//for(i=0; i<param.nBufferCountActual; i++) //is one enough?
{
error = OMX_UseBuffer(st_play.comp, &st_play.out_list, 100, st_play.out_list, size, NULL);
ERROR_RETURN("OMX_UseBuffer",error);
DEBUG("\n playback %lx:st.out_list=%x st.out_list->private=%x\n",jiffies,
(int)st_play.out_list,(int)st_play.out_list->pAppPrivate);
}
//
error = ilclient_wait_for_event(&st_play, OMX_EventCmdComplete, OMX_CommandStateSet,
0, OMX_StateIdle, 0,
ILCLIENT_STATE_CHANGED, PLATFORM_EVENTGROUP_SUSPEND);
ERROR_RETURN("ilclient_wait_for_event",error);
//
if (alsa_pcm_event & PCM_EVENT_PLAY_START )
{
error = ilclient_change_component_state(&st_play, OMX_StateExecuting);
ERROR_RETURN("ilclient_change_component_state",error);
}
return 0;
}
