| /* |
| * 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_Wav.c |
| * @brief Generic encapsulation of the core pcm reader |
| * @note This file implements the generic M4READER interface |
| * on top of the PCM reader |
| ************************************************************************ |
| */ |
| |
| #include "M4OSA_Types.h" |
| #include "M4OSA_Error.h" |
| #include "M4OSA_Memory.h" |
| #include "M4OSA_Debug.h" |
| #include "M4OSA_CoreID.h" |
| #include "M4TOOL_VersionInfo.h" |
| #include "M4PCMR_CoreReader.h" |
| #include "M4READER_Pcm.h" |
| /** |
| ************************************************************************ |
| * structure M4READER_WAV_Context |
| * @brief This structure defines the internal context of a wav reader instance |
| * @note The context is allocated and de-allocated by the reader |
| ************************************************************************ |
| */ |
| typedef struct _M4READER_PCM_Context |
| { |
| M4OSA_Context m_coreContext; /**< core wav reader context */ |
| M4_StreamHandler* 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_FileReadPointer* m_pOsaFileReaderFcts; /**< OSAL file read functions */ |
| |
| } M4READER_PCM_Context; |
| |
| |
| /** |
| ************************************************************************ |
| * @brief Creates a wav reader instance |
| * @note allocates the context |
| * @param pContext: (OUT) Pointer to a wav 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_PCM_create(M4OSA_Context* pContext) |
| { |
| M4READER_PCM_Context* pReaderContext; |
| |
| M4OSA_DEBUG_IF1((pContext == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_create: invalid context pointer"); |
| |
| pReaderContext = (M4READER_PCM_Context*)M4OSA_32bitAlignedMalloc(sizeof(M4READER_PCM_Context), |
| M4READER_WAV, (M4OSA_Char *)"M4READER_PCM_Context"); |
| if (pReaderContext == M4OSA_NULL) |
| { |
| return M4ERR_ALLOC; |
| } |
| |
| pReaderContext->m_coreContext = M4OSA_NULL; |
| pReaderContext->m_pAudioStream = M4OSA_NULL; |
| pReaderContext->m_audioAu.dataAddress = M4OSA_NULL; |
| pReaderContext->m_pOsaFileReaderFcts = M4OSA_NULL; |
| |
| *pContext = pReaderContext; |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ************************************************************************ |
| * @brief Destroy the instance of the reader |
| * @note the context is un-allocated |
| * @param context: (IN) context of the network reader |
| * @return M4NO_ERROR: there is no error |
| * @return M4ERR_PARAMETER: at least one parameter is not properly set (in DEBUG only) |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4READER_PCM_destroy(M4OSA_Context context) |
| { |
| M4READER_PCM_Context* pC = (M4READER_PCM_Context*)context; |
| |
| /* Check function parameters */ |
| M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, |
| "M4READER_PCM_destroy: invalid context pointer"); |
| |
| free(pC); |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ************************************************************************ |
| * @brief Initializes the reader instance |
| * @param context: (IN) context of the network reader |
| * @param pFileDescriptor: (IN) Pointer to proprietary data identifying the media to open |
| * @return M4NO_ERROR: there is no error |
| * @return M4ERR_PARAMETER: at least one parameter is not properly set (in DEBUG only) |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4READER_PCM_open(M4OSA_Context context, M4OSA_Void* pFileDescriptor) |
| { |
| M4READER_PCM_Context* pC = (M4READER_PCM_Context*)context; |
| M4OSA_ERR err; |
| |
| /* Check function parameters */ |
| M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, |
| "M4READER_PCM_open: invalid context pointer"); |
| M4OSA_DEBUG_IF1((M4OSA_NULL == pFileDescriptor), M4ERR_PARAMETER, |
| "M4READER_PCM_open: invalid pointer pFileDescriptor"); |
| |
| err = M4PCMR_openRead(&(pC->m_coreContext), (M4OSA_Char*)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_PCM_close(M4OSA_Context context) |
| { |
| M4READER_PCM_Context* pC = (M4READER_PCM_Context*)context; |
| M4OSA_ERR err; |
| |
| /* Check function parameters */ |
| M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, |
| "M4READER_PCM_close: invalid context pointer"); |
| |
| /* Free audio AU and audio stream */ |
| if (M4OSA_NULL != pC->m_pAudioStream) |
| { |
| if (M4OSA_NULL != pC->m_audioAu.dataAddress) |
| { |
| err = M4PCMR_freeAU(pC->m_coreContext, pC->m_pAudioStream->m_streamId, |
| &pC->m_audioAu); |
| if (err != M4NO_ERROR) |
| { |
| M4OSA_TRACE1_0("M4READER_PCM_close: Error when freeing audio access unit"); |
| return err; |
| } |
| } |
| free(pC->m_pAudioStream); |
| pC->m_pAudioStream = M4OSA_NULL; |
| } |
| |
| |
| if (M4OSA_NULL != pC->m_coreContext) |
| { |
| /* Close tha PCM file */ |
| err = M4PCMR_closeRead(pC->m_coreContext); |
| pC->m_coreContext = M4OSA_NULL; |
| } |
| |
| |
| return err; |
| } |
| |
| /** |
| ************************************************************************ |
| * @brief set en option value of the reader |
| * @note this function follows the set/get option mechanism described in OSAL 3.0 |
| * it allows the caller to set a property value: |
| * @param context: (IN) Context of the reader |
| * @param optionId: (IN) indicates 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_CONTEXT provided context is not a valid one |
| * @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_PCM_setOption(M4OSA_Context context, M4OSA_OptionID optionId, void* pValue) |
| { |
| M4READER_PCM_Context* pC = (M4READER_PCM_Context*)context; |
| M4OSA_ERR err = M4NO_ERROR; |
| |
| /* Check function parameters */ |
| M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, |
| "M4READER_PCM_setOption: invalid context pointer"); |
| M4OSA_DEBUG_IF1((M4OSA_NULL == pValue), M4ERR_PARAMETER, |
| "M4READER_PCM_setOption: invalid value pointer"); |
| |
| switch(optionId) |
| { |
| case M4READER_kOptionID_SetOsaFileReaderFctsPtr : |
| { |
| pC->m_pOsaFileReaderFcts = (M4OSA_FileReadPointer*)pValue; |
| } |
| break; |
| default : |
| { |
| err = M4ERR_PARAMETER; |
| } |
| } |
| |
| return err; |
| } |
| |
| /** |
| ************************************************************************ |
| * @brief Retrieves the an option value from the reader, given an option ID. |
| * @note this function follows the set/get option mechanism described in OSAL 3.0 |
| * it allows the caller to retrieve a property value: |
| * |
| * @param context: (IN) context of the network reader |
| * @param optionId: (IN) option identificator whose option value is to be retrieved. |
| * @param pValue: (OUT) option value retrieved. |
| * |
| * @return M4NO_ERROR: there is no error |
| * @return M4ERR_PARAMETER: at least one parameter is not properly set (in DEBUG only) |
| * @return M4ERR_BAD_OPTION_ID: the required option identificator is unknown |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4READER_PCM_getOption(M4OSA_Context context, M4OSA_OptionID optionId, void* pValue) |
| { |
| M4READER_PCM_Context* pContext = (M4READER_PCM_Context*)context; |
| M4OSA_ERR err = M4NO_ERROR; |
| |
| /* no check of context at this level because some option does not need it */ |
| M4OSA_DEBUG_IF1((pValue == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_getOption: invalid pointer on value"); |
| |
| switch (optionId) |
| { |
| case M4READER_kOptionID_Duration: |
| *((M4OSA_UInt32*)pValue) = pContext->m_pAudioStream->m_duration; |
| break; |
| |
| case M4READER_kOptionID_Version: |
| err = M4PCMR_getVersion((M4_VersionInfo*)pValue); |
| break; |
| |
| case M4READER_kOptionID_Copyright: |
| return M4ERR_NOT_IMPLEMENTED; |
| break; |
| |
| case M4READER_kOptionID_Bitrate: |
| { |
| M4OSA_UInt32* pBitrate = (M4OSA_UInt32*)pValue; |
| if (M4OSA_NULL != pContext->m_pAudioStream) |
| { |
| *pBitrate = pContext->m_pAudioStream->m_averageBitRate; |
| } |
| else |
| { |
| pBitrate = 0; |
| err = M4ERR_PARAMETER; |
| } |
| } |
| break; |
| |
| default: |
| err = M4ERR_BAD_OPTION_ID; |
| M4OSA_TRACE1_0("M4READER_PCM_getOption: unsupported optionId"); |
| break; |
| } |
| |
| return err; |
| } |
| |
| /** |
| ************************************************************************ |
| * @brief Get the next stream found in the media |
| * @note |
| * |
| * @param context: (IN) context of the network reader |
| * @param pMediaFamily: (OUT) pointer to a user allocated M4READER_MediaFamily that will |
| * be filled |
| * @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 M4ERR_PARAMETER: at least one parameter is not properly set (in DEBUG only) |
| * @return M4WAR_NO_MORE_STREAM no more available stream in the media (all streams found) |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4READER_PCM_getNextStream(M4OSA_Context context, M4READER_MediaFamily *pMediaFamily, |
| M4_StreamHandler **pStreamHandler) |
| { |
| M4READER_PCM_Context* pC=(M4READER_PCM_Context*)context; |
| M4OSA_ERR err; |
| /* M4_StreamHandler* pStreamHandler = M4OSA_NULL;*/ |
| M4SYS_StreamDescription streamDesc; |
| M4_AudioStreamHandler* pAudioStreamHandler; |
| M4OSA_Double fDuration; |
| M4SYS_StreamID streamIdArray[2]; |
| M4PCMC_DecoderSpecificInfo* pDsi; |
| |
| M4OSA_DEBUG_IF1((pC == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_getNextStream: invalid context"); |
| M4OSA_DEBUG_IF1((pMediaFamily == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_getNextStream: invalid pointer to MediaFamily"); |
| M4OSA_DEBUG_IF1((pStreamHandler == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_getNextStream: invalid pointer to StreamHandler"); |
| |
| err = M4PCMR_getNextStream( pC->m_coreContext, &streamDesc); |
| if (err == M4WAR_NO_MORE_STREAM) |
| { |
| streamIdArray[0] = 0; |
| streamIdArray[1] = 0; |
| err = M4PCMR_startReading(pC->m_coreContext, streamIdArray); /*to put in open function*/ |
| |
| return M4WAR_NO_MORE_STREAM; |
| } |
| else if (M4NO_ERROR != err) |
| { |
| return err; /*also return M4WAR_NO_MORE_STREAM*/ |
| } |
| |
| switch (streamDesc.streamType) |
| { |
| case M4SYS_kAudioUnknown: |
| case M4SYS_kPCM_16bitsS: |
| case M4SYS_kPCM_16bitsU: |
| case M4SYS_kPCM_8bitsU: |
| *pMediaFamily = M4READER_kMediaFamilyAudio; |
| M4OSA_TRACE2_0("M4READER_PCM_getNextStream: found audio stream"); |
| break; |
| default: |
| *pMediaFamily = M4READER_kMediaFamilyUnknown; |
| M4OSA_TRACE2_0("M4READER_PCM_getNextStream: found UNKNOWN stream"); |
| return M4NO_ERROR; |
| } |
| |
| pAudioStreamHandler = (M4_AudioStreamHandler*)M4OSA_32bitAlignedMalloc(sizeof(M4_AudioStreamHandler), |
| M4READER_WAV, (M4OSA_Char *)"M4_AudioStreamHandler"); |
| if (pAudioStreamHandler == M4OSA_NULL) |
| { |
| return M4ERR_ALLOC; |
| } |
| pAudioStreamHandler->m_structSize = sizeof(M4_AudioStreamHandler); |
| pC->m_pAudioStream = (M4_StreamHandler*)(pAudioStreamHandler); |
| |
| pDsi = (M4PCMC_DecoderSpecificInfo*)(streamDesc.decoderSpecificInfo); |
| M4OSA_DEBUG_IF1((pDsi == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_getNextStream: invalid decoder specific info in stream"); |
| |
| pAudioStreamHandler->m_samplingFrequency = pDsi->SampleFrequency; |
| pAudioStreamHandler->m_byteSampleSize = (M4OSA_UInt32)(pDsi->BitsPerSample/8); |
| /* m_byteFrameLength is badly named: it is not in bytes but in samples number */ |
| if(pAudioStreamHandler->m_samplingFrequency == 8000) |
| { |
| /* AMR case */ |
| pAudioStreamHandler->m_byteFrameLength = |
| (((streamDesc.averageBitrate/8)/50)/pDsi->nbChannels)\ |
| /pAudioStreamHandler->m_byteSampleSize;/*/50 to get around 20 ms of audio*/ |
| } |
| else |
| { |
| /* AAC Case */ |
| pAudioStreamHandler->m_byteFrameLength = |
| (M4OSA_UInt32)(((streamDesc.averageBitrate/8)/15.625)/pDsi->nbChannels)\ |
| /pAudioStreamHandler->m_byteSampleSize; |
| } |
| |
| pAudioStreamHandler->m_nbChannels = pDsi->nbChannels; |
| |
| M4OSA_TIME_TO_MS( fDuration, streamDesc.duration, streamDesc.timeScale); |
| pC->m_pAudioStream->m_duration = (M4OSA_Int32)fDuration; |
| pC->m_pAudioStream->m_pDecoderSpecificInfo = (M4OSA_UInt8*)(streamDesc.decoderSpecificInfo); |
| pC->m_pAudioStream->m_decoderSpecificInfoSize = streamDesc.decoderSpecificInfoSize; |
| pC->m_pAudioStream->m_streamId = streamDesc.streamID; |
| pC->m_pAudioStream->m_pUserData = |
| (void*)streamDesc.timeScale; /*trick to change*/ |
| pC->m_pAudioStream->m_averageBitRate = streamDesc.averageBitrate; |
| pC->m_pAudioStream->m_maxAUSize = |
| pAudioStreamHandler->m_byteFrameLength*pAudioStreamHandler->m_byteSampleSize\ |
| *pAudioStreamHandler->m_nbChannels; |
| pC->m_pAudioStream->m_streamType = M4DA_StreamTypeAudioPcm; |
| |
| *pStreamHandler = pC->m_pAudioStream; |
| return err; |
| } |
| |
| /** |
| ************************************************************************ |
| * @brief fill the access unit structure with initialization values |
| * @note |
| * |
| * @param context: (IN) context of the network reader |
| * @param pStreamHandler: (IN) pointer to the stream handler to which the access unit will |
| * be associated |
| * @param pAccessUnit: (IN) 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 (in DEBUG only) |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4READER_PCM_fillAuStruct(M4OSA_Context context, M4_StreamHandler *pStreamHandler, |
| M4_AccessUnit *pAccessUnit) |
| { |
| M4READER_PCM_Context* pC = (M4READER_PCM_Context*)context; |
| M4SYS_AccessUnit* pAu; |
| |
| M4OSA_DEBUG_IF1((pC == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_fillAuStruct: invalid context"); |
| M4OSA_DEBUG_IF1((pStreamHandler == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_fillAuStruct: invalid pointer to M4_StreamHandler"); |
| M4OSA_DEBUG_IF1((pAccessUnit == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_fillAuStruct: invalid pointer to M4_AccessUnit"); |
| |
| if (pStreamHandler == (M4_StreamHandler*)pC->m_pAudioStream) |
| { |
| pAu = &pC->m_audioAu; |
| } |
| else |
| { |
| M4OSA_TRACE1_0("M4READER_PCM_fillAuStruct: passed StreamHandler is not known"); |
| return M4ERR_PARAMETER; |
| } |
| |
| pAu->dataAddress = M4OSA_NULL; |
| pAu->size = 0; |
| pAu->CTS = 0; |
| pAu->DTS = 0; |
| pAu->attribute = 0; |
| pAu->nbFrag = 0; |
| |
| pAccessUnit->m_size = 0; |
| pAccessUnit->m_CTS = 0; |
| pAccessUnit->m_DTS = 0; |
| 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 reset the stream, that is: seek it to beginning and make it ready to be read |
| * @note |
| * @param context: (IN) context of the network reader |
| * @param pStreamHandler: (IN) The stream handler of the stream to reset |
| * @return M4NO_ERROR: there is no error. |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4READER_PCM_reset(M4OSA_Context context, M4_StreamHandler *pStreamHandler) |
| { |
| M4READER_PCM_Context* pC = (M4READER_PCM_Context*)context; |
| M4SYS_StreamID streamIdArray[2]; |
| M4OSA_ERR err; |
| M4SYS_AccessUnit* pAu; |
| M4OSA_Time time64 = 0; |
| |
| M4OSA_DEBUG_IF1((pC == 0), M4ERR_PARAMETER, "M4READER_PCM_reset: invalid context"); |
| M4OSA_DEBUG_IF1((pStreamHandler == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_reset: invalid pointer to M4_StreamHandler"); |
| |
| if (pStreamHandler == (M4_StreamHandler*)pC->m_pAudioStream) |
| { |
| pAu = &pC->m_audioAu; |
| } |
| else |
| { |
| M4OSA_TRACE1_0("M4READER_PCM_reset: passed StreamHandler is not known"); |
| return M4ERR_PARAMETER; |
| } |
| |
| if (pAu->dataAddress != M4OSA_NULL) |
| { |
| err = M4PCMR_freeAU(pC->m_coreContext, pStreamHandler->m_streamId, pAu); |
| if (err != M4NO_ERROR) |
| { |
| M4OSA_TRACE1_0("M4READER_PCM_reset: error when freeing access unit"); |
| return err; |
| } |
| pAu->dataAddress = M4OSA_NULL; |
| } |
| |
| streamIdArray[0] = pStreamHandler->m_streamId; |
| streamIdArray[1] = 0; |
| |
| pAu->CTS = 0; |
| pAu->DTS = 0; |
| |
| /* This call is needed only when replay during playback */ |
| err = M4PCMR_seek(pC->m_coreContext, streamIdArray, time64, M4SYS_kBeginning, &time64); |
| |
| return err; |
| } |
| |
| /** |
| ************************************************************************ |
| * @brief Get the next access unit of the specified stream |
| * @note |
| * @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 |
| * @returns M4ERR_ALLOC memory allocation failed |
| * @returns M4ERR_BAD_STREAM_ID at least one of the stream Id. does not exist. |
| * @returns M4WAR_NO_DATA_YET there is no enough data on the stream for new access unit |
| * @returns M4WAR_NO_MORE_AU there are no more access unit in the stream (end of stream) |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4READER_PCM_getNextAu(M4OSA_Context context, M4_StreamHandler *pStreamHandler, |
| M4_AccessUnit *pAccessUnit) |
| { |
| M4READER_PCM_Context* pC = (M4READER_PCM_Context*)context; |
| M4OSA_ERR err = M4NO_ERROR; |
| M4SYS_AccessUnit* pAu; |
| |
| M4OSA_DEBUG_IF1((pC == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_getNextAu: invalid context"); |
| M4OSA_DEBUG_IF1((pStreamHandler == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_getNextAu: invalid pointer to M4_StreamHandler"); |
| M4OSA_DEBUG_IF1((pAccessUnit == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_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_PCM_getNextAu: passed StreamHandler is not known"); |
| return M4ERR_PARAMETER; |
| } |
| |
| if (pAu->dataAddress != M4OSA_NULL) |
| { |
| err = M4PCMR_freeAU(pC->m_coreContext, pStreamHandler->m_streamId, pAu); |
| if (err != M4NO_ERROR) |
| { |
| M4OSA_TRACE1_0("M4READER_PCM_getNextAu: error when freeing access unit"); |
| return err; |
| } |
| } |
| |
| pAu->nbFrag = 0; |
| err = M4PCMR_nextAU(pC->m_coreContext, pStreamHandler->m_streamId, pAu); |
| |
| if (err == M4NO_ERROR) |
| { |
| pAccessUnit->m_dataAddress = (M4OSA_MemAddr8)pAu->dataAddress; |
| pAccessUnit->m_size = pAu->size; |
| pAccessUnit->m_CTS = (M4OSA_Double)pAu->CTS; |
| pAccessUnit->m_DTS = (M4OSA_Double)pAu->DTS; |
| pAccessUnit->m_attribute = pAu->attribute; |
| } |
| else |
| { |
| pAccessUnit->m_size=0; |
| } |
| |
| return err; |
| } |
| |
| |
| /** |
| ************************************************************************ |
| * @brief jump into the stream at the specified time |
| * @note |
| * @param context: (IN) Context of the reader |
| * @param pStreamHandler (IN) the stream handler 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 |
| * But in this reader, we do not modify the time |
| * @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 M4ERR_BAD_STREAM_ID the streamID does not exist |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4READER_PCM_jump(M4OSA_Context context, M4_StreamHandler *pStreamHandler, |
| M4OSA_Int32* pTime) |
| { |
| M4READER_PCM_Context* pC = (M4READER_PCM_Context*)context; |
| M4SYS_StreamID streamIdArray[2]; |
| M4OSA_ERR err; |
| M4SYS_AccessUnit* pAu; |
| M4OSA_Time time64; |
| |
| M4OSA_DEBUG_IF1((pC == 0), M4ERR_PARAMETER, "M4READER_PCM_jump: invalid context"); |
| M4OSA_DEBUG_IF1((pStreamHandler == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_jump: invalid pointer to M4_StreamHandler"); |
| M4OSA_DEBUG_IF1((pTime == 0), M4ERR_PARAMETER, "M4READER_PCM_jump: invalid time pointer"); |
| |
| time64 = (M4OSA_Time)*pTime; |
| |
| if (pStreamHandler == pC->m_pAudioStream) |
| { |
| pAu = &pC->m_audioAu; |
| } |
| else |
| { |
| M4OSA_TRACE1_0("M4READER_PCM_jump: passed StreamHandler is not known"); |
| return M4ERR_PARAMETER; |
| } |
| |
| if (pAu->dataAddress != M4OSA_NULL) |
| { |
| err = M4PCMR_freeAU(pC->m_coreContext, pStreamHandler->m_streamId, pAu); |
| if (err != M4NO_ERROR) |
| { |
| M4OSA_TRACE1_0("M4READER_PCM_jump: Error when freeing access unit"); |
| return err; |
| } |
| pAu->dataAddress = M4OSA_NULL; |
| } |
| |
| streamIdArray[0] = pStreamHandler->m_streamId; |
| streamIdArray[1] = 0; |
| |
| pAu->CTS = time64; |
| pAu->DTS = time64; |
| |
| err = M4PCMR_seek(pC->m_coreContext, streamIdArray, time64, M4SYS_kBeginning, &time64); |
| |
| *pTime = (M4OSA_Int32)time64; |
| |
| 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_PCM_getInterfaces(M4READER_MediaType *pMediaType, |
| M4READER_GlobalInterface **pRdrGlobalInterface, |
| M4READER_DataInterface **pRdrDataInterface) |
| /************************************************************************/ |
| { |
| M4OSA_DEBUG_IF1((pMediaType == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_getInterfaces: invalid pointer to MediaType passed"); |
| M4OSA_DEBUG_IF1((pRdrGlobalInterface == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_getInterfaces: invalid pointer to M4READER_GlobalInterface"); |
| M4OSA_DEBUG_IF1((pRdrDataInterface == 0), M4ERR_PARAMETER, |
| "M4READER_PCM_getInterfaces: invalid pointer to M4READER_DataInterface"); |
| |
| *pRdrGlobalInterface = |
| (M4READER_GlobalInterface*)M4OSA_32bitAlignedMalloc( sizeof(M4READER_GlobalInterface), M4READER_WAV, |
| (M4OSA_Char *)"M4READER_PCM GlobalInterface"); |
| if (M4OSA_NULL == *pRdrGlobalInterface) |
| { |
| return M4ERR_ALLOC; |
| } |
| *pRdrDataInterface = |
| (M4READER_DataInterface*)M4OSA_32bitAlignedMalloc( sizeof(M4READER_DataInterface), M4READER_WAV, |
| (M4OSA_Char *) "M4READER_PCM DataInterface"); |
| if (M4OSA_NULL == *pRdrDataInterface) |
| { |
| free(*pRdrGlobalInterface); |
| return M4ERR_ALLOC; |
| } |
| |
| *pMediaType = M4READER_kMediaTypePCM; |
| |
| (*pRdrGlobalInterface)->m_pFctCreate = M4READER_PCM_create; |
| (*pRdrGlobalInterface)->m_pFctDestroy = M4READER_PCM_destroy; |
| (*pRdrGlobalInterface)->m_pFctOpen = M4READER_PCM_open; |
| (*pRdrGlobalInterface)->m_pFctClose = M4READER_PCM_close; |
| (*pRdrGlobalInterface)->m_pFctStart = M4OSA_NULL; |
| (*pRdrGlobalInterface)->m_pFctStop = M4OSA_NULL; |
| (*pRdrGlobalInterface)->m_pFctGetOption = M4READER_PCM_getOption; |
| (*pRdrGlobalInterface)->m_pFctSetOption = M4READER_PCM_setOption; |
| (*pRdrGlobalInterface)->m_pFctGetNextStream = M4READER_PCM_getNextStream; |
| (*pRdrGlobalInterface)->m_pFctFillAuStruct = M4READER_PCM_fillAuStruct; |
| (*pRdrGlobalInterface)->m_pFctJump = M4READER_PCM_jump; |
| (*pRdrGlobalInterface)->m_pFctReset = M4READER_PCM_reset; |
| (*pRdrGlobalInterface)->m_pFctGetPrevRapTime = M4OSA_NULL; /*all AUs are RAP*/ |
| |
| (*pRdrDataInterface)->m_pFctGetNextAu = M4READER_PCM_getNextAu; |
| |
| (*pRdrDataInterface)->m_readerContext = M4OSA_NULL; |
| |
| return M4NO_ERROR; |
| } |
| |
| |
