xref: /frameworks/av/libvideoeditor/vss/src/M4READER_Amr.c

/*
 * Copyright (C) 2004-2011 NXP Software
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 ************************************************************************
 * @file   M4READER_Amr.c
 * @brief  Generic encapsulation of the core amr reader
 * @note   This file implements the generic M4READER interface
 *         on top of the AMR reader
 ************************************************************************
*/
#include "M4OSA_Types.h"
#include "M4OSA_Error.h"
#include "M4OSA_Memory.h"
#include "M4OSA_Debug.h"
#include "M4OSA_CoreID.h"

#include "M4_Utils.h"

#include "M4AMRR_CoreReader.h"
#include "M4READER_Amr.h"

/**
 ************************************************************************
 * structure    M4READER_AMR_Context
 * @brief       This structure defines the internal context of a amr reader instance
 * @note        The context is allocated and de-allocated by the reader
 ************************************************************************
*/
typedef struct _M4READER_AMR_Context
{
    M4OSA_Context           m_pCoreContext;     /**< core amr reader context */
    M4_AudioStreamHandler*  m_pAudioStream;     /**< pointer on the audio stream
                                                 description returned by the core */
    M4SYS_AccessUnit        m_audioAu;          /**< audio access unit to be filled by the core */
    M4OSA_Time              m_maxDuration;      /**< duration of the audio stream */
    M4OSA_FileReadPointer*    m_pOsaFileReaderFcts;    /**< OSAL file read functions */

} M4READER_AMR_Context;


/**
 ************************************************************************
 * @brief    create an instance of the reader
 * @note     allocates the context
 * @param    pContext:        (OUT)    pointer on a reader context
 * @return    M4NO_ERROR                 there is no error
 * @return    M4ERR_ALLOC                a memory allocation has failed
 * @return    M4ERR_PARAMETER            at least one parameter is not properly set (in DEBUG only)
 ************************************************************************
*/
M4OSA_ERR M4READER_AMR_create(M4OSA_Context *pContext)
{
    M4READER_AMR_Context* pReaderContext;

    /* Check function parameters */
    M4OSA_DEBUG_IF1((pContext == 0), M4ERR_PARAMETER,
         "M4READER_AMR_create: invalid context pointer");

    pReaderContext = (M4READER_AMR_Context*)M4OSA_32bitAlignedMalloc(sizeof(M4READER_AMR_Context),
         M4READER_AMR, (M4OSA_Char *)"M4READER_AMR_Context");
    if (pReaderContext == M4OSA_NULL)
    {
        return M4ERR_ALLOC;
    }

    pReaderContext->m_pAudioStream  = M4OSA_NULL;
    pReaderContext->m_audioAu.dataAddress = M4OSA_NULL;
    M4OSA_INT64_FROM_INT32(pReaderContext->m_maxDuration, 0);
    pReaderContext->m_pCoreContext = M4OSA_NULL;
    pReaderContext->m_pOsaFileReaderFcts = M4OSA_NULL;

    *pContext = pReaderContext;

    return M4NO_ERROR;
}

/**
 ************************************************************************
 * @brief    destroy the instance of the reader
 * @note     after this call the context is invalid
 *
 * @param    context:        (IN)    Context of the reader
 *
 * @return    M4NO_ERROR                 there is no error
 * @return    M4ERR_PARAMETER            at least one parameter is not properly set
 ************************************************************************
*/
M4OSA_ERR M4READER_AMR_destroy(M4OSA_Context context)
{
    M4READER_AMR_Context*   pC=(M4READER_AMR_Context*)context;

    /* Check function parameters*/
    M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
         "M4READER_AMR_destroy: invalid context pointer");

    /**
     *    Check input parameter */
    if (M4OSA_NULL == pC)
    {
        M4OSA_TRACE1_0("M4READER_AMR_destroy(): M4READER_AMR_destroy: context is M4OSA_NULL,\
             returning M4ERR_PARAMETER");
        return M4ERR_PARAMETER;
    }

    free(pC);

    return M4NO_ERROR;
}


