Line-Following-Robot/Input/Externals/raspicam-master/dependencies/mmal/util/mmal_il.c

/*
Copyright (c) 2012, Broadcom Europe Ltd
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of the copyright holder nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "mmal.h"
#include "util/mmal_il.h"
#include "interface/vmcs_host/khronos/IL/OMX_Broadcom.h"

/*****************************************************************************/
static struct {
   MMAL_STATUS_T mmal;
   OMX_ERRORTYPE omx;
} mmal_omx_error[] =
{
   {MMAL_SUCCESS, OMX_ErrorNone},
   {MMAL_ENOMEM, OMX_ErrorInsufficientResources},
   {MMAL_ENOSPC, OMX_ErrorInsufficientResources},
   {MMAL_EINVAL, OMX_ErrorBadParameter},
   {MMAL_ENOSYS, OMX_ErrorNotImplemented},
   {(MMAL_STATUS_T)-1, OMX_ErrorUndefined},
};

OMX_ERRORTYPE mmalil_error_to_omx(MMAL_STATUS_T status)
{
   unsigned int i;
   for(i = 0; mmal_omx_error[i].mmal != (MMAL_STATUS_T)-1; i++)
      if(mmal_omx_error[i].mmal == status) break;
   return mmal_omx_error[i].omx;
}

MMAL_STATUS_T mmalil_error_to_mmal(OMX_ERRORTYPE error)
{
   unsigned int i;
   for(i = 0; mmal_omx_error[i].mmal != (MMAL_STATUS_T)-1; i++)
      if(mmal_omx_error[i].omx == error) break;
   return mmal_omx_error[i].mmal;
}

/*****************************************************************************/
OMX_U32 mmalil_buffer_flags_to_omx(uint32_t flags)
{
   OMX_U32 omx_flags = 0;

   if(flags & MMAL_BUFFER_HEADER_FLAG_KEYFRAME)
      omx_flags |= OMX_BUFFERFLAG_SYNCFRAME;
   if(flags & MMAL_BUFFER_HEADER_FLAG_FRAME_END)
      omx_flags |= OMX_BUFFERFLAG_ENDOFFRAME;
   if(flags & MMAL_BUFFER_HEADER_FLAG_EOS)
      omx_flags |= OMX_BUFFERFLAG_EOS;
   if(flags & MMAL_BUFFER_HEADER_FLAG_CONFIG)
      omx_flags |= OMX_BUFFERFLAG_CODECCONFIG;
   if(flags & MMAL_BUFFER_HEADER_FLAG_DISCONTINUITY)
      omx_flags |= OMX_BUFFERFLAG_DISCONTINUITY;
   if (flags & MMAL_BUFFER_HEADER_FLAG_CODECSIDEINFO)
      omx_flags |= OMX_BUFFERFLAG_CODECSIDEINFO;
   if (flags & MMAL_BUFFER_HEADER_FLAGS_SNAPSHOT)
      omx_flags |= OMX_BUFFERFLAG_CAPTURE_PREVIEW;
   if (flags & MMAL_BUFFER_HEADER_FLAG_CORRUPTED)
      omx_flags |= OMX_BUFFERFLAG_DATACORRUPT;
   if (flags & MMAL_BUFFER_HEADER_FLAG_DECODEONLY)
      omx_flags |= OMX_BUFFERFLAG_DECODEONLY;
   if (flags & MMAL_BUFFER_HEADER_FLAG_USER0)
      omx_flags |= 1<<28;
   if (flags & MMAL_BUFFER_HEADER_FLAG_USER1)
      omx_flags |= 1<<29;
   if (flags & MMAL_BUFFER_HEADER_FLAG_USER2)
      omx_flags |= 1<<30;
   if (flags & MMAL_BUFFER_HEADER_FLAG_USER3)
      omx_flags |= 1<<31;

   return omx_flags;
}

uint32_t mmalil_buffer_flags_to_mmal(OMX_U32 flags)
{
   uint32_t mmal_flags = 0;

   if (flags & OMX_BUFFERFLAG_SYNCFRAME)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_KEYFRAME;
   if (flags & OMX_BUFFERFLAG_ENDOFFRAME)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_FRAME_END;
   if (flags & OMX_BUFFERFLAG_EOS)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_EOS;
   if (flags & OMX_BUFFERFLAG_CODECCONFIG)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_CONFIG;
   if (flags & OMX_BUFFERFLAG_DISCONTINUITY)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_DISCONTINUITY;
   if (flags & OMX_BUFFERFLAG_CODECSIDEINFO)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_CODECSIDEINFO;
   if (flags & OMX_BUFFERFLAG_CAPTURE_PREVIEW)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAGS_SNAPSHOT;
   if (flags & OMX_BUFFERFLAG_DATACORRUPT)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_CORRUPTED;
   if (flags & OMX_BUFFERFLAG_DECODEONLY)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_DECODEONLY;
   if (flags & 1<<28)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_USER0;
   if (flags & 1<<29)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_USER1;
   if (flags & 1<<30)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_USER2;
   if (flags & 1<<31)
      mmal_flags |= MMAL_BUFFER_HEADER_FLAG_USER3;

   return mmal_flags;
}

/*****************************************************************************/
void mmalil_buffer_header_to_omx(OMX_BUFFERHEADERTYPE *omx, MMAL_BUFFER_HEADER_T *mmal)
{
   omx->pBuffer = mmal->data;
   omx->nAllocLen = mmal->alloc_size;
   omx->nFilledLen = mmal->length;
   omx->nOffset = mmal->offset;
   omx->nFlags = mmalil_buffer_flags_to_omx(mmal->flags);
   omx->nTimeStamp = omx_ticks_from_s64(mmal->pts);
   if (mmal->pts == MMAL_TIME_UNKNOWN)
   {
      omx->nFlags |= OMX_BUFFERFLAG_TIME_UNKNOWN;
      omx->nTimeStamp = omx_ticks_from_s64(0);
   }
}

void mmalil_buffer_header_to_mmal(MMAL_BUFFER_HEADER_T *mmal, OMX_BUFFERHEADERTYPE *omx)
{
   mmal->cmd = 0;
   mmal->data = omx->pBuffer;
   mmal->alloc_size = omx->nAllocLen;
   mmal->length = omx->nFilledLen;
   mmal->offset = omx->nOffset;
   mmal->pts = omx_ticks_to_s64(omx->nTimeStamp);
   if (omx->nFlags & OMX_BUFFERFLAG_TIME_UNKNOWN)
      mmal->pts = MMAL_TIME_UNKNOWN;
   mmal->dts = MMAL_TIME_UNKNOWN;
   mmal->flags = mmalil_buffer_flags_to_mmal(omx->nFlags);
}

