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

/*
 * 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    M4AD_Null.c
 * @brief   Implementation of the MP3 decoder public interface
 * @note    This file implements a "null" audio decoder, that is a decoder
 *          that do nothing except getting AU from the reader
*************************************************************************
*/
#include "M4OSA_Debug.h"
#include "M4OSA_Error.h"
#include "M4OSA_Debug.h"
#include "M4TOOL_VersionInfo.h"
#include "M4AD_Common.h"
#include "M4AD_Null.h"

#define M4AD_FORCE_16BITS

/**
 ************************************************************************
 * NULL Audio Decoder version information
 ************************************************************************
*/
/* CHANGE_VERSION_HERE */
#define M4AD_NULL_MAJOR    1
#define M4AD_NULL_MINOR    1
#define M4AD_NULL_REVISION 4

/**
 ************************************************************************
 * structure    M4AD_NullContext
 * @brief        Internal null decoder context
 ************************************************************************
*/
typedef struct
{
    /**< Pointer to the stream handler provided by the user */
    M4_AudioStreamHandler*    m_pAudioStreamhandler;
} M4AD_NullContext;


/**
 ************************************************************************
 * NXP MP3 decoder functions definition
 ************************************************************************
*/

/**
 ************************************************************************
 * @brief   Creates an instance of the null decoder
 * @note    Allocates the context
 *
 * @param    pContext:        (OUT)    Context of the decoder
 * @param    pStreamHandler: (IN)    Pointer to an audio stream description
 * @param    pUserData:        (IN)    Pointer to User data
 *
 * @return    M4NO_ERROR              there is no error
 * @return    M4ERR_STATE             State automaton is not applied
 * @return    M4ERR_ALLOC             a memory allocation has failed
 * @return    M4ERR_PARAMETER         at least one parameter is not properly set (in DEBUG only)
 ************************************************************************
*/
M4OSA_ERR    M4AD_NULL_create(  M4AD_Context* pContext,
                                M4_AudioStreamHandler *pStreamHandler,
                                void* pUserData)
{
    M4AD_NullContext* pC;

    M4OSA_DEBUG_IF1((pContext == 0), M4ERR_PARAMETER,
                "M4AD_NULL_create: invalid context pointer");
    M4OSA_DEBUG_IF1((pStreamHandler == 0), M4ERR_PARAMETER,
                "M4AD_NULL_create: invalid pointer pStreamHandler");

    pC = (M4AD_NullContext*)M4OSA_32bitAlignedMalloc(sizeof(M4AD_NullContext),
                 M4DECODER_AUDIO, (M4OSA_Char *)"M4AD_NullContext");
    if (pC == (M4AD_NullContext*)0)
    {
        M4OSA_TRACE1_0("Can not allocate null decoder context");
        return M4ERR_ALLOC;
    }

    *pContext = pC;

    pC->m_pAudioStreamhandler = pStreamHandler;

    return M4NO_ERROR;
}

/**
 ************************************************************************
 * @brief    Destroys the instance of the null decoder
 * @note     After this call the context is invalid
 *
 * @param    context:    (IN)    Context of the decoder
 *
 * @return   M4NO_ERROR            There is no error
 * @return   M4ERR_PARAMETER     The context is invalid (in DEBUG only)
 ************************************************************************
*/
M4OSA_ERR    M4AD_NULL_destroy(M4AD_Context context)
{
    M4AD_NullContext* pC = (M4AD_NullContext*)context;

    M4OSA_DEBUG_IF1((context == M4OSA_NULL), M4ERR_PARAMETER, "M4AD_NULL_destroy: invalid context");

    free(pC);

    return M4NO_ERROR;
}