/**
 ************************************************************************
 * @brief    open the reader and initializes its created instance
 * @note     this function opens the AMR file
 * @param    context:            (IN)    Context of the reader
 * @param    pFileDescriptor:    (IN)    Pointer to proprietary data identifying the media to open
 * @return    M4NO_ERROR                     there is no error
 * @return    M4ERR_PARAMETER                the context is NULL
 * @return    M4ERR_BAD_CONTEXT            provided context is not a valid one
 ************************************************************************
*/
M4OSA_ERR M4READER_AMR_open(M4OSA_Context context, M4OSA_Void* pFileDescriptor)
{
    M4READER_AMR_Context*    pC = (M4READER_AMR_Context*)context;
    M4OSA_ERR                err;

    /* Check function parameters*/
    M4OSA_DEBUG_IF1((M4OSA_NULL == pC),              M4ERR_PARAMETER,
         "M4READER_AMR_open: invalid context pointer");
    M4OSA_DEBUG_IF1((M4OSA_NULL == pFileDescriptor), M4ERR_PARAMETER,
         "M4READER_AMR_open: invalid pointer pFileDescriptor");

    err = M4AMRR_openRead( &pC->m_pCoreContext, pFileDescriptor, pC->m_pOsaFileReaderFcts);

    return err;
}



/**
 ************************************************************************
 * @brief    close the reader
 * @note
 * @param    context:        (IN)    Context of the reader
 * @return    M4NO_ERROR                 there is no error
 * @return    M4ERR_PARAMETER            the context is NULL
 * @return    M4ERR_BAD_CONTEXT        provided context is not a valid one
 ************************************************************************
*/
M4OSA_ERR   M4READER_AMR_close(M4OSA_Context context)
{
    M4READER_AMR_Context*    pC = (M4READER_AMR_Context*)context;
    M4OSA_ERR                err;
    M4AMRR_State State;

    /* Check function parameters*/
    M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
         "M4READER_AMR_close: invalid context pointer");

    /**
     *    Check input parameter */
    if (M4OSA_NULL == pC)
    {
        M4OSA_TRACE1_0("M4READER_AMR_close(): M4READER_AMR_close: context is M4OSA_NULL,\
             returning M4ERR_PARAMETER");
        return M4ERR_PARAMETER;
    }

    if (M4OSA_NULL != pC->m_pAudioStream)
    {
        err = M4AMRR_getState(pC->m_pCoreContext, &State,
                ((M4_StreamHandler*)pC->m_pAudioStream)->m_streamId);
        if(M4NO_ERROR != err)
        {
            M4OSA_TRACE1_0("M4READER_AMR_close: error when calling M4AMRR_getState\n");
            return err;
        }

        if (M4AMRR_kReading_nextAU == State)
        {
            err = M4AMRR_freeAU(pC->m_pCoreContext,
                ((M4_StreamHandler*)pC->m_pAudioStream)->m_streamId,  &pC->m_audioAu);
            if (err != M4NO_ERROR)
            {
                M4OSA_TRACE1_0("M4READER_AMR_close: error when freeing access unit\n");
                return err;
            }
        }

        /* Delete the DSI if needed */
        if(M4OSA_NULL != pC->m_pAudioStream->m_basicProperties.m_pDecoderSpecificInfo)
        {
            free(\
                pC->m_pAudioStream->m_basicProperties.m_pDecoderSpecificInfo);

            pC->m_pAudioStream->m_basicProperties.m_decoderSpecificInfoSize = 0;
            pC->m_pAudioStream->m_basicProperties.m_pDecoderSpecificInfo = M4OSA_NULL;
        }

        /* Finally destroy the stream handler */
        free(pC->m_pAudioStream);
        pC->m_pAudioStream = M4OSA_NULL;
    }

    if (M4OSA_NULL != pC->m_pCoreContext)
    {
        err = M4AMRR_closeRead(pC->m_pCoreContext);
        pC->m_pCoreContext = M4OSA_NULL;
    }

    return err;
}