/*****************************************************************************/
static struct {
   MMAL_ES_TYPE_T type;
   OMX_PORTDOMAINTYPE domain;
} mmal_omx_es_type_table[] =
{
   {MMAL_ES_TYPE_VIDEO,           OMX_PortDomainVideo},
   {MMAL_ES_TYPE_VIDEO,           OMX_PortDomainImage},
   {MMAL_ES_TYPE_AUDIO,           OMX_PortDomainAudio},
   {MMAL_ES_TYPE_UNKNOWN,         OMX_PortDomainMax}
};

OMX_PORTDOMAINTYPE mmalil_es_type_to_omx_domain(MMAL_ES_TYPE_T type)
{
   unsigned int i;
   for(i = 0; mmal_omx_es_type_table[i].type != MMAL_ES_TYPE_UNKNOWN; i++)
      if(mmal_omx_es_type_table[i].type == type) break;
   return mmal_omx_es_type_table[i].domain;
}

MMAL_ES_TYPE_T mmalil_omx_domain_to_es_type(OMX_PORTDOMAINTYPE domain)
{
   unsigned int i;
   for(i = 0; mmal_omx_es_type_table[i].type != MMAL_ES_TYPE_UNKNOWN; i++)
      if(mmal_omx_es_type_table[i].domain == domain) break;
   return mmal_omx_es_type_table[i].type;
}

/*****************************************************************************/
static struct {
   uint32_t encoding;
   OMX_AUDIO_CODINGTYPE coding;
} mmal_omx_audio_coding_table[] =
{
   {MMAL_ENCODING_MP4A,           OMX_AUDIO_CodingAAC},
   {MMAL_ENCODING_MPGA,           OMX_AUDIO_CodingMP3},
   {MMAL_ENCODING_WMA2,           OMX_AUDIO_CodingWMA},
   {MMAL_ENCODING_WMA1,           OMX_AUDIO_CodingWMA},
   {MMAL_ENCODING_AMRNB,          OMX_AUDIO_CodingAMR},
   {MMAL_ENCODING_AMRWB,          OMX_AUDIO_CodingAMR},
   {MMAL_ENCODING_AMRWBP,         OMX_AUDIO_CodingAMR},
   {MMAL_ENCODING_VORBIS,         OMX_AUDIO_CodingVORBIS},
   {MMAL_ENCODING_ALAW,           OMX_AUDIO_CodingPCM},
   {MMAL_ENCODING_MULAW,          OMX_AUDIO_CodingPCM},
   {MMAL_ENCODING_PCM_SIGNED_LE,  OMX_AUDIO_CodingPCM},
   {MMAL_ENCODING_PCM_UNSIGNED_LE,OMX_AUDIO_CodingPCM},
   {MMAL_ENCODING_PCM_SIGNED_BE,  OMX_AUDIO_CodingPCM},
   {MMAL_ENCODING_PCM_UNSIGNED_BE,OMX_AUDIO_CodingPCM},
   {MMAL_ENCODING_AC3,            OMX_AUDIO_CodingDDP},
   {MMAL_ENCODING_EAC3,           OMX_AUDIO_CodingDDP},
   {MMAL_ENCODING_DTS,            OMX_AUDIO_CodingDTS},
   {MMAL_ENCODING_UNKNOWN,        OMX_AUDIO_CodingUnused}
};

uint32_t mmalil_omx_audio_coding_to_encoding(OMX_AUDIO_CODINGTYPE coding)
{
   unsigned int i;
   for(i = 0; mmal_omx_audio_coding_table[i].encoding != MMAL_ENCODING_UNKNOWN; i++)
      if(mmal_omx_audio_coding_table[i].coding == coding) break;
   return mmal_omx_audio_coding_table[i].encoding;
}

OMX_AUDIO_CODINGTYPE mmalil_encoding_to_omx_audio_coding(uint32_t encoding)
{
   unsigned int i;
   for(i = 0; mmal_omx_audio_coding_table[i].encoding != MMAL_ENCODING_UNKNOWN; i++)
      if(mmal_omx_audio_coding_table[i].encoding == encoding) break;
   return mmal_omx_audio_coding_table[i].coding;
}

static struct {
   OMX_AUDIO_CODINGTYPE coding;
   OMX_INDEXTYPE index;
   unsigned int size;
} mmal_omx_audio_format_table[] =
{
   {OMX_AUDIO_CodingPCM, OMX_IndexParamAudioPcm, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE)},
   {OMX_AUDIO_CodingADPCM, OMX_IndexParamAudioAdpcm, sizeof(OMX_AUDIO_PARAM_ADPCMTYPE)},
   {OMX_AUDIO_CodingAMR, OMX_IndexParamAudioAmr, sizeof(OMX_AUDIO_PARAM_AMRTYPE)},
   {OMX_AUDIO_CodingGSMFR, OMX_IndexParamAudioGsm_FR, sizeof(OMX_AUDIO_PARAM_GSMFRTYPE)},
   {OMX_AUDIO_CodingGSMEFR, OMX_IndexParamAudioGsm_EFR, sizeof(OMX_AUDIO_PARAM_GSMEFRTYPE)},
   {OMX_AUDIO_CodingGSMHR, OMX_IndexParamAudioGsm_HR, sizeof(OMX_AUDIO_PARAM_GSMHRTYPE)},
   {OMX_AUDIO_CodingPDCFR, OMX_IndexParamAudioPdc_FR, sizeof(OMX_AUDIO_PARAM_PDCFRTYPE)},
   {OMX_AUDIO_CodingPDCEFR, OMX_IndexParamAudioPdc_EFR, sizeof(OMX_AUDIO_PARAM_PDCEFRTYPE)},
   {OMX_AUDIO_CodingPDCHR, OMX_IndexParamAudioPdc_HR, sizeof(OMX_AUDIO_PARAM_PDCHRTYPE)},
   {OMX_AUDIO_CodingTDMAFR, OMX_IndexParamAudioTdma_FR, sizeof(OMX_AUDIO_PARAM_TDMAFRTYPE)},
   {OMX_AUDIO_CodingTDMAEFR, OMX_IndexParamAudioTdma_EFR, sizeof(OMX_AUDIO_PARAM_TDMAEFRTYPE)},
   {OMX_AUDIO_CodingQCELP8, OMX_IndexParamAudioQcelp8, sizeof(OMX_AUDIO_PARAM_QCELP8TYPE)},
   {OMX_AUDIO_CodingQCELP13, OMX_IndexParamAudioQcelp13, sizeof(OMX_AUDIO_PARAM_QCELP13TYPE)},
   {OMX_AUDIO_CodingEVRC, OMX_IndexParamAudioEvrc, sizeof(OMX_AUDIO_PARAM_EVRCTYPE)},
   {OMX_AUDIO_CodingSMV, OMX_IndexParamAudioSmv, sizeof(OMX_AUDIO_PARAM_SMVTYPE)},
   {OMX_AUDIO_CodingG723, OMX_IndexParamAudioG723, sizeof(OMX_AUDIO_PARAM_G723TYPE)},
   {OMX_AUDIO_CodingG726, OMX_IndexParamAudioG726, sizeof(OMX_AUDIO_PARAM_G726TYPE)},
   {OMX_AUDIO_CodingG729, OMX_IndexParamAudioG729, sizeof(OMX_AUDIO_PARAM_G729TYPE)},
   {OMX_AUDIO_CodingAAC, OMX_IndexParamAudioAac, sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE)},
   {OMX_AUDIO_CodingMP3, OMX_IndexParamAudioMp3, sizeof(OMX_AUDIO_PARAM_MP3TYPE)},
   {OMX_AUDIO_CodingSBC, OMX_IndexParamAudioSbc, sizeof(OMX_AUDIO_PARAM_SBCTYPE)},
   {OMX_AUDIO_CodingVORBIS, OMX_IndexParamAudioVorbis, sizeof(OMX_AUDIO_PARAM_VORBISTYPE)},
   {OMX_AUDIO_CodingWMA, OMX_IndexParamAudioWma, sizeof(OMX_AUDIO_PARAM_WMATYPE)},
   {OMX_AUDIO_CodingRA, OMX_IndexParamAudioRa, sizeof(OMX_AUDIO_PARAM_RATYPE)},
   {OMX_AUDIO_CodingMIDI, OMX_IndexParamAudioMidi, sizeof(OMX_AUDIO_PARAM_MIDITYPE)},
   {OMX_AUDIO_CodingDDP, OMX_IndexParamAudioDdp, sizeof(OMX_AUDIO_PARAM_DDPTYPE)},
   {OMX_AUDIO_CodingDTS, OMX_IndexParamAudioDts, sizeof(OMX_AUDIO_PARAM_DTSTYPE)},
   {OMX_AUDIO_CodingUnused, 0, 0}
};

