| /* |
| * 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 M4PCM_PCMReader.c |
| * @brief PCM reader implementation |
| * @note This file implements functions of the PCM reader |
| ************************************************************************ |
| */ |
| #include "M4OSA_CharStar.h" |
| #include "M4PCMR_CoreReader.h" |
| #include "M4OSA_Debug.h" |
| #include "M4OSA_CharStar.h" |
| /** |
| ****************************************************************************** |
| * PCM reader version numbers |
| ****************************************************************************** |
| */ |
| /* CHANGE_VERSION_HERE */ |
| #define M4PCMR_VERSION_MAJOR 1 |
| #define M4PCMR_VERSION_MINOR 0 |
| #define M4PCMR_VERSION_REVISION 0 |
| |
| /** |
| ************************************************************************ |
| * M4OSA_ERR M4PCMR_openRead(M4OSA_Context* pContext, M4OSA_Void* pUrl, |
| * M4OSA_FileReaderPointer* pFileFunction) |
| * @brief This function opens a PCM file |
| * @note This function : |
| * - opens a PCM file |
| * - initializes PCM context, |
| * - verifies PCM file format |
| * - Fill decoder config structure |
| * - Changes state of the reader in 'Opening' |
| * @param pContext: (OUT) Pointer on the PCM Reader context |
| * @param pUrl: (IN) Name of the PCM file |
| * @param pFileFunctions: (IN) Pointer on the file access functions |
| * @return M4NO_ERROR there is no error during the opening |
| * @return M4ERR_PARAMETER pContext and/or pUrl and/or pFileFunction is NULL |
| * @return M4ERR_ALLOC there is no more memory available |
| * @return M4ERR_FILE_NOT_FOUND the file cannot be found |
| * @return M4PCMC_ERR_PCM_NOT_COMPLIANT the file does not seem to be compliant, no RIFF, |
| * or lack of any mandatory chunk. |
| * @return M4PCMC_ERR_PCM_NOT_SUPPORTED the PCM format of this file is not supported by the |
| * reader |
| * @return Any M4OSA_FILE errors see OSAL File specification for detailed errors |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4PCMR_openRead(M4OSA_Context* pContext, M4OSA_Void* pUrl, |
| M4OSA_FileReadPointer* pFileFunction) |
| { |
| M4OSA_ERR err; |
| M4PCMR_Context *context; |
| M4OSA_Char* pTempURL; |
| M4OSA_Char value[6]; |
| |
| /* Check parameters */ |
| if((M4OSA_NULL == pContext)|| (M4OSA_NULL == pUrl) ||(M4OSA_NULL == pFileFunction)) |
| { |
| return M4ERR_PARAMETER; |
| } |
| |
| /* Allocates the context */ |
| context = M4OSA_NULL; |
| context = (M4PCMR_Context *)M4OSA_32bitAlignedMalloc(sizeof(M4PCMR_Context), M4WAV_READER, |
| (M4OSA_Char *)"M4PCMR_openRead"); |
| if (M4OSA_NULL == context) |
| { |
| return M4ERR_ALLOC; |
| } |
| *pContext = (M4OSA_Context)context; |
| |
| /* Initialize the context */ |
| context->m_offset = 0; |
| |
| context->m_state = M4PCMR_kInit; |
| context->m_microState = M4PCMR_kInit; |
| context->m_pFileReadFunc = M4OSA_NULL; |
| context->m_fileContext = M4OSA_NULL; |
| context->m_pAuBuffer = M4OSA_NULL; |
| context->m_pDecoderSpecInfo = M4OSA_NULL; |
| |
| /* Set sample frequency */ |
| pTempURL = (M4OSA_Char*)pUrl + (strlen((const char *)pUrl)-11); |
| M4OSA_chrNCopy(value, pTempURL, 5); |
| M4OSA_chrGetUInt32(pTempURL, &(context->m_decoderConfig.SampleFrequency), |
| M4OSA_NULL, M4OSA_kchrDec); |
| |
| /* Set number of channels */ |
| pTempURL += 6; |
| M4OSA_chrNCopy(value, pTempURL, 1); |
| M4OSA_chrGetUInt16(pTempURL, &(context->m_decoderConfig.nbChannels), |
| M4OSA_NULL, M4OSA_kchrDec); |
| |
| M4OSA_chrNCopy(pUrl,pUrl, (strlen((const char *)pUrl)-12)); |
| /* Open the file */ |
| context->m_fileContext = M4OSA_NULL; |
| err = pFileFunction->openRead(&(context->m_fileContext), pUrl, M4OSA_kFileRead); |
| if(M4NO_ERROR != err) |
| { |
| return err; |
| } |
| context->m_decoderConfig.BitsPerSample = 16; |
| context->m_decoderConfig.AvgBytesPerSec = context->m_decoderConfig.SampleFrequency * 2 \ |
| * context->m_decoderConfig.nbChannels; |
| err = pFileFunction->getOption(context->m_fileContext, M4OSA_kFileReadGetFileSize, |
| (M4OSA_DataOption*)&(context->m_decoderConfig.DataLength)); |
| if(M4NO_ERROR != err) |
| { |
| return err; |
| } |
| context->m_blockSize = 2048 * context->m_decoderConfig.nbChannels; // Raw PCM. Hence, get a |
| // chunk of data |
| |
| if(context->m_decoderConfig.SampleFrequency == 8000) |
| { |
| /* AMR case, no pb */ |
| context->m_blockSize = context->m_decoderConfig.nbChannels *\ |
| (context->m_decoderConfig.SampleFrequency / 50) * \ |
| (context->m_decoderConfig.BitsPerSample / 8); |
| } |
| if(context->m_decoderConfig.SampleFrequency == 16000) |
| { |
| /* AAC case, we can't read only 20 ms blocks */ |
| context->m_blockSize = 2048 * context->m_decoderConfig.nbChannels; |
| } |
| context->m_dataStartOffset = 0; |
| context->m_pFileReadFunc = pFileFunction; |
| |
| context->m_pAuBuffer = (M4OSA_MemAddr32)M4OSA_32bitAlignedMalloc(context->m_blockSize, M4WAV_READER, |
| (M4OSA_Char *)"Core PCM reader Access Unit"); |
| if (M4OSA_NULL == context->m_pAuBuffer) |
| { |
| err = M4ERR_ALLOC; |
| goto cleanup; |
| } |
| |
| /* Change state */ |
| context->m_state = M4PCMR_kOpening; |
| |
| return M4NO_ERROR; |
| |
| cleanup: |
| |
| /* Close the file */ |
| if(context->m_pFileReadFunc != M4OSA_NULL) |
| context->m_pFileReadFunc->closeRead(context->m_fileContext); |
| |
| /* Free internal context */ |
| free(context); |
| *pContext = M4OSA_NULL; |
| |
| return err; |
| } |
| |
| /** |
| ************************************************************************ |
| * M4OSA_ERR M4PCMR_getNextStream(M4OSA_Context context, M4SYS_StreamDescription* pStreamDesc) |
| * @brief This function get the (unique) stream of a PCM file |
| * @note This function : |
| * - Allocates and fills the decoder specific info structure |
| * - Fills decoder specific infos structure |
| * - Fills pStreamDesc structure allocated by the caller |
| * @param context: (IN/OUT) PCM Reader context |
| * @param pStreamDesc: (IN) Stream Description context |
| * @return M4NO_ERROR there is no error |
| * @return M4ERR_PARAMETER at least one parameter is NULL |
| * @return M4ERR_ALLOC there is no more memory available |
| * @return M4ERR_STATE this function cannot be called now |
| * @return Any M4OSA_FILE errors see OSAL File specification for detailed errors |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4PCMR_getNextStream(M4OSA_Context context, M4SYS_StreamDescription* pStreamDesc) |
| { |
| M4PCMR_Context *c = (M4PCMR_Context *)context; |
| |
| /* Check parameters */ |
| if((M4OSA_NULL == context)|| (M4OSA_NULL == pStreamDesc)) |
| { |
| return M4ERR_PARAMETER; |
| } |
| |
| if (c->m_state == M4PCMR_kOpening_streamRetrieved) |
| { |
| return M4WAR_NO_MORE_STREAM; |
| } |
| /* Check Reader's m_state */ |
| if(c->m_state != M4PCMR_kOpening) |
| { |
| return M4ERR_STATE; |
| } |
| |
| /* Only one stream is contained in PCM file */ |
| pStreamDesc->streamID = 1; |
| /* Not used */ |
| pStreamDesc->profileLevel = 0; |
| pStreamDesc->decoderSpecificInfoSize = sizeof(M4PCMC_DecoderSpecificInfo); |
| |
| /* Allocates decoder specific info structure */ |
| pStreamDesc->decoderSpecificInfo = M4OSA_NULL; |
| pStreamDesc->decoderSpecificInfo = |
| (M4OSA_MemAddr32)M4OSA_32bitAlignedMalloc( sizeof(M4PCMC_DecoderSpecificInfo), M4WAV_READER, |
| (M4OSA_Char *)"M4PCMR_getNextStream"); |
| if(pStreamDesc->decoderSpecificInfo == M4OSA_NULL) |
| { |
| return M4ERR_ALLOC; |
| } |
| /* Fill decoderSpecificInfo structure, with decoder config structure filled in 'openread' |
| function */ |
| memcpy((void *)pStreamDesc->decoderSpecificInfo, |
| (void *)&c->m_decoderConfig, sizeof(M4PCMC_DecoderSpecificInfo)); |
| |
| /* Fill other fields of pStreamDesc structure */ |
| pStreamDesc->timeScale = 1000; |
| pStreamDesc->duration = (M4OSA_Time)(((M4OSA_Double)(c->m_decoderConfig.DataLength)\ |
| / (M4OSA_Double)(c->m_decoderConfig.AvgBytesPerSec))*pStreamDesc->timeScale); |
| pStreamDesc->averageBitrate = c->m_decoderConfig.AvgBytesPerSec * 8;/* in bits, multiply by 8*/ |
| pStreamDesc->maxBitrate = pStreamDesc->averageBitrate; /* PCM stream has constant bitrate */ |
| |
| /* Determines Stream type */ |
| switch(c->m_decoderConfig.BitsPerSample) |
| { |
| case 8: |
| switch(c->m_decoderConfig.nbChannels) |
| { |
| case 1: |
| pStreamDesc->streamType = M4SYS_kPCM_8bitsU; |
| break; |
| // case 2: |
| // pStreamDesc->streamType = M4SYS_kPCM_8bitsS; /* ??? 8bits stereo not |
| // defined ? */ |
| // break; |
| default: |
| pStreamDesc->streamType = M4SYS_kAudioUnknown; |
| } |
| break; |
| |
| case 16: |
| switch(c->m_decoderConfig.nbChannels) |
| { |
| case 1: |
| pStreamDesc->streamType = M4SYS_kPCM_16bitsU; |
| break; |
| case 2: |
| pStreamDesc->streamType = M4SYS_kPCM_16bitsS; |
| break; |
| default: |
| pStreamDesc->streamType = M4SYS_kAudioUnknown; |
| } |
| break; |
| |
| default: |
| pStreamDesc->streamType = M4SYS_kAudioUnknown; |
| } |
| |
| c->m_pDecoderSpecInfo = pStreamDesc->decoderSpecificInfo; |
| |
| c->m_state = M4PCMR_kOpening_streamRetrieved; |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ************************************************************************ |
| * M4OSA_ERR M4PCMR_startReading(M4OSA_Context context, M4SYS_StreamID* pStreamIDs) |
| * @brief This function starts reading the unique stream of a PCM file |
| * @note This function : |
| * - Verifies that the current reader's state allows to start reading a stream |
| * - Check that provided StreamId is correct (always true, only one stream...) |
| * In the player application, a StreamId table is initialized as follow: |
| * M4SYS_StreamID pStreamID[2]={1,0}; |
| * - Change state of the reader in 'Reading' |
| * @param context: (IN/OUT) PCM Reader context |
| * @param streamID: (IN) Stream selection |
| * @return M4NO_ERROR there is no error |
| * @return M4ERR_PARAMETER at least one parameter is NULL |
| * @return M4ERR_STATE this function cannot be called now |
| * @return M4ERR_BAD_STREAM_ID at least one of the streamID does not exist |
| * (should never happen if table pStreamID is correctly initialized as above) |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4PCMR_startReading(M4OSA_Context context, M4SYS_StreamID* pStreamIDs) |
| { |
| M4PCMR_Context *c = (M4PCMR_Context *)context; |
| |
| /* Check parameters */ |
| if((M4OSA_NULL == context) || (M4OSA_NULL == pStreamIDs)) |
| { |
| return M4ERR_PARAMETER; |
| } |
| |
| /* Check Reader's state */ |
| if(c->m_state != M4PCMR_kOpening_streamRetrieved) |
| { |
| return M4ERR_STATE; |
| } |
| |
| /* Check pStreamID and if they're OK, change reader's state */ |
| if(pStreamIDs[0] == 1 || pStreamIDs[0] == 0) |
| /* First and unique stream contained in PCM file */ |
| { |
| c->m_state = M4PCMR_kReading; |
| c->m_microState = M4PCMR_kReading; |
| } |
| else |
| { |
| return M4ERR_BAD_STREAM_ID; |
| } |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ************************************************************************ |
| * M4OSA_ERR M4PCMR_nextAU(M4OSA_Context context, M4SYS_StreamID streamID, M4SYS_AccessUnit* pAU) |
| * @brief This function reads the next AU contained in the PCM file |
| * @note This function : |
| * - Verifies that the current reader's state allows to read an AU |
| * - Allocates memory to store read AU |
| * - Read data from file and store them into previously allocated memory |
| * - Fill AU structure fileds (CTS...) |
| * - Change state of the reader in 'Reading' (not useful...) |
| * - Change Micro state 'Reading' in M4PCMR_kReading_nextAU |
| * (AU is read and can be deleted) |
| * - Check if the last AU has been read or if we're about to read it |
| * @param context: (IN/OUT) PCM Reader context |
| * @param streamID: (IN) Stream selection |
| * @param pAU: (IN/OUT) Acces Unit Structure |
| * @return M4NO_ERROR there is no error |
| * @return M4ERR_PARAMETER at least one parameter is NULL |
| * @return M4ERR_ALLOC there is no more memory available |
| * @return M4ERR_STATE this function cannot be called now |
| * @return M4M4WAR_NO_DATA_YET there is no enough data in the file to provide a new access unit. |
| * @return M4WAR_END_OF_STREAM There is no more access unit in the stream, |
| * or the sample number is bigger the maximum one. |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4PCMR_nextAU(M4OSA_Context context, M4SYS_StreamID streamID, M4SYS_AccessUnit* pAU) |
| { |
| M4PCMR_Context *c = (M4PCMR_Context *)context; |
| M4OSA_ERR err = M4NO_ERROR; |
| M4OSA_UInt32 size_read; |
| |
| /* Check parameters */ |
| if((M4OSA_NULL == context) || (M4OSA_NULL == pAU)) |
| { |
| return M4ERR_PARAMETER; |
| } |
| |
| /* Check Reader's state */ |
| if(c->m_state != M4PCMR_kReading && c->m_microState != M4PCMR_kReading) |
| { |
| return M4ERR_STATE; |
| } |
| |
| /* Allocates AU dataAdress */ |
| pAU->dataAddress = c->m_pAuBuffer; |
| size_read = c->m_blockSize; |
| |
| if((c->m_offset + size_read) >= c->m_decoderConfig.DataLength) |
| { |
| size_read = c->m_decoderConfig.DataLength - c->m_offset; |
| } |
| |
| /* Read data in file, and copy it to AU Structure */ |
| err = c->m_pFileReadFunc->readData(c->m_fileContext, (M4OSA_MemAddr8)pAU->dataAddress, |
| (M4OSA_UInt32 *)&size_read); |
| if(M4NO_ERROR != err) |
| { |
| return err; |
| } |
| |
| /* Calculates the new m_offset, used to determine whether we're at end of reading or not */ |
| c->m_offset = c->m_offset + size_read; |
| |
| /* Fill others parameters of AU structure */ |
| pAU->CTS = |
| (M4OSA_Time)(((M4OSA_Double)c->m_offset/(M4OSA_Double)c->m_decoderConfig.AvgBytesPerSec)\ |
| *1000); |
| pAU->DTS = pAU->CTS; |
| |
| pAU->attribute = 0; |
| pAU->frag = M4OSA_NULL; |
| pAU->nbFrag = 0; |
| pAU->stream = M4OSA_NULL; |
| pAU->size = size_read; |
| |
| /* Change states */ |
| c->m_state = M4PCMR_kReading; /* Not changed ... */ |
| c->m_microState = M4PCMR_kReading_nextAU; /* AU is read and can be deleted */ |
| |
| /* Check if there is another AU to read */ |
| /* ie: if decoded nb of bytes = nb of bytes to decode, |
| it means there is no more AU to decode */ |
| if(c->m_offset >= c->m_decoderConfig.DataLength) |
| { |
| return M4WAR_NO_MORE_AU; |
| } |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ************************************************************************ |
| * M4OSA_ERR M4PCMR_freeAU(M4OSA_Context context, M4SYS_StreamID streamID, M4SYS_AccessUnit* pAU) |
| * @brief This function frees the AU provided in parameter |
| * @note This function : |
| * - Verifies that the current reader's state allows to free an AU |
| * - Free dataAddress field of AU structure |
| * - Change state of the reader in 'Reading' (not useful...) |
| * - Change Micro state 'Reading' in M4PCMR_kReading (another AU can be read) |
| * @param context: (IN/OUT) PCM Reader context |
| * @param streamID: (IN) Stream selection |
| * @param pAU: (IN) Acces Unit Structure |
| * @return M4NO_ERROR there is no error |
| * @return M4ERR_PARAMETER at least one parameter is NULL |
| * @return M4ERR_STATE this function cannot be called now |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4PCMR_freeAU(M4OSA_Context context, M4SYS_StreamID streamID, M4SYS_AccessUnit* pAU) |
| { |
| M4PCMR_Context *c = (M4PCMR_Context *)context; |
| |
| /* Check parameters */ |
| if((M4OSA_NULL == context ) || (M4OSA_NULL == pAU)) |
| { |
| return M4ERR_PARAMETER; |
| } |
| |
| /* Check Reader's state */ |
| if(c->m_state != M4PCMR_kReading && c->m_microState != M4PCMR_kReading_nextAU) |
| { |
| return M4ERR_STATE; |
| } |
| |
| pAU->dataAddress = M4OSA_NULL; |
| |
| /* Change states */ |
| c->m_state = M4PCMR_kReading; /* Not changed ... */ |
| c->m_microState = M4PCMR_kReading; /* AU is deleted, another AU can be read */ |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ************************************************************************ |
| * M4OSA_ERR M4PCMR_seek(M4OSA_Context context, M4SYS_StreamID* pStreamID, |
| M4OSA_Time time, M4SYS_seekAccessMode seekAccessMode, |
| M4OSA_Time* pObtainCTS[]) |
| * @brief This function seeks into the PCM file at the provided time |
| * @note This function : |
| * - Verifies that the current reader's state allows to seek |
| * - Determines from provided time m_offset to seek in file |
| * - If m_offset is correct, seek in file |
| * - Update new m_offset in PCM reader context |
| * @param context: (IN/OUT) PCM Reader context |
| * @param pStreamID: (IN) Stream selection (not used, only 1 stream) |
| * @param time: (IN) Targeted time |
| * @param seekMode: (IN) Selects the seek access mode |
| * @param pObtainCTS[]: (OUT) Returned Time (not used) |
| * @return M4NO_ERROR there is no error |
| * @return M4ERR_PARAMETER at least one parameter is NULL |
| * @return M4ERR_ALLOC there is no more memory available |
| * @return M4ERR_STATE this function cannot be called now |
| * @return M4WAR_INVALID_TIME Specified time is not reachable |
| * @param M4ERR_NOT_IMPLEMENTED This seek mode is not implemented yet |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4PCMR_seek(M4OSA_Context context, M4SYS_StreamID* pStreamID, M4OSA_Time time, |
| M4SYS_SeekAccessMode seekAccessMode, M4OSA_Time* pObtainCTS) |
| { |
| M4PCMR_Context *c = (M4PCMR_Context *)context; |
| M4OSA_ERR err = M4NO_ERROR; |
| M4OSA_UInt32 offset; |
| M4OSA_UInt32 alignment; |
| M4OSA_UInt32 size_read; |
| |
| /* Check parameters */ |
| if((M4OSA_NULL == context) || (M4OSA_NULL == pStreamID)) |
| { |
| return M4ERR_PARAMETER; |
| } |
| |
| /* Check Reader's state */ |
| if(c->m_state != M4PCMR_kOpening_streamRetrieved && c->m_state != M4PCMR_kReading) |
| { |
| return M4ERR_STATE; |
| } |
| |
| switch(seekAccessMode) |
| { |
| case M4SYS_kBeginning: |
| /* Determine m_offset from time*/ |
| offset = |
| (M4OSA_UInt32)(time * ((M4OSA_Double)(c->m_decoderConfig.AvgBytesPerSec) / 1000)); |
| /** check the alignment on sample boundary */ |
| alignment = c->m_decoderConfig.nbChannels*c->m_decoderConfig.BitsPerSample/8; |
| if (offset%alignment != 0) |
| { |
| offset -= offset%alignment; |
| } |
| /*add the header offset*/ |
| offset += c->m_dataStartOffset; |
| /* If m_offset is over file size -> Invalid time */ |
| if (offset > (c->m_dataStartOffset + c->m_decoderConfig.DataLength)) |
| { |
| return M4WAR_INVALID_TIME; |
| } |
| else |
| { |
| /* Seek file */ |
| size_read = offset; |
| err = c->m_pFileReadFunc->seek(c->m_fileContext, M4OSA_kFileSeekBeginning, |
| (M4OSA_FilePosition *) &size_read); |
| if(M4NO_ERROR != err) |
| { |
| return err; |
| } |
| /* Update m_offset in M4PCMR_context */ |
| c->m_offset = offset - c->m_dataStartOffset; |
| } |
| break; |
| |
| default: |
| return M4ERR_NOT_IMPLEMENTED; |
| } |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ************************************************************************ |
| * M4OSA_ERR M4PCMR_closeRead(M4OSA_Context context) |
| * @brief This function closes PCM file, and frees context |
| * @note This function : |
| * - Verifies that the current reader's state allows close the PCM file |
| * - Closes the file |
| * - Free structures |
| * @param context: (IN/OUT) PCM Reader context |
| * @return M4NO_ERROR there is no error |
| * @return M4ERR_PARAMETER at least one parameter is NULL |
| * @return M4ERR_STATE this function cannot be called now |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4PCMR_closeRead(M4OSA_Context context) |
| { |
| M4PCMR_Context *c = (M4PCMR_Context *)context; |
| M4OSA_ERR err = M4NO_ERROR; |
| |
| /* Check parameters */ |
| if(M4OSA_NULL == context) |
| { |
| return M4ERR_PARAMETER; |
| } |
| |
| if(c->m_pDecoderSpecInfo != M4OSA_NULL) |
| { |
| free(c->m_pDecoderSpecInfo); |
| } |
| |
| /* Check Reader's state */ |
| if(c->m_state != M4PCMR_kReading) |
| { |
| return M4ERR_STATE; |
| } |
| else if(c->m_microState == M4PCMR_kReading_nextAU) |
| { |
| return M4ERR_STATE; |
| } |
| |
| if (M4OSA_NULL != c->m_pAuBuffer) |
| { |
| free(c->m_pAuBuffer); |
| } |
| |
| /* Close the file */ |
| if (M4OSA_NULL != c->m_pFileReadFunc) |
| { |
| err = c->m_pFileReadFunc->closeRead(c->m_fileContext); |
| } |
| |
| /* Free internal context */ |
| if (M4OSA_NULL != c) |
| { |
| free(c); |
| } |
| |
| return err; |
| } |
| |
| /** |
| ************************************************************************ |
| * M4OSA_ERR M4PCMR_getOption(M4OSA_Context context, M4PCMR_OptionID optionID, |
| * M4OSA_DataOption* pValue) |
| * @brief This function get option of the PCM Reader |
| * @note This function : |
| * - Verifies that the current reader's state allows to get an option |
| * - Return corresponding option value |
| * @param context: (IN/OUT) PCM Reader context |
| * @param optionID: (IN) ID of the option to get |
| * @param pValue: (OUT) Variable where the option value is returned |
| * @return M4NO_ERROR there is no error. |
| * @return M4ERR_PARAMETER at least one parameter is NULL. |
| * @return M4ERR_BAD_OPTION_ID the optionID is not a valid one. |
| * @return M4ERR_STATE this option is not available now. |
| * @return M4ERR_NOT_IMPLEMENTED this option is not implemented |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4PCMR_getOption(M4OSA_Context context, M4PCMR_OptionID optionID, |
| M4OSA_DataOption* pValue) |
| { |
| M4PCMR_Context *c =(M4PCMR_Context *)context; |
| |
| /* Check parameters */ |
| if(M4OSA_NULL == context) |
| { |
| return M4ERR_PARAMETER; |
| } |
| |
| /* Check reader's state */ |
| if((c->m_state != M4PCMR_kOpening) && (c->m_state != M4PCMR_kOpening_streamRetrieved)\ |
| && (c->m_state != M4PCMR_kReading)) |
| { |
| return M4ERR_STATE; |
| } |
| |
| /* Depend of the OptionID, the value to return is different */ |
| switch(optionID) |
| { |
| case M4PCMR_kPCMblockSize: |
| *pValue = &c->m_blockSize; |
| break; |
| |
| default: |
| return M4ERR_BAD_OPTION_ID; |
| } |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ************************************************************************ |
| * M4OSA_ERR M4PCMR_setOption(M4OSA_Context context, M4PCMR_OptionID optionID, |
| * M4OSA_DataOption Value) |
| * @brief This function set option of the PCM Reader |
| * @note This function : |
| * - Verifies that the current reader's state allows to set an option |
| * - Set corresponding option value |
| * @param context: (IN/OUT) PCM Reader context |
| * @param optionID: (IN) ID of the option to get |
| * @param Value: (IN) Variable where the option value is stored |
| * @return M4NO_ERROR there is no error. |
| * @return M4ERR_PARAMETER at least one parameter is NULL. |
| * @return M4ERR_BAD_OPTION_ID the optionID is not a valid one. |
| * @return M4ERR_STATE this option is not available now. |
| * @return M4ERR_NOT_IMPLEMENTED this option is not implemented |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4PCMR_setOption(M4OSA_Context context, M4PCMR_OptionID optionID, M4OSA_DataOption Value) |
| { |
| M4PCMR_Context *c =(M4PCMR_Context *)context; |
| |
| /* Check parameters */ |
| if(context == M4OSA_NULL) |
| { |
| return M4ERR_PARAMETER; |
| } |
| |
| /* Check reader's state */ |
| if((c->m_state != M4PCMR_kOpening) && (c->m_state != M4PCMR_kOpening_streamRetrieved)\ |
| && (c->m_state != M4PCMR_kReading)) |
| { |
| return M4ERR_STATE; |
| } |
| |
| /* Depend of the OptionID, the value to set is different */ |
| switch(optionID) |
| { |
| case M4PCMR_kPCMblockSize: |
| c->m_blockSize = (M4OSA_UInt32)Value; |
| break; |
| |
| default: |
| return M4ERR_BAD_OPTION_ID; |
| } |
| |
| return M4NO_ERROR; |
| } |
| |
| /*********************************************************/ |
| M4OSA_ERR M4PCMR_getVersion (M4_VersionInfo *pVersion) |
| /*********************************************************/ |
| { |
| M4OSA_TRACE1_1("M4PCMR_getVersion called with pVersion: 0x%x", pVersion); |
| M4OSA_DEBUG_IF1(((M4OSA_UInt32) pVersion == 0),M4ERR_PARAMETER, |
| "pVersion is NULL in M4PCMR_getVersion"); |
| |
| pVersion->m_major = M4PCMR_VERSION_MAJOR; |
| pVersion->m_minor = M4PCMR_VERSION_MINOR; |
| pVersion->m_revision = M4PCMR_VERSION_REVISION; |
| |
| return M4NO_ERROR; |
| } |