/**
 ************************************************************************
 * @brief    Get the next stream found in the media
 * @note    current version needs to translate M4SYS_Stream to M4_StreamHandler
 *
 * @param    context:        (IN)   Context of the reader
 * @param    pMediaFamily:   (OUT)  pointer to a user allocated M4READER_MediaFamily
 *                                  that will be filled with the media family of the found stream
 * @param    pStreamHandler: (OUT)  pointer to a stream handler that will be
 *                                  allocated and filled with the found stream description
 *
 * @return    M4NO_ERROR            there is no error
 * @return    M4WAR_NO_MORE_STREAM  no more available stream in the media (all streams found)
 * @return    M4ERR_PARAMETER       at least one parameter is not properly set (in DEBUG mode only)
 ************************************************************************
*/
M4OSA_ERR M4READER_AMR_getNextStream(M4OSA_Context context, M4READER_MediaFamily *pMediaFamily,
                                     M4_StreamHandler **pStreamHandlerParam)
{
    M4READER_AMR_Context*   pC=(M4READER_AMR_Context*)context;
    M4OSA_ERR               err;
    M4SYS_StreamID          streamIdArray[2];
    M4SYS_StreamDescription streamDesc;
    M4_AudioStreamHandler*  pAudioStreamHandler;
    M4_StreamHandler*       pStreamHandler;

    M4OSA_DEBUG_IF1((pC == 0),                  M4ERR_PARAMETER,
                "M4READER_AMR_getNextStream: invalid context");
    M4OSA_DEBUG_IF1((pMediaFamily == 0),        M4ERR_PARAMETER,
                "M4READER_AMR_getNextStream: invalid pointer to MediaFamily");
    M4OSA_DEBUG_IF1((pStreamHandlerParam == 0), M4ERR_PARAMETER,
                "M4READER_AMR_getNextStream: invalid pointer to StreamHandler");

    err = M4AMRR_getNextStream( pC->m_pCoreContext, &streamDesc);
    if (err == M4WAR_NO_MORE_STREAM)
    {
        streamIdArray[0] = 0;
        streamIdArray[1] = 0;
        err = M4AMRR_startReading(pC->m_pCoreContext, streamIdArray);
        if ((M4OSA_UInt32)M4ERR_ALLOC == err)
        {
            M4OSA_TRACE2_0("M4READER_AMR_getNextStream: M4AMRR_startReading returns M4ERR_ALLOC!");
            return err;
        }
        return M4WAR_NO_MORE_STREAM;
    }
    else if (err != M4NO_ERROR)
    {
        return err;
    }

    *pMediaFamily = M4READER_kMediaFamilyAudio;

    pAudioStreamHandler = (M4_AudioStreamHandler*)M4OSA_32bitAlignedMalloc(sizeof(M4_AudioStreamHandler),
                        M4READER_AMR, (M4OSA_Char *)"M4_AudioStreamHandler");
    if (pAudioStreamHandler == M4OSA_NULL)
    {
        return M4ERR_ALLOC;
    }
    pStreamHandler =(M4_StreamHandler*)(pAudioStreamHandler);
    *pStreamHandlerParam = pStreamHandler;
    pC->m_pAudioStream = pAudioStreamHandler;

    pAudioStreamHandler->m_structSize = sizeof(M4_AudioStreamHandler);

    /*
     * Audio stream handler fields are initialised with 0 value.
     * They will be properly set by the AMR decoder
     */
    pAudioStreamHandler->m_samplingFrequency = 0;
    pAudioStreamHandler->m_byteFrameLength   = 0;
    pAudioStreamHandler->m_byteSampleSize    = 0;
    pAudioStreamHandler->m_nbChannels        = 0;

    pStreamHandler->m_pDecoderSpecificInfo    = (M4OSA_UInt8*)(streamDesc.decoderSpecificInfo);
    pStreamHandler->m_decoderSpecificInfoSize = streamDesc.decoderSpecificInfoSize;
    pStreamHandler->m_streamId                = streamDesc.streamID;
 // M4OSA_INT64_FROM_DOUBLE(pStreamHandler->m_duration,
 // (M4OSA_Double)(((M4OSA_Float)streamDesc.duration*1000/(M4OSA_Float)(streamDesc.timeScale))));
    pStreamHandler->m_duration                = streamDesc.duration;
    pStreamHandler->m_pUserData               = (void*)streamDesc.timeScale; /*trick to change*/

    if (M4OSA_TIME_COMPARE(streamDesc.duration, pC->m_maxDuration) > 0)
    {
        M4OSA_TIME_SET(pC->m_maxDuration, streamDesc.duration);
    }
    pStreamHandler->m_averageBitRate          = streamDesc.averageBitrate;

    M4AMRR_getmaxAUsize(pC->m_pCoreContext, &pStreamHandler->m_maxAUSize);

    switch (streamDesc.streamType)
    {
    case M4SYS_kAMR:
        pStreamHandler->m_streamType = M4DA_StreamTypeAudioAmrNarrowBand;
        break;
    case M4SYS_kAMR_WB:
        pStreamHandler->m_streamType = M4DA_StreamTypeAudioAmrWideBand;
        break;
    default:
        break;
    }

    return err;
}