OMX_AUDIO_CODINGTYPE mmalil_omx_audio_param_index_to_coding(OMX_INDEXTYPE index)
{
   unsigned int i;
   for(i = 0; mmal_omx_audio_format_table[i].coding != OMX_AUDIO_CodingUnused; i++)
      if(mmal_omx_audio_format_table[i].index == index) break;

   return mmal_omx_audio_format_table[i].coding;
}

OMX_INDEXTYPE mmalil_omx_audio_param_index(OMX_AUDIO_CODINGTYPE coding, OMX_U32 *size)
{
   unsigned int i;
   for(i = 0; mmal_omx_audio_format_table[i].coding != OMX_AUDIO_CodingUnused; i++)
      if(mmal_omx_audio_format_table[i].coding == coding) break;

   if(size) *size = mmal_omx_audio_format_table[i].size;
   return mmal_omx_audio_format_table[i].index;
}

MMAL_STATUS_T mmalil_omx_default_channel_mapping(OMX_AUDIO_CHANNELTYPE *channel_mapping, unsigned int nchannels)
{
   static const OMX_AUDIO_CHANNELTYPE default_mapping[][8] = {
      {OMX_AUDIO_ChannelNone},
      {OMX_AUDIO_ChannelCF},
      {OMX_AUDIO_ChannelLF, OMX_AUDIO_ChannelRF},
      {OMX_AUDIO_ChannelLF, OMX_AUDIO_ChannelRF, OMX_AUDIO_ChannelCF},
      {OMX_AUDIO_ChannelLF, OMX_AUDIO_ChannelRF, OMX_AUDIO_ChannelCF,
         OMX_AUDIO_ChannelCS},
      {OMX_AUDIO_ChannelLF, OMX_AUDIO_ChannelRF, OMX_AUDIO_ChannelCF,
         OMX_AUDIO_ChannelLR, OMX_AUDIO_ChannelRR},
      {OMX_AUDIO_ChannelLF, OMX_AUDIO_ChannelRF, OMX_AUDIO_ChannelCF,
         OMX_AUDIO_ChannelLFE, OMX_AUDIO_ChannelLR, OMX_AUDIO_ChannelRR},
      {OMX_AUDIO_ChannelLF, OMX_AUDIO_ChannelRF, OMX_AUDIO_ChannelCF,
         OMX_AUDIO_ChannelLFE, OMX_AUDIO_ChannelLR, OMX_AUDIO_ChannelRR,
         OMX_AUDIO_ChannelCS},
      {OMX_AUDIO_ChannelLF, OMX_AUDIO_ChannelRF, OMX_AUDIO_ChannelCF,
         OMX_AUDIO_ChannelLFE, OMX_AUDIO_ChannelLR, OMX_AUDIO_ChannelRR,
         OMX_AUDIO_ChannelLS, OMX_AUDIO_ChannelRS}
   };

   if (!nchannels || nchannels + 1 >= MMAL_COUNTOF(default_mapping))
      return MMAL_EINVAL;

   memcpy(channel_mapping, default_mapping[nchannels],
      sizeof(default_mapping[0][0]) * nchannels);
   return MMAL_SUCCESS;
}

