OMX_ERRORTYPE StdAudioEncoderTest_AacEncoder(TEST_CTXTYPE *pCtx)
    {
        OMX_ERRORTYPE eError = OMX_ErrorNone;
        OMX_U32 nPortIndex;

        eError = StdComponentTest_SetRole(pCtx, "audio_encoder.aac");
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* For the standard AAC encoder component, there must be at least two audio domain ports. */
        if (pCtx->sPortParamAudio.nPorts < 2) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = APB + 0; input port, PCM format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying PCM input port 0 \n");
        nPortIndex = pCtx->sPortParamAudio.nStartPortNumber + 0;
        if (StdComponentTest_IsInputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonAudio_PcmPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = APB + 1; outpt port, AAC format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying AAC output port 1 \n");
        nPortIndex = pCtx->sPortParamAudio.nStartPortNumber + 1;
        if (StdComponentTest_IsOutputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonAudio_AacPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

OMX_CONF_TEST_BAIL:

        return (eError);
    }
    OMX_ERRORTYPE StdAudioMixerTest_PcmMixer(TEST_CTXTYPE *pCtx)
    {
        OMX_ERRORTYPE eError = OMX_ErrorNone;
        OMX_U32 nPortIndex, i;

        eError = StdComponentTest_SetRole(pCtx, "audio_mixer.pcm");
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = APB + 0; output port, PCM format */
        nPortIndex = pCtx->sPortParamAudio.nStartPortNumber + 0;
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying PCM output port %d \n", nPortIndex);
        if (StdComponentTest_IsOutputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonAudio_PcmPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = (APB + 1) + i; input port, PCM format */
        for (i = 1; i < pCtx->sPortParamAudio.nPorts; i++)
        {
            nPortIndex = pCtx->sPortParamAudio.nStartPortNumber + i;
            OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying PCM input port %d \n", nPortIndex);
            if (StdComponentTest_IsInputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
            OMX_CONF_BAIL_ON_ERROR(eError);
            eError = StdCompCommonAudio_PcmPortParameters(pCtx, nPortIndex);
            OMX_CONF_BAIL_ON_ERROR(eError);
        }

OMX_CONF_TEST_BAIL:

        return (eError);
    }
    OMX_ERRORTYPE StdVideoEncoderTest_AvcEncoder(TEST_CTXTYPE *pCtx)
    {
        OMX_ERRORTYPE eError = OMX_ErrorNone;
        OMX_U32 nPortIndex;

        eError = StdComponentTest_SetRole(pCtx, "video_encoder.avc");
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* For the standard AVC encoder component, there must be at least two video domain ports. */
        if (pCtx->sPortParamVideo.nPorts < 2) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = VPB + 0; input port, raw video format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying Raw video input port 0 \n");
        nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 0;
        if (StdComponentTest_IsInputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonVideo_RawPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = VPB + 1; output port, AVC format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying AVC output port 1 \n");
        nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 1;
        if (StdComponentTest_IsOutputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonVideo_AvcPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);


OMX_CONF_TEST_BAIL:

        return (eError);
    }
    OMX_ERRORTYPE StdIVRendererTest_RgbOverlay(TEST_CTXTYPE *pCtx)
    {
        OMX_ERRORTYPE eError = OMX_ErrorNone;
        OMX_U32 nPortIndex;

        eError = StdComponentTest_SetRole(pCtx, "iv_renderer.rgb.overlay");
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* For the standard RGB overlay image/video renderer component, there must be at least one video domain ports. */
        if (pCtx->sPortParamVideo.nPorts < 1) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = VPB + 0; input port, rgb format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying RGB input port 0 \n");
        nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 0;
        OMX_CONF_BAIL_ON_ERROR(eError);
        if (StdComponentTest_IsInputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonVideo_QcifPlusPortParameters(pCtx, nPortIndex, OMX_COLOR_Format16bitRGB565);
        OMX_CONF_BAIL_ON_ERROR(eError);

OMX_CONF_TEST_BAIL:

        return (eError);
    }
    OMX_ERRORTYPE StdImageDecoderTest_JpegDecoder(TEST_CTXTYPE *pCtx)
    {
        OMX_ERRORTYPE eError = OMX_ErrorNone;
        OMX_U32 nPortIndex;

        eError = StdComponentTest_SetRole(pCtx, "image_decoder.jpeg");
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* For the standard JPEG decoder component, there must be at least two image domain ports. */
        if (pCtx->sPortParamImage.nPorts < 2) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = IPB + 0; input port, JPEG format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying JPEG input port 0 \n");
        nPortIndex = pCtx->sPortParamImage.nStartPortNumber + 0;
        OMX_CONF_BAIL_ON_ERROR(eError);
        if (StdComponentTest_IsInputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonImage_JpegPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = IPB + 1; output port, raw image format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying Raw image output port 1 \n");
        nPortIndex = pCtx->sPortParamImage.nStartPortNumber + 1;
        if (StdComponentTest_IsOutputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonImage_RawPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

OMX_CONF_TEST_BAIL:

        return (eError);
    }
    OMX_ERRORTYPE StdContainerDemuxerTest_RealDemuxer(TEST_CTXTYPE *pCtx)
    {
        OMX_ERRORTYPE eError = OMX_ErrorNone;
        OMX_U32 nPortIndex;

        eError = StdComponentTest_SetRole(pCtx, "container_demuxer.real");
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* For the standard Real Container Demuxer component, there must be at least
           one port each of the audio, video and other domains. */
        if (pCtx->sPortParamAudio.nPorts < 1) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        if (pCtx->sPortParamVideo.nPorts < 1) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        if (pCtx->sPortParamOther.nPorts < 1) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = APB + 0; Output port, PCM format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying PCM output port 0 \n");
        nPortIndex = pCtx->sPortParamAudio.nStartPortNumber + 0;
        if (StdComponentTest_IsOutputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonAudio_PcmPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* TO DO: Verify additional support for some additional configs. */
        /* OMX_IndexConfigAudioVolume, OMX_IndexConfigAudioMute */
        /* Also need to verify the default value for bInterleaved (OMX_IndexParamAudioPcm). */

        /* Verify - Port Index = VPB + 0; output port, raw format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying Raw video output port 0 \n");
        nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 0;
        if (StdComponentTest_IsOutputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonVideo_RawPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = OPB + 0; input port, OTHER format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying other (media time) input port 0 \n");
        nPortIndex = pCtx->sPortParamOther.nStartPortNumber + 0;
        if (StdComponentTest_IsInputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonOther_OtherPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

OMX_CONF_TEST_BAIL:

        return (eError);
    }
    OMX_ERRORTYPE StdWriterTest_BinaryVideoWriter(TEST_CTXTYPE *pCtx)
    {
        OMX_ERRORTYPE eError = OMX_ErrorNone;
        OMX_U32 nPortIndex;

        eError = StdComponentTest_SetRole(pCtx, "video_writer.binary");
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* For the standard binary video writer component, there must be at least one video domain port. */
        if (pCtx->sPortParamVideo.nPorts < 1) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = VPB + 0; output port */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying OMX_VIDEOPORTBASE + 0 is input port \n\n");
        nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 0;
        if (StdComponentTest_IsInputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdComponentTest_StdPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

OMX_CONF_TEST_BAIL:
        return (eError);
    }
    OMX_ERRORTYPE StdVideoEncoderTest_Mpeg4Encoder(TEST_CTXTYPE *pCtx)
    {
        OMX_ERRORTYPE eError = OMX_ErrorNone;
        OMX_U32 nPortIndex;

        OMX_CONFIG_FRAMERATETYPE sVideoFrameRate;
        OMX_VIDEO_CONFIG_BITRATETYPE sVideoBitRate;

        OMX_CONF_INIT_STRUCT(sVideoFrameRate, OMX_CONFIG_FRAMERATETYPE);
        OMX_CONF_INIT_STRUCT(sVideoBitRate, OMX_VIDEO_CONFIG_BITRATETYPE);

        eError = StdComponentTest_SetRole(pCtx, "video_encoder.mpeg4");
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* For the standard MPEG4 encoder component, there must be at least two video domain ports. */
        if (pCtx->sPortParamVideo.nPorts < 2) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = VPB + 0; input port, raw video format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying Raw video input port 0 \n");
        nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 0;
        if (StdComponentTest_IsInputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonVideo_RawPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = VPB + 1; output port, MPEG4 format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying MPEG4 output port 1 \n");
        nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 1;
        if (StdComponentTest_IsOutputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonVideo_Mpeg4PortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify support for OMX_IndexConfigVideoFramerate and verify the default value. */
        sVideoFrameRate.nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 1;
        eError = OMX_GetConfig(pCtx->hWrappedComp, OMX_IndexConfigVideoFramerate, (OMX_PTR) & sVideoFrameRate);
        if (sVideoFrameRate.xEncodeFramerate != (15 << 16))
            eError = OMX_ErrorBadParameter;  // OMX_ErrorBadPortFormatEncoding
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify this value can be changed.*/
        OMX_CONF_CONFIG_READ_WRITE_VERIFY(pCtx, OMX_IndexConfigVideoFramerate,
                                          (OMX_PTR)&sVideoFrameRate,
                                          sVideoFrameRate.xEncodeFramerate,
                                          (5 << 16), (10 << 16), eError);

        /* Verify support for OMX_IndexConfigVideoBitrate and verify the default value. */
        sVideoBitRate.nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 1;
        eError = OMX_GetConfig(pCtx->hWrappedComp, OMX_IndexConfigVideoBitrate, (OMX_PTR) & sVideoBitRate);
        if (sVideoBitRate.nEncodeBitrate != 64000)
            eError = OMX_ErrorBadParameter;  // OMX_ErrorBadPortFormatEncoding
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify this value can be changed.*/
        OMX_CONF_CONFIG_READ_WRITE_VERIFY(pCtx, OMX_IndexConfigVideoBitrate,
                                          (OMX_PTR)&sVideoBitRate,
                                          sVideoBitRate.nEncodeBitrate,
                                          32000, 11111, eError);

OMX_CONF_TEST_BAIL:

        return (eError);
    }
    OMX_ERRORTYPE StdContainerDemuxerTest_3GpDemuxer(TEST_CTXTYPE *pCtx)
    {
        OMX_ERRORTYPE eError = OMX_ErrorNone;
        OMX_U32 nPortIndex;
        OMX_PARAM_U32TYPE sTestParam;

        OMX_CONF_INIT_STRUCT(sTestParam, OMX_PARAM_U32TYPE);

        eError = StdComponentTest_SetRole(pCtx, "container_demuxer.3gp");
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* For the standard 3GP Container Demuxer component, there must be at least
           one port each of the audio, video and other domains. */
        if (pCtx->sPortParamAudio.nPorts < 1) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        if (pCtx->sPortParamVideo.nPorts < 1) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        if (pCtx->sPortParamOther.nPorts < 1) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = APB + 0; Output port, format? */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying PCM output port 0 \n");
        nPortIndex = pCtx->sPortParamAudio.nStartPortNumber + 0;
        if (StdComponentTest_IsOutputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonOther_ContainerDemuxerPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify addition APB+0 settings
           No defaults mentioned in the specification. Verify access.
        */
        sTestParam.nPortIndex = pCtx->sPortParamAudio.nStartPortNumber + 0;
        OMX_CONF_PARAM_REQUIREDGETSET(pCtx, OMX_IndexParamActiveStream,
                                      (OMX_PTR)&sTestParam, eError);
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = OMX_GetParameter(pCtx, OMX_IndexParamNumAvailableStreams,
                                  (OMX_PTR) & sTestParam);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = VPB + 0; output port, format? */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying Raw video output port 0 \n");
        nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 0;
        if (StdComponentTest_IsOutputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonOther_ContainerDemuxerPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify addition VPB+0 settings
           No defaults mentioned in the specification. Verify access.
        */
        sTestParam.nPortIndex = pCtx->sPortParamVideo.nStartPortNumber + 0;
        OMX_CONF_PARAM_REQUIREDGETSET(pCtx, OMX_IndexParamActiveStream,
                                      (OMX_PTR)&sTestParam, eError);
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = OMX_GetParameter(pCtx, OMX_IndexParamNumAvailableStreams,
                                  (OMX_PTR) & sTestParam);
        OMX_CONF_BAIL_ON_ERROR(eError);

        /* Verify - Port Index = OPB + 0; input port, OTHER format */
        OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying other (media time) input port 0 \n");
        nPortIndex = pCtx->sPortParamOther.nStartPortNumber + 0;
        if (StdComponentTest_IsInputPort(pCtx, nPortIndex) == OMX_FALSE) eError = OMX_ErrorUndefined;
        OMX_CONF_BAIL_ON_ERROR(eError);
        eError = StdCompCommonOther_OtherPortParameters(pCtx, nPortIndex);
        eError = StdCompCommonOther_ContainerDemuxerPortParameters(pCtx, nPortIndex);
        OMX_CONF_BAIL_ON_ERROR(eError);

OMX_CONF_TEST_BAIL:

        return (eError);
    }