/**
 ************************************************************************
 * @brief    fill the access unit structure with initialization values
 * @note
 * @param    context:        (IN)     Context of the reader
 * @param    pStreamHandler: (IN)     pointer to the stream handler to
 *                                    which the access unit will be associated
 * @param    pAccessUnit:    (IN/OUT) pointer to the access unit (allocated by the caller)
 *                                      to initialize
 *
 * @return    M4NO_ERROR              there is no error
 * @return    M4ERR_PARAMETER         at least one parameter is not properly set
 ************************************************************************
*/
M4OSA_ERR M4READER_AMR_fillAuStruct(M4OSA_Context context, M4_StreamHandler *pStreamHandler,
                                     M4_AccessUnit *pAccessUnit)
{
    M4READER_AMR_Context*   pC = (M4READER_AMR_Context*)context;
    M4SYS_AccessUnit*       pAu;

    M4OSA_DEBUG_IF1((pC == 0),             M4ERR_PARAMETER,
         "M4READER_AMR_fillAuStruct: invalid context");
    M4OSA_DEBUG_IF1((pStreamHandler == 0), M4ERR_PARAMETER,
         "M4READER_AMR_fillAuStruct: invalid pointer to M4_StreamHandler");
    M4OSA_DEBUG_IF1((pAccessUnit == 0),    M4ERR_PARAMETER,
         "M4READER_AMR_fillAuStruct: invalid pointer to M4_AccessUnit");

    if (pStreamHandler == (M4_StreamHandler*)pC->m_pAudioStream)
    {
        pAu = &pC->m_audioAu;
    }
    else
    {
        M4OSA_TRACE1_0("M4READER_AMR_fillAuStruct: passed StreamHandler is not known\n");
        return M4ERR_PARAMETER;
    }

    pAu->dataAddress = M4OSA_NULL;
    pAu->size        = 0;
    /* JC: bug fix 1197 (set CTS to -20 in order the first AU CTS is 0) */
    pAu->CTS         = -20;
    pAu->DTS         = -20;
    pAu->attribute   = 0;
    pAu->nbFrag      = 0;

    pAccessUnit->m_size         = 0;
    /* JC: bug fix 1197 (set CTS to -20 in order the first AU CTS is 0) */
    pAccessUnit->m_CTS          = -20;
    pAccessUnit->m_DTS          = -20;
    pAccessUnit->m_attribute    = 0;
    pAccessUnit->m_dataAddress  = M4OSA_NULL;/*pBuffer;*/
    pAccessUnit->m_maxsize      = pStreamHandler->m_maxAUSize;
    pAccessUnit->m_streamID     = pStreamHandler->m_streamId;
    pAccessUnit->m_structSize   = sizeof(M4_AccessUnit);

    return M4NO_ERROR;
}

/**
 ************************************************************************
 * @brief    get an option value from the reader
 * @note    this function follows the set/get option mechanism described in OSAL 3.0
 *          it allows the caller to retrieve a property value:
 *          - the duration of the longest stream of the media
 *          - the version number of the reader (not implemented yet)
 *
 * @param    context:        (IN)    Context of the reader
 * @param    optionId:        (IN)    indicates the option to get
 * @param    pValue:            (OUT)    pointer to structure or value (allocated by user)
 *                                       where option is stored
 *
 * @return    M4NO_ERROR                 there is no error
 * @return    M4ERR_PARAMETER            at least one parameter is not properly set
 * @return    M4ERR_BAD_OPTION_ID        when the option ID is not a valid one
 ************************************************************************
*/
M4OSA_ERR M4READER_AMR_getOption(M4OSA_Context context, M4OSA_OptionID optionId,
                                 M4OSA_DataOption pValue)