MMAL_FOURCC_T mmalil_omx_audio_param_to_format(MMAL_ES_FORMAT_T *format,
   OMX_AUDIO_CODINGTYPE coding, OMX_FORMAT_PARAM_TYPE *param)
{
   MMAL_AUDIO_FORMAT_T *audio = &format->es->audio;
   format->encoding = mmalil_omx_audio_coding_to_encoding(coding);
   format->encoding_variant = 0;

   switch(coding)
   {
   case OMX_AUDIO_CodingPCM:
      audio->channels = param->pcm.nChannels;
      audio->sample_rate = param->pcm.nSamplingRate;
      audio->bits_per_sample = param->pcm.nBitPerSample;
      if(param->pcm.ePCMMode == OMX_AUDIO_PCMModeLinear && param->pcm.bInterleaved)
      {
         if(param->pcm.eEndian == OMX_EndianBig &&
            param->pcm.eNumData == OMX_NumericalDataSigned)
            format->encoding = MMAL_ENCODING_PCM_SIGNED_BE;
         else if(param->pcm.eEndian == OMX_EndianLittle &&
            param->pcm.eNumData == OMX_NumericalDataSigned)
            format->encoding = MMAL_ENCODING_PCM_SIGNED_LE;
         if(param->pcm.eEndian == OMX_EndianBig &&
            param->pcm.eNumData == OMX_NumericalDataUnsigned)
            format->encoding = MMAL_ENCODING_PCM_UNSIGNED_BE;
         if(param->pcm.eEndian == OMX_EndianLittle &&
            param->pcm.eNumData == OMX_NumericalDataUnsigned)
            format->encoding = MMAL_ENCODING_PCM_UNSIGNED_LE;
      }
      else if(param->pcm.ePCMMode == OMX_AUDIO_PCMModeALaw)
         format->encoding = MMAL_ENCODING_ALAW;
      else if(param->pcm.ePCMMode == OMX_AUDIO_PCMModeMULaw)
         format->encoding = MMAL_ENCODING_MULAW;
      break;
   case OMX_AUDIO_CodingAAC:
      audio->channels = param->aac.nChannels;
      audio->sample_rate = param->aac.nSampleRate;
      format->bitrate = param->aac.nBitRate;
      switch(param->aac.eAACStreamFormat)
      {
      case OMX_AUDIO_AACStreamFormatMP2ADTS:
      case OMX_AUDIO_AACStreamFormatMP4ADTS:
         format->encoding = MMAL_ENCODING_MP4A;
         format->encoding_variant = MMAL_ENCODING_VARIANT_MP4A_ADTS;
         break;
      case OMX_AUDIO_AACStreamFormatMP4FF:
      case OMX_AUDIO_AACStreamFormatRAW:
         format->encoding = MMAL_ENCODING_MP4A;
         format->encoding_variant = MMAL_ENCODING_VARIANT_MP4A_DEFAULT;
         break;
      default: break;
      }
      break;
   case OMX_AUDIO_CodingMP3:
      format->encoding = MMAL_ENCODING_MPGA;
      audio->channels = param->mp3.nChannels;
      audio->sample_rate = param->mp3.nSampleRate;
      format->bitrate = param->mp3.nBitRate;
      break;
   case OMX_AUDIO_CodingWMA:
      audio->channels = param->wma.nChannels;
      audio->sample_rate = param->wma.nSamplingRate;
      audio->block_align = param->wma.nBlockAlign;
      format->bitrate = param->wma.nBitRate;
      switch(param->wma.eFormat)
      {
      case OMX_AUDIO_WMAFormat7:
         format->encoding = MMAL_ENCODING_WMA1;
         break;
      case OMX_AUDIO_WMAFormat8:
      case OMX_AUDIO_WMAFormat9:
         format->encoding = MMAL_ENCODING_WMA2;
         break;
      default: break;
      }
      break;
   case OMX_AUDIO_CodingVORBIS:
      audio->channels = param->vorbis.nChannels;
      audio->sample_rate = param->vorbis.nSampleRate;
      format->bitrate = param->vorbis.nBitRate;
      break;
   case OMX_AUDIO_CodingAMR:
      audio->channels = param->amr.nChannels;
      audio->sample_rate = 8000;
      format->bitrate = param->amr.nBitRate;
      if(param->amr.eAMRBandMode >= OMX_AUDIO_AMRBandModeNB0 &&
         param->amr.eAMRBandMode <= OMX_AUDIO_AMRBandModeNB7)
         format->encoding = MMAL_ENCODING_AMRNB;
      if(param->amr.eAMRBandMode >= OMX_AUDIO_AMRBandModeWB0 &&
         param->amr.eAMRBandMode <= OMX_AUDIO_AMRBandModeWB8)
         format->encoding = MMAL_ENCODING_AMRWB;
      break;
   case OMX_AUDIO_CodingDDP:
      audio->channels = param->ddp.nChannels;
      audio->sample_rate = param->ddp.nSampleRate;
      if(param->ddp.eBitStreamId > OMX_AUDIO_DDPBitStreamIdAC3)
         format->encoding = MMAL_ENCODING_EAC3;
      break;
   case OMX_AUDIO_CodingDTS:
      audio->channels = param->dts.nChannels;
      audio->sample_rate = param->dts.nSampleRate;
      audio->block_align = param->dts.nDtsFrameSizeBytes;
      break;

   case OMX_AUDIO_CodingADPCM:
   case OMX_AUDIO_CodingGSMFR:
   case OMX_AUDIO_CodingGSMEFR:
   case OMX_AUDIO_CodingGSMHR:
   case OMX_AUDIO_CodingPDCFR:
   case OMX_AUDIO_CodingPDCEFR:
   case OMX_AUDIO_CodingPDCHR:
   case OMX_AUDIO_CodingTDMAFR:
   case OMX_AUDIO_CodingTDMAEFR:
   case OMX_AUDIO_CodingQCELP8:
   case OMX_AUDIO_CodingQCELP13:
   case OMX_AUDIO_CodingEVRC:
   case OMX_AUDIO_CodingSMV:
   case OMX_AUDIO_CodingG711:
   case OMX_AUDIO_CodingG723:
   case OMX_AUDIO_CodingG726:
   case OMX_AUDIO_CodingG729:
   case OMX_AUDIO_CodingSBC:
   case OMX_AUDIO_CodingRA:
   case OMX_AUDIO_CodingMIDI:
   default:
      vcos_assert(0);
      break;
   }

   return format->encoding;
}