/**
 ************************************************************************
 * @brief   Simply output the given audio data
 * @note
 *
 * @param   context:          (IN)    Context of the decoder
 * @param   pInputBuffer:     (IN/OUT)Input Data buffer. It contains at least one audio frame.
 *                                    The size of the buffer must be updated inside the function
 *                                    to reflect the size of the actually decoded data.
 *                                    (e.g. the first frame in pInputBuffer)
 * @param   pDecodedPCMBuffer: (OUT)  Output PCM buffer (decoded data).
 * @param   jumping:           (IN)   M4OSA_TRUE if a jump was just done, M4OSA_FALSE otherwise.
 * @return    M4NO_ERROR              there is no error
 * @return    M4ERR_PARAMETER         at least one parameter is not properly set
 ************************************************************************
*/
M4OSA_ERR    M4AD_NULL_step(M4AD_Context context, M4AD_Buffer *pInputBuffer,
                            M4AD_Buffer *pDecodedPCMBuffer, M4OSA_Bool jumping)
{
    M4AD_NullContext* pC = (M4AD_NullContext*)context;

    /*The VPS sends a zero buffer at the end*/
    if (0 == pInputBuffer->m_bufferSize)
    {
        return M4WAR_NO_MORE_AU;
    }

    if (pInputBuffer->m_bufferSize > pDecodedPCMBuffer->m_bufferSize)
    {
        return M4ERR_PARAMETER;
    }
#ifdef M4AD_FORCE_16BITS
    /*if read samples are 8 bits, complete them to 16 bits*/
    if (pC->m_pAudioStreamhandler->m_byteSampleSize == 1)
    {
        M4OSA_UInt32 i;
        M4OSA_Int16  val;

        for (i = 0; i < pInputBuffer->m_bufferSize; i++)
        {
            val = (M4OSA_Int16)((M4OSA_UInt8)(pInputBuffer->m_dataAddress[i]) - 128);

            pDecodedPCMBuffer->m_dataAddress[i*2]   = (M4OSA_Int8)(val>>8);
            pDecodedPCMBuffer->m_dataAddress[i*2+1] = (M4OSA_Int8)(val&0x00ff);
        }
    }
    else
    {
        memcpy((void *)pDecodedPCMBuffer->m_dataAddress, (void *)pInputBuffer->m_dataAddress,
                    pInputBuffer->m_bufferSize );
    }
#else /*M4AD_FORCE_16BITS*/
    memcpy((void *)pDecodedPCMBuffer->m_dataAddress, (void *)pInputBuffer->m_dataAddress,
                    pInputBuffer->m_bufferSize );
#endif /*M4AD_FORCE_16BITS*/

    return M4NO_ERROR;
}

/**
 ************************************************************************
 * @brief   Gets the decoder version
 * @note    The version is given in a M4_VersionInfo structure
 *
 * @param   pValue:     (OUT)       Pointer to the version structure
 *
 * @return  M4NO_ERROR              there is no error
 * @return  M4ERR_PARAMETER         pVersionInfo pointer is null (in DEBUG only)
 ************************************************************************
*/
M4OSA_ERR    M4AD_NULL_getVersion(M4_VersionInfo* pVersionInfo)
{
    M4OSA_ERR err = M4NO_ERROR;
    M4OSA_DEBUG_IF1((pVersionInfo == 0), M4ERR_PARAMETER,
        "M4AD_NULL_getVersion: invalid pointer pVersionInfo");

    /* Up until now, the null decoder version is not available */

    /* CHANGE_VERSION_HERE */
    pVersionInfo->m_major        = M4AD_NULL_MAJOR;      /*major version of the component*/
    pVersionInfo->m_minor        = M4AD_NULL_MINOR;      /*minor version of the component*/
    pVersionInfo->m_revision    = M4AD_NULL_REVISION;    /*revision version of the component*/
    pVersionInfo->m_structSize=sizeof(M4_VersionInfo);

    return err;
}


/**
 ************************************************************************
 * getInterface function definitions of NXP MP3 decoder
 ************************************************************************
*/

/**
 ************************************************************************
 * @brief Retrieves the interface implemented by the decoder
 * @param pDecoderType        : pointer on an M4AD_Type (allocated by the caller)
 *                              that will be filled with the decoder type supported by
 *                              this decoder
 * @param pDecoderInterface   : address of a pointer that will be set to the interface
 *                              implemented by this decoder. The interface is a structure
 *                              allocated by the function and must be un-allocated by the
 *                              caller.
 *
 * @return    M4NO_ERROR  if OK
 * @return    M4ERR_ALLOC if allocation failed
 ************************************************************************
*/
M4OSA_ERR M4AD_NULL_getInterface( M4AD_Type *pDecoderType, M4AD_Interface **pDecoderInterface)
{
    *pDecoderInterface = (  M4AD_Interface*)M4OSA_32bitAlignedMalloc( sizeof(M4AD_Interface),
                            M4DECODER_AUDIO, (M4OSA_Char *)"M4AD_Interface" );
    if (M4OSA_NULL == *pDecoderInterface)
    {
        return M4ERR_ALLOC;
    }

    *pDecoderType = M4AD_kTypePCM;

    (*pDecoderInterface)->m_pFctCreateAudioDec       = M4AD_NULL_create;
    (*pDecoderInterface)->m_pFctDestroyAudioDec      = M4AD_NULL_destroy;
    (*pDecoderInterface)->m_pFctStepAudioDec         = M4AD_NULL_step;
    (*pDecoderInterface)->m_pFctGetVersionAudioDec   = M4AD_NULL_getVersion;
    (*pDecoderInterface)->m_pFctStartAudioDec        = M4OSA_NULL;
    (*pDecoderInterface)->m_pFctResetAudioDec        = M4OSA_NULL;
    (*pDecoderInterface)->m_pFctSetOptionAudioDec    = M4OSA_NULL;
    (*pDecoderInterface)->m_pFctGetOptionAudioDec    = M4OSA_NULL;

    return M4NO_ERROR;
}