{
    M4READER_AMR_Context* pC = (M4READER_AMR_Context*)context;
    M4OSA_ERR err = M4NO_ERROR;

    /* Check function parameters */
    M4OSA_DEBUG_IF1((M4OSA_NULL == pC),     M4ERR_PARAMETER, "invalid context pointer");
    M4OSA_DEBUG_IF1((M4OSA_NULL == pValue), M4ERR_PARAMETER, "invalid value pointer");

    switch(optionId)
    {
    case M4READER_kOptionID_Duration :
        {
            M4OSA_TIME_SET(*(M4OSA_Time*)pValue, pC->m_maxDuration);
        }
        break;

    case M4READER_kOptionID_Bitrate:
        {
            M4OSA_UInt32* pBitrate = (M4OSA_UInt32*)pValue;
            if (M4OSA_NULL != pC->m_pAudioStream)
            {
                *pBitrate = pC->m_pAudioStream->m_basicProperties.m_averageBitRate;
            }
            else
            {
                pBitrate = 0;
                err = M4ERR_PARAMETER;
            }

        }
        break;
    case M4READER_kOptionID_Version:
        {
            err = M4AMRR_getVersion((M4_VersionInfo*)pValue);
        }
        break;

    default :
        {
            err = M4ERR_PARAMETER;
        }
    }

    return err;
}

/**
 ************************************************************************
 * @brief   set en option value of the readder
 * @note    this function follows the set/get option mechanism described in OSAL 3.0
 *          it allows the caller to set a property value:
 *          - the OSAL file read functions
 *
 * @param   context:    (IN)        Context of the decoder
 * @param   optionId:   (IN)        Identifier indicating the option to set
 * @param   pValue:     (IN)        Pointer to structure or value (allocated by user)
 *                                  where option is stored
 *
 * @return  M4NO_ERROR              There is no error
 * @return  M4ERR_BAD_OPTION_ID     The option ID is not a valid one
 * @return  M4ERR_STATE             State automaton is not applied
 * @return  M4ERR_PARAMETER         The option parameter is invalid
 ************************************************************************
*/
M4OSA_ERR M4READER_AMR_setOption(M4OSA_Context context, M4OSA_OptionID optionId,
                                 M4OSA_DataOption pValue)
{
    M4READER_AMR_Context* pC = (M4READER_AMR_Context*)context;
    M4OSA_ERR err = M4NO_ERROR;

    /* Check function parameters */
    M4OSA_DEBUG_IF1((M4OSA_NULL == pC),     M4ERR_PARAMETER, "invalid context pointer");
    M4OSA_DEBUG_IF1((M4OSA_NULL == pValue), M4ERR_PARAMETER, "invalid value pointer");

    switch(optionId)
    {
    case M4READER_kOptionID_SetOsaFileReaderFctsPtr :
        {
            pC->m_pOsaFileReaderFcts = (M4OSA_FileReadPointer*)pValue;
        }
        break;
    default :
        {
            err = M4ERR_PARAMETER;
        }
    }

    return err;
}

/**
 ************************************************************************
 * @brief    reset the stream, that is seek it to beginning and make it ready to be read
 * @note    this function is to be deprecated in next versions
 *
 * @param    context:        (IN)    Context of the reader
 * @param    pStreamHandler    (IN)    The stream handler of the stream to reset
 *
 * @return    M4NO_ERROR                 there is no error
 * @return    M4ERR_PARAMETER            at least one parameter is not properly set
 * @return    M4ERR_ALLOC                there is no more memory available
 * @return    M4ERR_BAD_STREAM_ID        the streamID does not exist
 * @return    M4ERR_STATE    this function cannot be called now
 * @return    M4ERR_BAD_CONTEXT        provided context is not a valid one
 * @return    M4WAR_INVALID_TIME        beginning of the stream can not be reached
 ************************************************************************
*/
M4OSA_ERR M4READER_AMR_reset(M4OSA_Context context, M4_StreamHandler *pStreamHandler)
{
    M4READER_AMR_Context*   pC = (M4READER_AMR_Context*)context;
    M4SYS_StreamID          streamIdArray[2];
    M4OSA_ERR               err;
    M4SYS_AccessUnit*       pAu;
    M4OSA_Time                time64;
    M4AMRR_State            State;

    M4OSA_DEBUG_IF1((pC == 0), M4ERR_PARAMETER, "M4READER_AMR_reset: invalid context");
    M4OSA_DEBUG_IF1((pStreamHandler == 0), M4ERR_PARAMETER,
         "M4READER_AMR_reset: invalid pointer to M4_StreamHandler");

    M4OSA_INT64_FROM_INT32(time64, 0);

    if (pStreamHandler == (M4_StreamHandler*)pC->m_pAudioStream)
    {
        pAu = &pC->m_audioAu;
    }
    else
    {
        M4OSA_TRACE1_0("M4READER_AMR_reset: passed StreamHandler is not known\n");
        return M4ERR_PARAMETER;
    }

    err = M4AMRR_getState(pC->m_pCoreContext, &State, pStreamHandler->m_streamId);
    if (M4AMRR_kReading_nextAU == State)
    {
        err = M4AMRR_freeAU(pC->m_pCoreContext, pStreamHandler->m_streamId, pAu);
        if (err != M4NO_ERROR)
        {
            M4OSA_TRACE1_0("M4READER_AMR_reset: error when freeing access unit\n");
            return err;
        }
        pAu->dataAddress = M4OSA_NULL;
    }

    streamIdArray[0] = pStreamHandler->m_streamId;
    streamIdArray[1] = 0;

    err = M4NO_ERROR;

    /* for reset during playback */
    /* (set CTS to -20 in order the first AU CTS is 0) */
    pAu->CTS = -20;
    pAu->DTS = -20;

    err = M4AMRR_seek(pC->m_pCoreContext, streamIdArray, time64, M4SYS_kBeginning, &time64);
    if (err != M4NO_ERROR)
    {
        M4OSA_TRACE1_0("M4READER_AMR_reset: error when calling M4AMRR_seek()\n");
        return err;
    }

    return err;
}