OMX_AUDIO_CODINGTYPE mmalil_format_to_omx_audio_param(OMX_FORMAT_PARAM_TYPE *param,
   OMX_INDEXTYPE *param_index, MMAL_ES_FORMAT_T *format)
{
   MMAL_AUDIO_FORMAT_T *audio = &format->es->audio;
   OMX_AUDIO_CODINGTYPE coding = mmalil_encoding_to_omx_audio_coding(format->encoding);
   OMX_U32 size = 0;
   OMX_INDEXTYPE index = mmalil_omx_audio_param_index(coding, &size);

   if(param_index) *param_index = index;
   memset(param, 0, size);
   param->common.nSize = size;

   switch(coding)
   {
   case OMX_AUDIO_CodingPCM:
      param->pcm.nChannels = audio->channels;
      param->pcm.nSamplingRate = audio->sample_rate;
      param->pcm.nBitPerSample = audio->bits_per_sample;
      mmalil_omx_default_channel_mapping(param->pcm.eChannelMapping, audio->channels);
      if(format->encoding == MMAL_ENCODING_PCM_SIGNED_BE ||
         format->encoding == MMAL_ENCODING_PCM_SIGNED_LE ||
         format->encoding == MMAL_ENCODING_PCM_UNSIGNED_BE ||
         format->encoding == MMAL_ENCODING_PCM_UNSIGNED_LE)
      {
         param->pcm.ePCMMode = OMX_AUDIO_PCMModeLinear;
         param->pcm.bInterleaved = OMX_TRUE;
         param->pcm.eEndian = OMX_EndianLittle;
         param->pcm.eNumData = OMX_NumericalDataSigned;
         if(format->encoding == MMAL_ENCODING_PCM_SIGNED_BE ||
            format->encoding == MMAL_ENCODING_PCM_UNSIGNED_BE)
            param->pcm.eEndian = OMX_EndianBig;
         if(format->encoding == MMAL_ENCODING_PCM_UNSIGNED_LE ||
            format->encoding == MMAL_ENCODING_PCM_UNSIGNED_BE)
            param->pcm.eNumData = OMX_NumericalDataUnsigned;
      }
      else if(format->encoding == MMAL_ENCODING_ALAW)
         param->pcm.ePCMMode = OMX_AUDIO_PCMModeALaw;
      else if(format->encoding == MMAL_ENCODING_MULAW)
         param->pcm.ePCMMode = OMX_AUDIO_PCMModeMULaw;
      break;
   case OMX_AUDIO_CodingAAC:
      param->aac.nChannels = audio->channels;
      param->aac.nSampleRate = audio->sample_rate;
      param->aac.nBitRate = format->bitrate;
      switch(format->encoding_variant)
      {
      case MMAL_ENCODING_VARIANT_MP4A_ADTS:
         param->aac.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4ADTS;
         break;
      case MMAL_ENCODING_VARIANT_MP4A_DEFAULT:
         param->aac.eAACStreamFormat = OMX_AUDIO_AACStreamFormatRAW;
         break;
      default: break;
      }
      break;
   case OMX_AUDIO_CodingMP3:
      param->mp3.nChannels = audio->channels;
      param->mp3.nSampleRate = audio->sample_rate;
      param->mp3.nBitRate = format->bitrate;
      break;
   case OMX_AUDIO_CodingWMA:
      param->wma.nChannels = audio->channels;
      param->wma.nSamplingRate = audio->sample_rate;
      param->wma.nBlockAlign = audio->block_align;
      param->wma.nBitRate = format->bitrate;
      switch(format->encoding)
      {
      case MMAL_ENCODING_WMA1:
         param->wma.eFormat = OMX_AUDIO_WMAFormat7;
         break;
      case MMAL_ENCODING_WMA2:
         param->wma.eFormat = OMX_AUDIO_WMAFormat8;
         break;
      default: break;
      }
      break;
   case OMX_AUDIO_CodingVORBIS:
      param->vorbis.nChannels = audio->channels;
      param->vorbis.nSampleRate = audio->sample_rate;
      param->vorbis.nBitRate = format->bitrate;
      break;
   case OMX_AUDIO_CodingAMR:
      param->amr.nChannels = audio->channels;
      param->amr.nBitRate = format->bitrate;
      if(format->encoding == MMAL_ENCODING_AMRNB)
         param->amr.eAMRBandMode = OMX_AUDIO_AMRBandModeNB0;
      if(format->encoding == MMAL_ENCODING_AMRWB)
         param->amr.eAMRBandMode = OMX_AUDIO_AMRBandModeWB0;
      break;
   case OMX_AUDIO_CodingDDP:
      param->ddp.nChannels = audio->channels;
      param->ddp.nSampleRate = audio->sample_rate;
      param->ddp.eBitStreamId = OMX_AUDIO_DDPBitStreamIdAC3;
      if(format->encoding == MMAL_ENCODING_EAC3)
         param->ddp.eBitStreamId = OMX_AUDIO_DDPBitStreamIdEAC3;
      param->ddp.eBitStreamMode = 0;
      param->ddp.eDolbySurroundMode = 0;
      mmalil_omx_default_channel_mapping(param->ddp.eChannelMapping, audio->channels);
      break;
   case OMX_AUDIO_CodingDTS:
      param->dts.nChannels = audio->channels;
      param->dts.nSampleRate = audio->sample_rate;
      param->dts.nDtsFrameSizeBytes = audio->block_align;
      param->dts.nDtsType = 1;
      param->dts.nFormat = 0;
      mmalil_omx_default_channel_mapping(param->dts.eChannelMapping, audio->channels);
      break;
   case OMX_AUDIO_CodingADPCM:
   case OMX_AUDIO_CodingGSMFR:
   case OMX_AUDIO_CodingGSMEFR:
   case OMX_AUDIO_CodingGSMHR:
   case OMX_AUDIO_CodingPDCFR:
   case OMX_AUDIO_CodingPDCEFR:
   case OMX_AUDIO_CodingPDCHR:
   case OMX_AUDIO_CodingTDMAFR:
   case OMX_AUDIO_CodingTDMAEFR:
   case OMX_AUDIO_CodingQCELP8:
   case OMX_AUDIO_CodingQCELP13:
   case OMX_AUDIO_CodingEVRC:
   case OMX_AUDIO_CodingSMV:
   case OMX_AUDIO_CodingG711:
   case OMX_AUDIO_CodingG723:
   case OMX_AUDIO_CodingG726:
   case OMX_AUDIO_CodingG729:
   case OMX_AUDIO_CodingSBC:
   case OMX_AUDIO_CodingRA:
   case OMX_AUDIO_CodingMIDI:
   default:
      vcos_assert(0);
      break;
   }

   return coding;
}

/*****************************************************************************/
static struct {
   uint32_t encoding;
   OMX_VIDEO_CODINGTYPE coding;
} mmal_omx_video_coding_table[] =
{
   {MMAL_ENCODING_H264,           OMX_VIDEO_CodingAVC},
   {MMAL_ENCODING_MP4V,           OMX_VIDEO_CodingMPEG4},
   {MMAL_ENCODING_MP2V,           OMX_VIDEO_CodingMPEG2},
   {MMAL_ENCODING_MP1V,           OMX_VIDEO_CodingMPEG2},
   {MMAL_ENCODING_H263,           OMX_VIDEO_CodingH263},
   {MMAL_ENCODING_WMV3,           OMX_VIDEO_CodingWMV},
   {MMAL_ENCODING_WMV2,           OMX_VIDEO_CodingWMV},
   {MMAL_ENCODING_WMV1,           OMX_VIDEO_CodingWMV},
   {MMAL_ENCODING_WVC1,           OMX_VIDEO_CodingWMV},
   {MMAL_ENCODING_VP6,            OMX_VIDEO_CodingVP6},
   {MMAL_ENCODING_VP7,            OMX_VIDEO_CodingVP7},
   {MMAL_ENCODING_VP8,            OMX_VIDEO_CodingVP8},
   {MMAL_ENCODING_SPARK,          OMX_VIDEO_CodingSorenson},
   {MMAL_ENCODING_THEORA,         OMX_VIDEO_CodingTheora},
   {MMAL_ENCODING_MJPEG,          OMX_VIDEO_CodingMJPEG},
   {MMAL_ENCODING_UNKNOWN,        OMX_VIDEO_CodingUnused}
};

uint32_t mmalil_omx_video_coding_to_encoding(OMX_VIDEO_CODINGTYPE coding)
{
   unsigned int i;
   for(i = 0; mmal_omx_video_coding_table[i].encoding != MMAL_ENCODING_UNKNOWN; i++)
      if(mmal_omx_video_coding_table[i].coding == coding) break;
   return mmal_omx_video_coding_table[i].encoding;
}