/**
 ************************************************************************
 * @brief    jump into the stream at the specified time
 * @note
 * @param    context:        (IN)     Context of the reader
 * @param    pStreamHandler    (IN)     the stream description of the stream to make jump
 * @param    pTime            (IN/OUT) IN:  the time to jump to (in ms)
 *                                     OUT: the time to which the stream really jumped
 * @return    M4NO_ERROR                 there is no error
 * @return    M4ERR_BAD_CONTEXT        provided context is not a valid one
 * @return    M4ERR_PARAMETER            at least one parameter is not properly set
 * @return    M4ERR_ALLOC                there is no more memory available
 * @return    M4WAR_INVALID_TIME        the time can not be reached
 ************************************************************************
*/
M4OSA_ERR M4READER_AMR_jump(M4OSA_Context context, M4_StreamHandler *pStreamHandler,
                             M4OSA_Int32* pTime)
{
    M4READER_AMR_Context*   pC = (M4READER_AMR_Context*)context;
    M4SYS_StreamID          streamIdArray[2];
    M4OSA_ERR               err;
    M4SYS_AccessUnit*       pAu;
    M4OSA_Time                time64;
    M4OSA_Double            timeDouble; /*used for type conversion only*/
    M4AMRR_State            State;

    M4OSA_DEBUG_IF1((pC == 0), M4ERR_PARAMETER, "M4READER_AMR_reset: invalid context");
    M4OSA_DEBUG_IF1((pStreamHandler == 0), M4ERR_PARAMETER,
         "M4READER_AMR_reset: invalid pointer to M4_StreamHandler");
    M4OSA_DEBUG_IF1((pTime == 0), M4ERR_PARAMETER, "M4READER_3GP_jump: invalid time pointer");

    M4OSA_INT64_FROM_INT32(time64, *pTime);

    if (pStreamHandler == (M4_StreamHandler*)pC->m_pAudioStream)
    {
        pAu = &pC->m_audioAu;
    }
    else
    {
        M4OSA_TRACE1_0("M4READER_AMR_jump: passed StreamHandler is not known\n");
        return M4ERR_PARAMETER;
    }

    err = M4AMRR_getState(pC->m_pCoreContext, &State, pStreamHandler->m_streamId);
    if (M4AMRR_kReading_nextAU == State)
    {
        err = M4AMRR_freeAU(pC->m_pCoreContext, pStreamHandler->m_streamId, pAu);
        if (err != M4NO_ERROR)
        {
            M4OSA_TRACE1_0("M4READER_AMR_jump: error when freeing access unit\n");
            return err;
        }
        pAu->dataAddress = M4OSA_NULL;
    }

    streamIdArray[0] = pStreamHandler->m_streamId;
    streamIdArray[1] = 0;

    pAu->CTS = time64;
    pAu->DTS = time64;
    err = M4AMRR_seek(pC->m_pCoreContext, streamIdArray, time64, M4SYS_kNoRAPprevious, &time64);
    if (err != M4NO_ERROR)
    {
        M4OSA_TRACE1_0("M4READER_AMR_jump: error when calling M4AMRR_seek()\n");
        return err;
    }

    M4OSA_INT64_TO_DOUBLE(timeDouble, time64);
    *pTime = (M4OSA_Int32)timeDouble;

    return err;
}

/**
 ************************************************************************
 * @brief   Gets an access unit (AU) from the stream handler source.
 * @note    An AU is the smallest possible amount of data to be decoded by a decoder (audio/video).
 *          In the current version, we need to translate M4OSA_AccessUnit to M4_AccessUnit
 *
 * @param    context:        (IN)        Context of the reader
 * @param    pStreamHandler  (IN)        The stream handler of the stream to make jump
 * @param    pAccessUnit     (IN/OUT)    Pointer to an access unit to fill with read data (the au
                                         structure is allocated by the user, and must be
                                         initialized by calling M4READER_fillAuStruct_fct after
                                         creation)
 * @return    M4NO_ERROR              there is no error
 * @return    M4ERR_BAD_CONTEXT       provided context is not a valid one
 * @return    M4ERR_PARAMETER         at least one parameter is not properly set
 * @return    M4ERR_ALLOC             memory allocation failed
 * @return    M4ERR_BAD_STREAM_ID     at least one of the stream Id. does not exist.
 * @return    M4WAR_NO_MORE_AU        there are no more access unit in the stream (end of stream)
 ************************************************************************
*/
M4OSA_ERR M4READER_AMR_getNextAu(M4OSA_Context context, M4_StreamHandler *pStreamHandler,
                                M4_AccessUnit *pAccessUnit)
{
    M4READER_AMR_Context*   pC = (M4READER_AMR_Context*)context;
    M4OSA_ERR               err = M4NO_ERROR;
    M4SYS_AccessUnit*       pAu;
    M4_MediaTime            timeScale;
    M4AMRR_State            State;

    M4OSA_DEBUG_IF1((pC == 0),             M4ERR_PARAMETER,
         "M4READER_AMR_getNextAu: invalid context");
    M4OSA_DEBUG_IF1((pStreamHandler == 0), M4ERR_PARAMETER,
         "M4READER_AMR_getNextAu: invalid pointer to M4_StreamHandler");
    M4OSA_DEBUG_IF1((pAccessUnit == 0),    M4ERR_PARAMETER,
         "M4READER_AMR_getNextAu: invalid pointer to M4_AccessUnit");

    /* keep trace of the allocated buffers in AU to be able to free them at destroy()
       but be aware that system is risky and would need upgrade if more than
       one video and one audio AU is needed */
    if (pStreamHandler == (M4_StreamHandler*)pC->m_pAudioStream)
    {
        pAu = &pC->m_audioAu;
    }
    else
    {
        M4OSA_TRACE1_0("M4READER_AMR_getNextAu: passed StreamHandler is not known\n");
        return M4ERR_PARAMETER;
    }

    err = M4AMRR_getState(pC->m_pCoreContext, &State, pStreamHandler->m_streamId);
    if (M4AMRR_kReading_nextAU == State)
    {
        err = M4AMRR_freeAU(pC->m_pCoreContext, pStreamHandler->m_streamId, pAu);
        if (err != M4NO_ERROR)
        {
            M4OSA_TRACE1_0("M4READER_AVI_getNextAu: error when freeing access unit\n");
            return err;
        }
        pAu->dataAddress = M4OSA_NULL;
    }

    pAu->nbFrag = 0;
    err = M4AMRR_nextAU(pC->m_pCoreContext, pStreamHandler->m_streamId, pAu);

    if (err == M4NO_ERROR)
    {
        timeScale = (M4OSA_Float)(M4OSA_Int32)(pStreamHandler->m_pUserData)/1000;
        pAccessUnit->m_dataAddress = (M4OSA_MemAddr8)pAu->dataAddress;
        pAccessUnit->m_size = pAu->size;
        pAccessUnit->m_CTS  = (M4_MediaTime)pAu->CTS/*/timeScale*/;
        pAccessUnit->m_DTS  = (M4_MediaTime)pAu->DTS/*/timeScale*/;
        pAccessUnit->m_attribute = pAu->attribute;
    }
    else
    {
        pAccessUnit->m_size=0;
    }

    return err;
}