OMX_VIDEO_CODINGTYPE mmalil_encoding_to_omx_video_coding(uint32_t encoding)
{
   unsigned int i;
   for(i = 0; mmal_omx_video_coding_table[i].encoding != MMAL_ENCODING_UNKNOWN; i++)
      if(mmal_omx_video_coding_table[i].encoding == encoding) break;
   return mmal_omx_video_coding_table[i].coding;
}

/*****************************************************************************/
static struct {
   uint32_t encoding;
   OMX_IMAGE_CODINGTYPE coding;
} mmal_omx_image_coding_table[] =
{
   {MMAL_ENCODING_JPEG,           OMX_IMAGE_CodingJPEG},
   {MMAL_ENCODING_GIF,            OMX_IMAGE_CodingGIF},
   {MMAL_ENCODING_PNG,            OMX_IMAGE_CodingPNG},
   {MMAL_ENCODING_BMP,            OMX_IMAGE_CodingBMP},
   {MMAL_ENCODING_TGA,            OMX_IMAGE_CodingTGA},
   {MMAL_ENCODING_PPM,            OMX_IMAGE_CodingPPM},
   {MMAL_ENCODING_UNKNOWN,        OMX_IMAGE_CodingUnused}
};

uint32_t mmalil_omx_image_coding_to_encoding(OMX_IMAGE_CODINGTYPE coding)
{
   unsigned int i;
   for(i = 0; mmal_omx_image_coding_table[i].encoding != MMAL_ENCODING_UNKNOWN; i++)
      if(mmal_omx_image_coding_table[i].coding == coding) break;
   return mmal_omx_image_coding_table[i].encoding;
}

OMX_IMAGE_CODINGTYPE mmalil_encoding_to_omx_image_coding(uint32_t encoding)
{
   unsigned int i;
   for(i = 0; mmal_omx_image_coding_table[i].encoding != MMAL_ENCODING_UNKNOWN; i++)
      if(mmal_omx_image_coding_table[i].encoding == encoding) break;
   return mmal_omx_image_coding_table[i].coding;
}

uint32_t mmalil_omx_coding_to_encoding(uint32_t encoding, OMX_PORTDOMAINTYPE domain)
{
   if(domain == OMX_PortDomainVideo)
      return mmalil_omx_video_coding_to_encoding((OMX_VIDEO_CODINGTYPE)encoding);
   else if(domain == OMX_PortDomainAudio)
      return mmalil_omx_audio_coding_to_encoding((OMX_AUDIO_CODINGTYPE)encoding);
   else if(domain == OMX_PortDomainImage)
      return mmalil_omx_image_coding_to_encoding((OMX_IMAGE_CODINGTYPE)encoding);
   else
      return MMAL_ENCODING_UNKNOWN;
}

/*****************************************************************************/
static struct {
   uint32_t encoding;
   OMX_COLOR_FORMATTYPE coding;
} mmal_omx_colorformat_coding_table[] =
{
   {MMAL_ENCODING_I420,           OMX_COLOR_FormatYUV420PackedPlanar},
   {MMAL_ENCODING_I422,           OMX_COLOR_FormatYUV422PackedPlanar},
   {MMAL_ENCODING_I420_SLICE,     OMX_COLOR_FormatYUV420PackedPlanar},
   {MMAL_ENCODING_I422_SLICE,     OMX_COLOR_FormatYUV422PackedPlanar},
   {MMAL_ENCODING_I420,           OMX_COLOR_FormatYUV420Planar},
   {MMAL_ENCODING_YV12,           OMX_COLOR_FormatYVU420PackedPlanar},
   {MMAL_ENCODING_NV12,           OMX_COLOR_FormatYUV420PackedSemiPlanar},
   {MMAL_ENCODING_NV12,           OMX_COLOR_FormatYUV420SemiPlanar},
   {MMAL_ENCODING_NV21,           OMX_COLOR_FormatYVU420PackedSemiPlanar},
   {MMAL_ENCODING_YUVUV128,       OMX_COLOR_FormatYUVUV128},
   {MMAL_ENCODING_YUYV,           OMX_COLOR_FormatYCbYCr},
   {MMAL_ENCODING_YVYU,           OMX_COLOR_FormatYCrYCb},
   {MMAL_ENCODING_UYVY,           OMX_COLOR_FormatCbYCrY},
   {MMAL_ENCODING_VYUY,           OMX_COLOR_FormatCrYCbY},
   {MMAL_ENCODING_RGB16,          OMX_COLOR_Format16bitRGB565},
   {MMAL_ENCODING_BGR24,          OMX_COLOR_Format24bitRGB888},
   {MMAL_ENCODING_BGRA,           OMX_COLOR_Format32bitARGB8888},
   {MMAL_ENCODING_BGR16,          OMX_COLOR_Format16bitBGR565},
   {MMAL_ENCODING_RGB24,          OMX_COLOR_Format24bitBGR888},
   {MMAL_ENCODING_ARGB,           OMX_COLOR_Format32bitBGRA8888},
   {MMAL_ENCODING_RGBA,           OMX_COLOR_Format32bitABGR8888},
   {MMAL_ENCODING_EGL_IMAGE,      OMX_COLOR_FormatBRCMEGL},
   {MMAL_ENCODING_OPAQUE,         OMX_COLOR_FormatBRCMOpaque},
   {MMAL_ENCODING_UNKNOWN,        OMX_COLOR_FormatUnused}
};

uint32_t mmalil_omx_color_format_to_encoding(OMX_COLOR_FORMATTYPE coding)
{
   unsigned int i;
   for(i = 0; mmal_omx_colorformat_coding_table[i].encoding != MMAL_ENCODING_UNKNOWN; i++)
      if(mmal_omx_colorformat_coding_table[i].coding == coding) break;
   return mmal_omx_colorformat_coding_table[i].encoding;
}

OMX_COLOR_FORMATTYPE mmalil_encoding_to_omx_color_format(uint32_t encoding)
{
   unsigned int i;
   for(i = 0; mmal_omx_colorformat_coding_table[i].encoding != MMAL_ENCODING_UNKNOWN; i++)
      if(mmal_omx_colorformat_coding_table[i].encoding == encoding) break;
   return mmal_omx_colorformat_coding_table[i].coding;
}

/*****************************************************************************/
static struct {
   uint32_t mmal;
   OMX_COLORSPACETYPE omx;
} mmal_omx_colorspace_coding_table[] =
{
   {MMAL_COLOR_SPACE_ITUR_BT601,    OMX_COLORSPACE_ITU_R_BT601},
   {MMAL_COLOR_SPACE_ITUR_BT709,    OMX_COLORSPACE_ITU_R_BT709},
   {MMAL_COLOR_SPACE_JPEG_JFIF,     OMX_COLORSPACE_JPEG_JFIF},
   {MMAL_COLOR_SPACE_FCC,           OMX_COLORSPACE_FCC},
   {MMAL_COLOR_SPACE_SMPTE240M,     OMX_COLORSPACE_SMPTE240M},
   {MMAL_COLOR_SPACE_BT470_2_M,     OMX_COLORSPACE_BT470_2_M},
   {MMAL_COLOR_SPACE_BT470_2_BG,    OMX_COLORSPACE_BT470_2_BG},
   {MMAL_COLOR_SPACE_JFIF_Y16_255,  OMX_COLORSPACE_JFIF_Y16_255},
   {MMAL_COLOR_SPACE_UNKNOWN,       OMX_COLORSPACE_UNKNOWN}
};

uint32_t mmalil_omx_color_space_to_mmal(OMX_COLORSPACETYPE coding)
{
   unsigned int i;
   for(i = 0; mmal_omx_colorspace_coding_table[i].mmal != MMAL_COLOR_SPACE_UNKNOWN; i++)
      if(mmal_omx_colorspace_coding_table[i].omx == coding) break;
   return mmal_omx_colorspace_coding_table[i].mmal;
}

OMX_COLORSPACETYPE mmalil_color_space_to_omx(uint32_t coding)
{
   unsigned int i;
   for(i = 0; mmal_omx_colorspace_coding_table[i].mmal != MMAL_COLOR_SPACE_UNKNOWN; i++)
      if(mmal_omx_colorspace_coding_table[i].mmal == coding) break;
   return mmal_omx_colorspace_coding_table[i].omx;
}

/*****************************************************************************/
static struct {
   uint32_t mmal;
   OMX_U32 omx;
   OMX_VIDEO_CODINGTYPE omx_coding;
} mmal_omx_video_profile_table[] =
{
   { MMAL_VIDEO_PROFILE_H263_BASELINE,           OMX_VIDEO_H263ProfileBaseline,           OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_PROFILE_H263_H320CODING,         OMX_VIDEO_H263ProfileH320Coding,         OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_PROFILE_H263_BACKWARDCOMPATIBLE, OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_PROFILE_H263_ISWV2,              OMX_VIDEO_H263ProfileISWV2,              OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_PROFILE_H263_ISWV3,              OMX_VIDEO_H263ProfileISWV3,              OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_PROFILE_H263_HIGHCOMPRESSION,    OMX_VIDEO_H263ProfileHighCompression,    OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_PROFILE_H263_INTERNET,           OMX_VIDEO_H263ProfileInternet,           OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_PROFILE_H263_INTERLACE,          OMX_VIDEO_H263ProfileInterlace,          OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_PROFILE_H263_HIGHLATENCY,        OMX_VIDEO_H263ProfileHighLatency,        OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_PROFILE_MP4V_SIMPLE,             OMX_VIDEO_MPEG4ProfileSimple,            OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_SIMPLESCALABLE,     OMX_VIDEO_MPEG4ProfileSimpleScalable,    OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_CORE,               OMX_VIDEO_MPEG4ProfileCore,              OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_MAIN,               OMX_VIDEO_MPEG4ProfileMain,              OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_NBIT,               OMX_VIDEO_MPEG4ProfileNbit,              OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_SCALABLETEXTURE,    OMX_VIDEO_MPEG4ProfileScalableTexture,   OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_SIMPLEFACE,         OMX_VIDEO_MPEG4ProfileSimpleFace,        OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_SIMPLEFBA,          OMX_VIDEO_MPEG4ProfileSimpleFBA,         OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_BASICANIMATED,      OMX_VIDEO_MPEG4ProfileBasicAnimated,     OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_HYBRID,             OMX_VIDEO_MPEG4ProfileHybrid,            OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_ADVANCEDREALTIME,   OMX_VIDEO_MPEG4ProfileAdvancedRealTime,  OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_CORESCALABLE,       OMX_VIDEO_MPEG4ProfileCoreScalable,      OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_ADVANCEDCODING,     OMX_VIDEO_MPEG4ProfileAdvancedCoding,    OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_ADVANCEDCORE,       OMX_VIDEO_MPEG4ProfileAdvancedCore,      OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_ADVANCEDSCALABLE,   OMX_VIDEO_MPEG4ProfileAdvancedScalable,  OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_MP4V_ADVANCEDSIMPLE,     OMX_VIDEO_MPEG4ProfileAdvancedSimple,    OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_PROFILE_H264_BASELINE,           OMX_VIDEO_AVCProfileBaseline,            OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_PROFILE_H264_MAIN,               OMX_VIDEO_AVCProfileMain,                OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_PROFILE_H264_EXTENDED,           OMX_VIDEO_AVCProfileExtended,            OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_PROFILE_H264_HIGH,               OMX_VIDEO_AVCProfileHigh,                OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_PROFILE_H264_HIGH10,             OMX_VIDEO_AVCProfileHigh10,              OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_PROFILE_H264_HIGH422,            OMX_VIDEO_AVCProfileHigh422,             OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_PROFILE_H264_HIGH444,            OMX_VIDEO_AVCProfileHigh444,             OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_PROFILE_H264_CONSTRAINED_BASELINE, OMX_VIDEO_AVCProfileConstrainedBaseline,             OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_PROFILE_DUMMY,                   OMX_VIDEO_AVCProfileMax,                 OMX_VIDEO_CodingAVC},
};

uint32_t mmalil_omx_video_profile_to_mmal(OMX_U32 profile, OMX_VIDEO_CODINGTYPE coding)
{
   unsigned int i;
   for(i = 0; mmal_omx_video_profile_table[i].mmal != MMAL_VIDEO_PROFILE_DUMMY; i++)
      if(mmal_omx_video_profile_table[i].omx == profile
         && mmal_omx_video_profile_table[i].omx_coding == coding) break;
   return mmal_omx_video_profile_table[i].mmal;
}

OMX_U32 mmalil_video_profile_to_omx(uint32_t profile)
{
   unsigned int i;
   for(i = 0; mmal_omx_video_profile_table[i].mmal != MMAL_VIDEO_PROFILE_DUMMY; i++)
      if(mmal_omx_video_profile_table[i].mmal == profile) break;
   return mmal_omx_video_profile_table[i].omx;
}