/**
*************************************************************************
* @brief Retrieves the generic interfaces implemented by the reader
*
* @param pMediaType          : Pointer on a M4READER_MediaType (allocated by the caller)
*                              that will be filled with the media type supported by this reader
* @param pRdrGlobalInterface : Address of a pointer that will be set to the global interface implemented
*                              by this reader. The interface is a structure allocated by the function and must
*                              be un-allocated by the caller.
* @param pRdrDataInterface   : Address of a pointer that will be set to the data interface implemented
*                              by this reader. The interface is a structure allocated by the function and must
*                              be un-allocated by the caller.
*
* @returns : M4NO_ERROR     if OK
*            ERR_ALLOC      if an allocation failed
*            ERR_PARAMETER  at least one parameter is not properly set (in DEBUG only)
*************************************************************************
*/
M4OSA_ERR   M4READER_AMR_getInterfaces(M4READER_MediaType *pMediaType,
                                         M4READER_GlobalInterface **pRdrGlobalInterface,
                                         M4READER_DataInterface **pRdrDataInterface)
{
    M4OSA_DEBUG_IF1((pMediaType == 0),          M4ERR_PARAMETER,
         "M4READER_AMR_getInterfaces: invalid pointer to MediaType");
    M4OSA_DEBUG_IF1((pRdrGlobalInterface == 0), M4ERR_PARAMETER,
         "M4READER_AMR_getInterfaces: invalid pointer to M4READER_GlobalInterface");
    M4OSA_DEBUG_IF1((pRdrDataInterface == 0),   M4ERR_PARAMETER,
         "M4READER_AMR_getInterfaces: invalid pointer to M4READER_DataInterface");

    *pRdrGlobalInterface =
         (M4READER_GlobalInterface*)M4OSA_32bitAlignedMalloc( sizeof(M4READER_GlobalInterface),
             M4READER_AMR, (M4OSA_Char *)"M4READER_GlobalInterface" );
    if (M4OSA_NULL == *pRdrGlobalInterface)
    {
        *pRdrDataInterface = M4OSA_NULL;
        return M4ERR_ALLOC;
    }
    *pRdrDataInterface = (M4READER_DataInterface*)M4OSA_32bitAlignedMalloc( sizeof(M4READER_DataInterface),
         M4READER_AMR, (M4OSA_Char *)"M4READER_DataInterface");
    if (M4OSA_NULL == *pRdrDataInterface)
    {
        free(*pRdrGlobalInterface);
        *pRdrGlobalInterface = M4OSA_NULL;
        return M4ERR_ALLOC;
    }

    *pMediaType = M4READER_kMediaTypeAMR;

    (*pRdrGlobalInterface)->m_pFctCreate           = M4READER_AMR_create;
    (*pRdrGlobalInterface)->m_pFctDestroy          = M4READER_AMR_destroy;
    (*pRdrGlobalInterface)->m_pFctOpen             = M4READER_AMR_open;
    (*pRdrGlobalInterface)->m_pFctClose            = M4READER_AMR_close;
    (*pRdrGlobalInterface)->m_pFctGetOption        = M4READER_AMR_getOption;
    (*pRdrGlobalInterface)->m_pFctSetOption        = M4READER_AMR_setOption;
    (*pRdrGlobalInterface)->m_pFctGetNextStream    = M4READER_AMR_getNextStream;
    (*pRdrGlobalInterface)->m_pFctFillAuStruct     = M4READER_AMR_fillAuStruct;
    (*pRdrGlobalInterface)->m_pFctStart            = M4OSA_NULL;
    (*pRdrGlobalInterface)->m_pFctStop             = M4OSA_NULL;
    (*pRdrGlobalInterface)->m_pFctJump             = M4READER_AMR_jump;
    (*pRdrGlobalInterface)->m_pFctReset            = M4READER_AMR_reset;
    (*pRdrGlobalInterface)->m_pFctGetPrevRapTime   = M4OSA_NULL; /*all AUs are RAP*/

    (*pRdrDataInterface)->m_pFctGetNextAu          = M4READER_AMR_getNextAu;

    (*pRdrDataInterface)->m_readerContext = M4OSA_NULL;

    return M4NO_ERROR;
}