/*****************************************************************************/
static struct {
   uint32_t mmal;
   OMX_U32 omx;
   OMX_VIDEO_CODINGTYPE omx_coding;
} mmal_omx_video_level_table[] =
{
   { MMAL_VIDEO_LEVEL_H263_10, OMX_VIDEO_H263Level10,  OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_LEVEL_H263_20, OMX_VIDEO_H263Level20,  OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_LEVEL_H263_30, OMX_VIDEO_H263Level30,  OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_LEVEL_H263_40, OMX_VIDEO_H263Level40,  OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_LEVEL_H263_45, OMX_VIDEO_H263Level45,  OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_LEVEL_H263_50, OMX_VIDEO_H263Level50,  OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_LEVEL_H263_60, OMX_VIDEO_H263Level60,  OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_LEVEL_H263_70, OMX_VIDEO_H263Level70,  OMX_VIDEO_CodingH263},
   { MMAL_VIDEO_LEVEL_MP4V_0,  OMX_VIDEO_MPEG4Level0,  OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_LEVEL_MP4V_0b, OMX_VIDEO_MPEG4Level0b, OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_LEVEL_MP4V_1,  OMX_VIDEO_MPEG4Level1,  OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_LEVEL_MP4V_2,  OMX_VIDEO_MPEG4Level2,  OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_LEVEL_MP4V_3,  OMX_VIDEO_MPEG4Level3,  OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_LEVEL_MP4V_4,  OMX_VIDEO_MPEG4Level4,  OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_LEVEL_MP4V_4a, OMX_VIDEO_MPEG4Level4a, OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_LEVEL_MP4V_5,  OMX_VIDEO_MPEG4Level5,  OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_LEVEL_MP4V_6,  OMX_VIDEO_MPEG4Level6,  OMX_VIDEO_CodingMPEG4},
   { MMAL_VIDEO_LEVEL_H264_1,  OMX_VIDEO_AVCLevel1,    OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_1b, OMX_VIDEO_AVCLevel1b,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_11, OMX_VIDEO_AVCLevel11,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_12, OMX_VIDEO_AVCLevel12,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_13, OMX_VIDEO_AVCLevel13,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_2,  OMX_VIDEO_AVCLevel2,    OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_21, OMX_VIDEO_AVCLevel21,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_22, OMX_VIDEO_AVCLevel22,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_3,  OMX_VIDEO_AVCLevel3,    OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_31, OMX_VIDEO_AVCLevel31,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_32, OMX_VIDEO_AVCLevel32,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_4,  OMX_VIDEO_AVCLevel4,    OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_41, OMX_VIDEO_AVCLevel41,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_42, OMX_VIDEO_AVCLevel42,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_5,  OMX_VIDEO_AVCLevel5,    OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_H264_51, OMX_VIDEO_AVCLevel51,   OMX_VIDEO_CodingAVC},
   { MMAL_VIDEO_LEVEL_DUMMY,   OMX_VIDEO_AVCLevelMax,  OMX_VIDEO_CodingMax},
};

uint32_t mmalil_omx_video_level_to_mmal(OMX_U32 level, OMX_VIDEO_CODINGTYPE coding)
{
   unsigned int i;
   for(i = 0; mmal_omx_video_level_table[i].mmal != MMAL_VIDEO_LEVEL_DUMMY; i++)
      if(mmal_omx_video_level_table[i].omx == level
         && mmal_omx_video_level_table[i].omx_coding == coding) break;
   return mmal_omx_video_level_table[i].mmal;
}

OMX_U32 mmalil_video_level_to_omx(uint32_t level)
{
   unsigned int i;
   for(i = 0; mmal_omx_video_level_table[i].mmal != MMAL_VIDEO_LEVEL_DUMMY; i++)
      if(mmal_omx_video_level_table[i].mmal == level) break;
   return mmal_omx_video_level_table[i].omx;
}

/*****************************************************************************/
static struct {
   MMAL_VIDEO_RATECONTROL_T mmal;
   OMX_VIDEO_CONTROLRATETYPE omx;
} mmal_omx_video_ratecontrol_table[] =
{
   { MMAL_VIDEO_RATECONTROL_DEFAULT,              OMX_Video_ControlRateDisable},
   { MMAL_VIDEO_RATECONTROL_VARIABLE,             OMX_Video_ControlRateVariable},
   { MMAL_VIDEO_RATECONTROL_CONSTANT,             OMX_Video_ControlRateConstant},
   { MMAL_VIDEO_RATECONTROL_VARIABLE_SKIP_FRAMES, OMX_Video_ControlRateVariableSkipFrames},
   { MMAL_VIDEO_RATECONTROL_CONSTANT_SKIP_FRAMES, OMX_Video_ControlRateConstantSkipFrames},
   { MMAL_VIDEO_RATECONTROL_DUMMY,                OMX_Video_ControlRateMax},
};

MMAL_VIDEO_RATECONTROL_T mmalil_omx_video_ratecontrol_to_mmal(OMX_VIDEO_CONTROLRATETYPE omx)
{
   unsigned int i;
   for(i = 0; mmal_omx_video_ratecontrol_table[i].mmal != MMAL_VIDEO_RATECONTROL_DUMMY; i++)
      if(mmal_omx_video_ratecontrol_table[i].omx == omx) break;
   return mmal_omx_video_ratecontrol_table[i].mmal;
}

OMX_VIDEO_CONTROLRATETYPE mmalil_video_ratecontrol_to_omx(MMAL_VIDEO_RATECONTROL_T mmal)
{
   unsigned int i;
   for(i = 0; mmal_omx_video_ratecontrol_table[i].mmal != MMAL_VIDEO_RATECONTROL_DUMMY; i++)
      if(mmal_omx_video_ratecontrol_table[i].mmal == mmal) break;
   return mmal_omx_video_ratecontrol_table[i].omx;
}

/*****************************************************************************/
static struct {
   MMAL_VIDEO_INTRA_REFRESH_T mmal;
   OMX_VIDEO_INTRAREFRESHTYPE omx;
} mmal_omx_video_intrarefresh_table[] =
{
   { MMAL_VIDEO_INTRA_REFRESH_CYCLIC,             OMX_VIDEO_IntraRefreshCyclic},
   { MMAL_VIDEO_INTRA_REFRESH_ADAPTIVE,           OMX_VIDEO_IntraRefreshAdaptive},
   { MMAL_VIDEO_INTRA_REFRESH_BOTH,               OMX_VIDEO_IntraRefreshBoth},
   { MMAL_VIDEO_INTRA_REFRESH_KHRONOSEXTENSIONS,  OMX_VIDEO_IntraRefreshKhronosExtensions},
   { MMAL_VIDEO_INTRA_REFRESH_VENDORSTARTUNUSED,  OMX_VIDEO_IntraRefreshVendorStartUnused},
   { MMAL_VIDEO_INTRA_REFRESH_DUMMY,              OMX_VIDEO_IntraRefreshMax},
};

MMAL_VIDEO_INTRA_REFRESH_T mmalil_omx_video_intrarefresh_to_mmal(OMX_VIDEO_INTRAREFRESHTYPE omx)
{
   unsigned int i;
   for(i = 0; mmal_omx_video_intrarefresh_table[i].mmal != MMAL_VIDEO_INTRA_REFRESH_DUMMY; i++)
      if(mmal_omx_video_intrarefresh_table[i].omx == omx) break;
   return mmal_omx_video_intrarefresh_table[i].mmal;
}