| /* ------------------------------------------------------------------ |
| * Copyright (C) 1998-2009 PacketVideo |
| * |
| * 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. |
| * ------------------------------------------------------------------- |
| */ |
| // -*- c++ -*- |
| // = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = |
| |
| // A M R F I L E P A R S E R |
| |
| // = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = |
| |
| |
| /** |
| * @file amrfileparser.cpp |
| * @brief This file contains the implementation of the raw GSM-AMR file parser. |
| */ |
| |
| //---------------------------------------------------------------------------- |
| // INCLUDES |
| //---------------------------------------------------------------------------- |
| #include "amrfileparser.h" |
| |
| // Use default DLL entry point for Symbian |
| #include "oscl_dll.h" |
| OSCL_DLL_ENTRY_POINT_DEFAULT() |
| |
| |
| /* Table containing the sum of the frame type byte */ |
| /* and the number of speech bytes for each codec mode */ |
| /* for IETF input format */ |
| static const int32 IetfDecInputBytes[NO_POSSIBLE_MODES] = |
| { |
| 13, /* 4.75 */ |
| 14, /* 5.15 */ |
| 16, /* 5.90 */ |
| 18, /* 6.70 */ |
| 20, /* 7.40 */ |
| 21, /* 7.95 */ |
| 27, /* 10.2 */ |
| 32, /* 12.2 */ |
| 6, /* GsmAmr comfort noise */ |
| 7, /* Gsm-Efr comfort noise */ |
| 6, /* IS-641 comfort noise */ |
| 6, /* Pdc-Efr comfort noise */ |
| 1, /* future use; 0 length but set to 1 to skip the frame type byte */ |
| 1, /* future use; 0 length but set to 1 to skip the frame type byte */ |
| 1, /* future use; 0 length but set to 1 to skip the frame type byte */ |
| 1 /* No transmission */ |
| }; |
| |
| /* Table containing the number of speech bytes for each codec mode */ |
| /* for IF2 input format */ |
| static const int32 If2DecInputBytes[NO_POSSIBLE_MODES] = |
| { |
| 13, /* 4.75 */ |
| 14, /* 5.15 */ |
| 16, /* 5.90 */ |
| 18, /* 6.70 */ |
| 19, /* 7.40 */ |
| 21, /* 7.95 */ |
| 26, /* 10.2 */ |
| 31, /* 12.2 */ |
| 6, /* GsmAmr comfort noise */ |
| 6, /* Gsm-Efr comfort noise */ |
| 6, /* IS-641 comfort noise */ |
| 6, /* Pdc-Efr comfort noise */ |
| 1, /* future use; 0 length but set to 1 to skip the frame type byte */ |
| 1, /* future use; 0 length but set to 1 to skip the frame type byte */ |
| 1, /* future use; 0 length but set to 1 to skip the frame type byte */ |
| 1 /* No transmission */ |
| }; |
| |
| static const int32 IetfWBDecInputBytes[NO_POSSIBLE_MODES] = |
| { |
| 18, /* 6.60 */ |
| 24, /* 8.85 */ |
| 33, /* 12.65 */ |
| 37, /* 14.25 */ |
| 41, /* 15.85 */ |
| 47, /* 18.25 */ |
| 51, /* 19.85 */ |
| 59, /* 23.05 */ |
| 61, /* 23.85 */ |
| 6, /* SID */ |
| 1, /* For future use : Set to 1 to skip the frame type byte */ |
| 1, /* For future use : Set to 1 to skip the frame type byte */ |
| 1, /* For future use : Set to 1 to skip the frame type byte */ |
| 1, /* For future use : Set to 1 to skip the frame type byte */ |
| 1, /* Speech lost */ |
| 1 /* No data/transmission */ |
| }; |
| |
| //! specially used in ResetPlayback(), re-position the file pointer |
| int32 bitstreamObject::reset(int32 filePos) |
| { |
| iFrame_type = 0; |
| iBytesRead = iInitFilePos + filePos; // set the initial value |
| iBytesProcessed = iBytesRead; |
| if (ipAMRFile) |
| { |
| ipAMRFile->Seek(iInitFilePos + filePos, Oscl_File::SEEKSET); |
| } |
| iPos = bitstreamObject::MAIN_BUFF_SIZE + bitstreamObject::SECOND_BUFF_SIZE; |
| return refill(); |
| } |
| |
| //! read data from bitstream, this is the only function to read data from file |
| int32 bitstreamObject::refill() |
| { |
| if (iBytesRead > 0 && iFileSize > 0 && iBytesRead >= iFileSize) |
| { |
| //At this point we're within 32 bytes of the end of data. |
| //Quit reading data but don't return EOF until all data is processed. |
| if (iBytesProcessed < iBytesRead) |
| return bitstreamObject::EVERYTHING_OK; |
| else |
| return bitstreamObject::END_OF_FILE; |
| } |
| |
| if (!ipAMRFile) |
| { |
| return bitstreamObject::MISC_ERROR; |
| } |
| |
| // Get file size at the very first time |
| if (iFileSize == 0) |
| { |
| if (ipAMRFile->Seek(0, Oscl_File::SEEKEND)) |
| { |
| return bitstreamObject::MISC_ERROR; |
| } |
| |
| iFileSize = ipAMRFile->Tell(); |
| |
| if (iFileSize <= 0) |
| { |
| return bitstreamObject::MISC_ERROR; |
| } |
| |
| if (ipAMRFile->Seek(0, Oscl_File::SEEKSET)) |
| { |
| return bitstreamObject::MISC_ERROR; |
| } |
| |
| // first-time read, set the initial value of iPos |
| iPos = bitstreamObject::SECOND_BUFF_SIZE; |
| iBytesProcessed = 0; |
| } |
| |
| else if (iPos == bitstreamObject::MAIN_BUFF_SIZE + bitstreamObject::SECOND_BUFF_SIZE) |
| { |
| // reset iPos and refill from the beginning of the file |
| iPos = bitstreamObject::SECOND_BUFF_SIZE; |
| } |
| |
| else if (iPos >= iActual_size) |
| { |
| // move the remaining stuff to the beginning of iBuffer |
| if (iActual_size < iMax_size) |
| { |
| // memory content will be overlapped |
| return bitstreamObject::MISC_ERROR; |
| } |
| int32 len = bitstreamObject::MAIN_BUFF_SIZE + bitstreamObject::SECOND_BUFF_SIZE - iPos; |
| oscl_memcpy(&iBuffer[bitstreamObject::SECOND_BUFF_SIZE-len], &iBuffer[iPos], len); |
| iPos = bitstreamObject::SECOND_BUFF_SIZE - len; |
| } |
| |
| // read data |
| if ((iActual_size = ipAMRFile->Read(&iBuffer[bitstreamObject::SECOND_BUFF_SIZE], 1, iMax_size)) == 0) |
| { |
| return bitstreamObject::READ_ERROR; |
| } |
| |
| iBytesRead += iActual_size; |
| |
| return bitstreamObject::EVERYTHING_OK; |
| } |
| |
| //! most important function to get one frame data plus frame type, used in getNextBundledAccessUnits() |
| int32 bitstreamObject::getNextFrame(uint8* frameBuffer, uint8& frame_type, bool bHeaderIncluded) |
| { |
| if (!frameBuffer) |
| { |
| return bitstreamObject::MISC_ERROR; |
| } |
| |
| int32 ret_value = bitstreamObject::EVERYTHING_OK; |
| |
| // Need to refill? |
| if (iFileSize == 0 || iPos >= iActual_size) |
| { |
| ret_value = refill(); |
| if (ret_value) |
| { |
| return ret_value; |
| } |
| } |
| |
| int32 frame_size = 0; |
| uint8 *pBuffer = &iBuffer[iPos]; |
| |
| if (EAMRIETF_SingleNB == iAmrFormat) // IETF format single channel NB |
| { |
| // Search the next IETF frame header (NOT returning error when the error is corrupt) |
| while ((iBuffer[iPos] & 0x83) != 0) |
| { |
| // Wrong IETF frame header(P+FT(4bits)+Q+PP) |
| if (iPos + 1 >= iActual_size) |
| { |
| ret_value = refill(); |
| if (ret_value) |
| { |
| return ret_value; |
| } |
| } |
| iPos++; |
| iBytesProcessed++; |
| } |
| pBuffer = &iBuffer[iPos]; |
| frame_type = (uint8)((pBuffer[0] >> 3) & 0x0f); |
| frame_size = IetfDecInputBytes[(uint16)frame_type]; |
| } |
| else if (EAMRIETF_SingleWB == iAmrFormat) // IETF format single channel WB |
| { |
| frame_type = (uint8)((pBuffer[0] >> 3) & 0x0f); |
| frame_size = IetfWBDecInputBytes[(uint16)frame_type]; |
| } |
| else if (iAmrFormat == EAMRIF2) // IF2 format |
| { |
| frame_type = (uint8)(pBuffer[0] & 0x0f); |
| frame_size = If2DecInputBytes[(uint16)frame_type]; |
| } |
| else |
| { |
| return bitstreamObject::MISC_ERROR; |
| } |
| |
| if (frame_size > 0) |
| { |
| if (bHeaderIncluded) |
| { |
| oscl_memcpy(frameBuffer, &pBuffer[0], frame_size); // With frame header |
| } |
| else |
| { |
| oscl_memcpy(frameBuffer, &pBuffer[1], frame_size - 1); // NO frame header |
| } |
| } |
| iPos += frame_size; |
| iBytesProcessed += frame_size; |
| |
| return ret_value; |
| } |
| |
| //! parse the IETF bitstream header: "$!AMR" + 0x0a, and get format(IETF, IF2, or WMF) |
| int32 bitstreamObject::parseIETFHeader() |
| { |
| int32 returnValue = reset(); |
| if (returnValue == bitstreamObject::EVERYTHING_OK) |
| { |
| iAmrFormat = EAMRUnrecognized; |
| |
| // first time read, we don't use iSecond_buffer |
| uint8 *pBuffer = &iBuffer[iPos]; |
| if (iActual_size >= 5 && |
| pBuffer[0] == '#' && |
| pBuffer[1] == '!' && |
| pBuffer[2] == 'A' && |
| pBuffer[3] == 'M' && |
| pBuffer[4] == 'R') |
| { |
| |
| if (pBuffer[5] == 0x0a) |
| { |
| // single channel AMR file |
| iAmrFormat = EAMRIETF_SingleNB; |
| iInitFilePos = 6; |
| } |
| |
| else if (iActual_size >= 11 && |
| pBuffer[5] == '_' && |
| pBuffer[6] == 'M' && |
| pBuffer[7] == 'C' && |
| pBuffer[8] == '1' && |
| pBuffer[9] == '.' && |
| pBuffer[10] == '0' && |
| pBuffer[11] == 0x0a) |
| { |
| // multi-channel AMR file |
| iAmrFormat = EAMRIETF_MultiNB; |
| iInitFilePos = 12; |
| } |
| else if (iActual_size >= 8 && |
| pBuffer[5] == '-' && |
| pBuffer[6] == 'W' && |
| pBuffer[7] == 'B') |
| { |
| |
| if (pBuffer[8] == 0x0a) |
| { |
| // single channel AMR-WB file |
| iAmrFormat = EAMRIETF_SingleWB; |
| iInitFilePos = 9; |
| } |
| else if (iActual_size >= 14 && |
| pBuffer[8] == '_' && |
| pBuffer[9] == 'M' && |
| pBuffer[10] == 'C' && |
| pBuffer[11] == '1' && |
| pBuffer[12] == '.' && |
| pBuffer[13] == '0' && |
| pBuffer[14] == 0x0a) |
| { |
| // multi-channel AMR-WB file |
| iAmrFormat = EAMRIETF_MultiWB; |
| iInitFilePos = 15; |
| } |
| } |
| } |
| iPos += iInitFilePos; |
| iBytesProcessed += iInitFilePos; |
| |
| // get the frame header |
| if (iAmrFormat == EAMRUnrecognized) |
| { |
| iFrame_type = iBuffer[iPos] & 0xf; |
| } |
| else // IETF |
| { |
| iFrame_type = (iBuffer[iPos] >> 3) & 0xf; |
| } |
| } |
| |
| return returnValue; |
| } |
| |
| //! get clip information: file size, format(IETF or IF2) and frame_type(bitrate) |
| int32 bitstreamObject::getFileInfo(int32& fileSize, int32& format, int32& frame_type) |
| { |
| fileSize = format = 0; |
| int32 ret_value = bitstreamObject::EVERYTHING_OK; |
| if (iFileSize == 0) |
| { |
| ret_value = parseIETFHeader(); |
| if (ret_value) |
| { |
| return ret_value; |
| } |
| } |
| |
| fileSize = iFileSize; |
| format = iAmrFormat; |
| frame_type = iFrame_type; |
| return ret_value; |
| } |
| |
| |
| //---------------------------------------------------------------------------- |
| // FUNCTION NAME: CAMRFileParser::CAMRFileParser |
| //---------------------------------------------------------------------------- |
| // INPUT AND OUTPUT DEFINITIONS |
| // |
| // Inputs: |
| // None |
| // |
| // Outputs: |
| // None |
| // |
| // Returns: |
| // None |
| // |
| // Global Variables Used: |
| // None |
| // |
| //---------------------------------------------------------------------------- |
| // FUNCTION DESCRIPTION |
| // |
| // Constructor for CAMRFileParser class |
| //---------------------------------------------------------------------------- |
| // REQUIREMENTS |
| // |
| //---------------------------------------------------------------------------- |
| // REFERENCES |
| // |
| //------------------------------------------------------------------------------ |
| // CAUTION |
| // |
| //------------------------------------------------------------------------------ |
| OSCL_EXPORT_REF CAMRFileParser::CAMRFileParser(void) |
| { |
| iAMRDuration = -1; |
| iAMRBitRate = 0; |
| iTotalNumFramesRead = 0; |
| iAMRFormat = EAMRUnrecognized; |
| iEndOfFileReached = false; |
| iRandomAccessTimeInterval = 0; |
| iCountToClaculateRDATimeInterval = 0; |
| iLogger = PVLogger::GetLoggerObject(" "); |
| iDiagnosticLogger = PVLogger::GetLoggerObject("playerdiagnostics.pvamr_parser"); |
| |
| ipBSO = NULL; |
| } |
| |
| //---------------------------------------------------------------------------- |
| // FUNCTION NAME: CAMRFileParser::~CAMRFileParser |
| //---------------------------------------------------------------------------- |
| // INPUT AND OUTPUT DEFINITIONS |
| // |
| // Inputs: |
| // None |
| // |
| // Outputs: |
| // None |
| // |
| // Returns: |
| // None |
| // |
| // Global Variables Used: |
| // None |
| // |
| //---------------------------------------------------------------------------- |
| // FUNCTION DESCRIPTION |
| // |
| // Destructor for CAMRFileParser class |
| //---------------------------------------------------------------------------- |
| // REQUIREMENTS |
| // |
| //---------------------------------------------------------------------------- |
| // REFERENCES |
| // |
| //------------------------------------------------------------------------------ |
| // CAUTION |
| // |
| //------------------------------------------------------------------------------ |
| OSCL_EXPORT_REF CAMRFileParser::~CAMRFileParser(void) |
| { |
| iAMRFile.Close(); |
| OSCL_DELETE(ipBSO); |
| ipBSO = NULL; |
| } |
| |
| //---------------------------------------------------------------------------- |
| // FUNCTION NAME: CAMRFileParser::InitAMRFile |
| //---------------------------------------------------------------------------- |
| // INPUT AND OUTPUT DEFINITIONS |
| // |
| // Inputs: |
| // iClip = pointer to the AMR file name to be played of type TPtrC |
| // |
| // Outputs: |
| // None |
| // |
| // Returns: |
| // returnValue = true if the init succeeds, else false. |
| // |
| // Global Variables Used: |
| // None |
| // |
| //---------------------------------------------------------------------------- |
| // FUNCTION DESCRIPTION |
| // |
| // This function opens the AMR file, checks for AMR format type, calculates |
| // the track duration, and sets the AMR bitrate value. |
| // |
| //---------------------------------------------------------------------------- |
| // REQUIREMENTS |
| // |
| //---------------------------------------------------------------------------- |
| // REFERENCES |
| // |
| //------------------------------------------------------------------------------ |
| // CAUTION |
| // |
| //------------------------------------------------------------------------------ |
| OSCL_EXPORT_REF bool CAMRFileParser::InitAMRFile(OSCL_wString& aClip, bool aInitParsingEnable, Oscl_FileServer* aFileSession, PVMFCPMPluginAccessInterfaceFactory*aCPM, OsclFileHandle*aHandle, uint32 countToClaculateRDATimeInterval) |
| { |
| iAMRFile.SetCPM(aCPM); |
| iAMRFile.SetFileHandle(aHandle); |
| |
| // Open the file (aClip) |
| if (iAMRFile.Open(aClip.get_cstr(), (Oscl_File::MODE_READ | Oscl_File::MODE_BINARY), *aFileSession) != 0) |
| { |
| PVMF_AMRPARSER_LOGERROR((0, "CAMRFileParser::InitAMRFile- File Open failed")); |
| return false; |
| } |
| |
| // create ipBSO |
| ipBSO = OSCL_NEW(bitstreamObject, (&iAMRFile)); |
| if (!ipBSO) |
| { |
| return false; |
| } |
| if (!ipBSO->get()) |
| { |
| return false; // make sure the memory allocation is going well |
| } |
| |
| // get file info |
| int32 frameTypeIndex = 0; |
| if (ipBSO->getFileInfo(iAMRFileSize, iAMRFormat, frameTypeIndex)) |
| { |
| PVMF_AMRPARSER_LOGERROR((0, "CAMRFileParser::InitAMRFile- getFileInfo failed ")); |
| return false; |
| } |
| |
| // Reject unsupported AMR file types |
| if (frameTypeIndex >= 16 || |
| iAMRFormat == EAMRETS || |
| iAMRFormat == EAMRIETF_MultiNB || |
| iAMRFormat == EAMRIETF_MultiWB || |
| iAMRFormat == EAMRWMF || |
| iAMRFormat == EAMRUnrecognized) |
| { |
| PVMF_AMRPARSER_LOGERROR((0, "CAMRFileParser::Unsupported AMR type ")); |
| return false; |
| } |
| |
| // Set bitrate |
| if (EAMRIETF_SingleWB != iAMRFormat) |
| { |
| AMRFF_Frame_Type_3GPP frameType3GPP = (AMRFF_Frame_Type_3GPP)frameTypeIndex; |
| SetBitRate(frameType3GPP); |
| } |
| else // for wide band |
| { |
| AMRFF_WB_Frame_Type_3GPP frameType3GPP = (AMRFF_WB_Frame_Type_3GPP)frameTypeIndex; |
| SetBitRate(frameType3GPP); |
| } |
| |
| // Determine file duration and set up random positioning table if needed |
| CalculateDuration(aInitParsingEnable, countToClaculateRDATimeInterval); |
| return true; |
| } |
| |
| bool CAMRFileParser::CalculateDuration(bool aInitParsingEnable, uint32 countToClaculateRDATimeInterval) |
| { |
| iCountToClaculateRDATimeInterval = countToClaculateRDATimeInterval; |
| uint32 FrameCount = iCountToClaculateRDATimeInterval; |
| iRandomAccessTimeInterval = countToClaculateRDATimeInterval * TIME_STAMP_PER_FRAME; |
| |
| if (aInitParsingEnable) |
| { |
| // Go through each frame to calculate AMR file duration. |
| int32 status = bitstreamObject::EVERYTHING_OK; |
| uint8 frame_type = 15; |
| iAMRDuration = 0; |
| |
| int32 error = 0; |
| |
| int32 filePos = 0; |
| |
| OSCL_TRY(error, iRPTable.push_back(filePos)); |
| OSCL_FIRST_CATCH_ANY(error, return false); |
| |
| while (status == bitstreamObject::EVERYTHING_OK) |
| { |
| // get the next frame |
| |
| status = ipBSO->getNextFrame(iAMRFrameBuffer, frame_type); // NO IETF frame header |
| |
| if (status == bitstreamObject::EVERYTHING_OK) |
| { |
| // calculate the number of frames // BX |
| iAMRDuration += TIME_STAMP_PER_FRAME; |
| |
| // set up the table for randow positioning |
| int32 frame_length = 0; |
| |
| if (iAMRFormat == EAMRIF2) |
| { |
| frame_length = If2DecInputBytes[(uint16)frame_type]; |
| } |
| else if (iAMRFormat == EAMRIETF_SingleNB) |
| { |
| frame_length = IetfDecInputBytes[(uint16)frame_type]; |
| } |
| else if (EAMRIETF_SingleWB == iAMRFormat) |
| { |
| frame_length = IetfWBDecInputBytes[(uint16)frame_type]; |
| } |
| else |
| { |
| PVMF_AMRPARSER_LOGERROR((0, "CAMRFileParser::CalculateDuration- Format unknown")); |
| return false; |
| } |
| |
| filePos += frame_length; |
| |
| error = 0; |
| if (!FrameCount) |
| { |
| OSCL_TRY(error, iRPTable.push_back(filePos)); |
| OSCL_FIRST_CATCH_ANY(error, return false); |
| FrameCount = countToClaculateRDATimeInterval; |
| } |
| } |
| |
| else if (status == bitstreamObject::END_OF_FILE) |
| { |
| break; |
| } |
| |
| else |
| { |
| // error happens! |
| PVMF_AMRPARSER_LOGERROR((0, "CAMRFileParser::getNextFrame Fails Error Code %d", status)); |
| if (ipBSO->reset()) |
| { |
| return false; |
| } |
| |
| return false; |
| } |
| FrameCount--; |
| } |
| |
| ResetPlayback(0); |
| } |
| return true; |
| } |
| |
| //---------------------------------------------------------------------------- |
| // FUNCTION NAME: CAMRFileParser::RetrieveAMRFileInfo |
| //---------------------------------------------------------------------------- |
| // INPUT AND OUTPUT DEFINITIONS |
| // |
| // Inputs: |
| // aMedia = pointer to CPVMedia class |
| // aTrackId = pointer to the ID specific to the current AMR track |
| // aTimescale = pointer to the sampling frequency value, for AMR it is 8000 Hz. |
| // |
| // Outputs: |
| // None |
| // |
| // Returns: |
| // false if an error happens, else true |
| // |
| // Global Variables Used: |
| // None |
| // |
| //---------------------------------------------------------------------------- |
| // FUNCTION DESCRIPTION |
| // |
| // This function opens the AMR file, checks for AMR format type, calculates |
| // the track duration, and sets the AMR bitrate value. |
| // |
| //---------------------------------------------------------------------------- |
| // REQUIREMENTS |
| // |
| //---------------------------------------------------------------------------- |
| // REFERENCES |
| // |
| //------------------------------------------------------------------------------ |
| // CAUTION |
| // |
| //------------------------------------------------------------------------------ |
| OSCL_EXPORT_REF bool CAMRFileParser::RetrieveFileInfo(TPVAmrFileInfo& aInfo) |
| { |
| if (iAMRFormat == EAMRUnrecognized) |
| { |
| // File is not open and parsed |
| return false; |
| } |
| |
| aInfo.iBitrate = iAMRBitRate; |
| aInfo.iTimescale = 1000; |
| aInfo.iDuration = iAMRDuration; |
| aInfo.iFileSize = iAMRFileSize; |
| aInfo.iAmrFormat = iAMRFormat; |
| PVMF_AMRPARSER_LOGDIAGNOSTICS((0, "CAMRFileParser::RetrieveFileInfo- duration = %d, bitrate = %d, filesize = %d", iAMRDuration, iAMRBitRate, iAMRFileSize)); |
| |
| return true; |
| } |
| |
| |
| //---------------------------------------------------------------------------- |
| // FUNCTION NAME: CAMRFileParser::SetBitRate |
| //---------------------------------------------------------------------------- |
| // INPUT AND OUTPUT DEFINITIONS |
| // |
| // Inputs: |
| // aFrameType3GPP = 3GPP frame type for the AMR frame of type AMRFF_Frame_Type_3GPP |
| // |
| // Outputs: |
| // None |
| // |
| // Returns: |
| // None |
| // |
| // Global Variables Used: |
| // None |
| // |
| //---------------------------------------------------------------------------- |
| // FUNCTION DESCRIPTION |
| // |
| // This function takes in the 3GPP frametype and sets the AMR bitrate value |
| // depending on the AMR frametype. |
| // |
| //---------------------------------------------------------------------------- |
| // REQUIREMENTS |
| // |
| //---------------------------------------------------------------------------- |
| // REFERENCES |
| // |
| //------------------------------------------------------------------------------ |
| // CAUTION |
| // |
| //------------------------------------------------------------------------------ |
| void CAMRFileParser::SetBitRate(AMRFF_Frame_Type_3GPP aFrameType3GPP) |
| { |
| switch (aFrameType3GPP) |
| { |
| case AMRFF_AMR_475: |
| { |
| iAMRBitRate = 4750; |
| break; |
| } |
| case AMRFF_AMR_515: |
| { |
| iAMRBitRate = 5150; |
| break; |
| } |
| case AMRFF_AMR_59: |
| { |
| iAMRBitRate = 5900; |
| break; |
| } |
| case AMRFF_AMR_67: |
| { |
| iAMRBitRate = 6700; |
| break; |
| } |
| case AMRFF_AMR_74: |
| { |
| iAMRBitRate = 7400; |
| break; |
| } |
| case AMRFF_AMR_795: |
| { |
| iAMRBitRate = 7950; |
| break; |
| } |
| case AMRFF_AMR_102: |
| { |
| iAMRBitRate = 10200; |
| break; |
| } |
| case AMRFF_AMR_122: |
| { |
| iAMRBitRate = 12200; |
| break; |
| } |
| default: |
| { |
| iAMRBitRate = 0; |
| break; |
| } |
| } |
| return; |
| } |
| |
| |
| void CAMRFileParser::SetBitRate(AMRFF_WB_Frame_Type_3GPP aFrameType3GPP) |
| { |
| switch (aFrameType3GPP) |
| { |
| case AMRFF_WB_660: |
| { |
| iAMRBitRate = 6600; |
| break; |
| } |
| case AMRFF_WB_885: |
| { |
| iAMRBitRate = 8850; |
| break; |
| } |
| case AMRFF_WB_1265: |
| { |
| iAMRBitRate = 12650; |
| break; |
| } |
| case AMRFF_WB_1425: |
| { |
| iAMRBitRate = 14250; |
| break; |
| } |
| case AMRFF_WB_1585: |
| { |
| iAMRBitRate = 15850; |
| break; |
| } |
| case AMRFF_WB_1825: |
| { |
| iAMRBitRate = 18250; |
| break; |
| } |
| case AMRFF_WB_1985: |
| { |
| iAMRBitRate = 19850; |
| break; |
| } |
| case AMRFF_WB_2305: |
| { |
| iAMRBitRate = 23050; |
| break; |
| } |
| case AMRFF_WB_2385: |
| { |
| iAMRBitRate = 23850; |
| break; |
| } |
| default: |
| { |
| iAMRBitRate = 0; |
| break; |
| } |
| } |
| return; |
| } |
| |
| |
| |
| //---------------------------------------------------------------------------- |
| // FUNCTION NAME: CAMRFileParser::ResetPlayback |
| //---------------------------------------------------------------------------- |
| // INPUT AND OUTPUT DEFINITIONS |
| // |
| // Inputs: |
| // aStartTime = integer value as where to move the playback positioning to. |
| // |
| // Outputs: |
| // None |
| // |
| // Returns: |
| // 0 if success, -1 if failure |
| // |
| // Global Variables Used: |
| // None |
| // |
| //---------------------------------------------------------------------------- |
| // FUNCTION DESCRIPTION |
| // |
| // This function sets the file pointer to the location that aStartTime would |
| // point to in the file. |
| // |
| //---------------------------------------------------------------------------- |
| // REQUIREMENTS |
| // |
| //---------------------------------------------------------------------------- |
| // REFERENCES |
| // |
| //------------------------------------------------------------------------------ |
| // CAUTION |
| // |
| //------------------------------------------------------------------------------ |
| OSCL_EXPORT_REF int32 CAMRFileParser::ResetPlayback(int32 aStartTime) |
| { |
| // get file size info, //iAMRFile.Size(fileSize) |
| int32 result; |
| if (iAMRFileSize <= 0) |
| { |
| int32 frameTypeIndex; |
| if (ipBSO->getFileInfo(iAMRFileSize, iAMRFormat, frameTypeIndex)) |
| { |
| PVMF_AMRPARSER_LOGERROR((0, "CAMRFileParser::Reset Playback Failed")); |
| return bitstreamObject::MISC_ERROR; |
| } |
| } |
| |
| iEndOfFileReached = false; |
| // initialize "iTotalNumFramesRead" |
| // note: +1 means we choose the next frame(ts>=aStartTime) |
| iTotalNumFramesRead = aStartTime / TIME_STAMP_PER_FRAME + (aStartTime > 0) * 1; |
| |
| uint32 tblIdx = aStartTime / (iRandomAccessTimeInterval);// +(aStartTime>0)*1; |
| iTotalNumFramesRead = tblIdx * iCountToClaculateRDATimeInterval; |
| |
| PVMF_AMRPARSER_LOGDIAGNOSTICS((0, "CAMRFileParser::resetplayback - TotalNumFramesRead=%d", iTotalNumFramesRead)); |
| // set new file position |
| int32 newPosition = 0; |
| if (iTotalNumFramesRead > 0) |
| { |
| // At the first time, don't do reset |
| if (iAMRDuration != 0 && iRPTable.size() == 0) |
| { |
| newPosition = (iAMRFileSize * aStartTime) / iAMRDuration; |
| PVMF_AMRPARSER_LOGDIAGNOSTICS((0, "CAMRFileParser::resetplayback - newPosition=%d", newPosition)); |
| if (newPosition < 0) |
| { |
| // if we have no duration information, reset the file position at 0. |
| newPosition = 0; |
| } |
| } |
| else if (iRPTable.size() > 0) |
| { |
| // use the randow positioning table to determine the file position |
| if (tblIdx >= iRPTable.size()) |
| { |
| // Requesting past the end of table so set to (end of table-1) |
| // to be at the last sample |
| tblIdx = ((int32)iRPTable.size()) - 2; |
| } |
| newPosition = iRPTable[tblIdx]; |
| } |
| } |
| result = ipBSO->reset(newPosition); |
| if (newPosition >= 0 && result) |
| { |
| PVMF_AMRPARSER_LOGERROR((0, "AMRBitstreamObject::refill- Misc Error")); |
| return result; |
| } |
| iEndOfFileReached = false; |
| |
| return bitstreamObject::EVERYTHING_OK; |
| } |
| |
| |
| //---------------------------------------------------------------------------- |
| // FUNCTION NAME: CAMRFileParser::SeekPointFromTimestamp |
| //---------------------------------------------------------------------------- |
| // INPUT AND OUTPUT DEFINITIONS |
| // |
| // Inputs: |
| // aStartTime = integer value as for the specified start time |
| // |
| // Outputs: |
| // None |
| // |
| // Returns: |
| // Timestamp in milliseconds of the actual position |
| // |
| // Global Variables Used: |
| // None |
| // |
| //---------------------------------------------------------------------------- |
| // FUNCTION DESCRIPTION |
| // |
| // This function returns the timestamp for an actual position corresponding |
| // to the specified start time |
| // |
| //---------------------------------------------------------------------------- |
| // REQUIREMENTS |
| // |
| //---------------------------------------------------------------------------- |
| // REFERENCES |
| // |
| //------------------------------------------------------------------------------ |
| // CAUTION |
| // |
| //------------------------------------------------------------------------------ |
| OSCL_EXPORT_REF uint32 CAMRFileParser::SeekPointFromTimestamp(uint32 aStartTime) |
| { |
| // get file size info, //iAMRFile.Size(fileSize) |
| if (iAMRFileSize <= 0) |
| { |
| int32 frameTypeIndex; |
| if (ipBSO->getFileInfo(iAMRFileSize, iAMRFormat, frameTypeIndex)) |
| { |
| return 0; |
| } |
| } |
| |
| // Determine the frame number corresponding to timestamp |
| // note: +1 means we choose the next frame(ts>=aStartTime) |
| uint32 startframenum = aStartTime / TIME_STAMP_PER_FRAME + (aStartTime > 0) * 1; |
| |
| // Correct the frame number if necessary |
| if (startframenum > 0) |
| { |
| if (iAMRDuration != 0 && iRPTable.size() <= 0) |
| { |
| // Duration not known and reposition table not available so go to first frame |
| startframenum = 0; |
| } |
| else if (iRPTable.size() > 0) |
| { |
| if (startframenum >= iRPTable.size()) |
| { |
| // Requesting past the end of table so set to (end of table-1) |
| // to be at the last sample |
| startframenum = ((int32)iRPTable.size()) - 2; |
| } |
| } |
| } |
| |
| return (startframenum*TIME_STAMP_PER_FRAME); |
| } |
| |
| //---------------------------------------------------------------------------- |
| // FUNCTION NAME: CAMRFileParser::GetNextBundledAccessUnits |
| //---------------------------------------------------------------------------- |
| // INPUT AND OUTPUT DEFINITIONS |
| // |
| // Inputs: |
| // aNumSamples = requested number of frames to be read from file |
| // aGau = frame information structure of type GAU |
| // |
| // Outputs: |
| // None |
| // |
| // Returns: |
| // 0 if success, -1 if failure |
| // |
| // Global Variables Used: |
| // None |
| // |
| //---------------------------------------------------------------------------- |
| // FUNCTION DESCRIPTION |
| // |
| // This function attempts to read in the number of AMR frames specified by |
| // aNumSamples. It formats the read data to WMF bit order and stores it in |
| // the GAU structure. |
| // |
| //---------------------------------------------------------------------------- |
| // REQUIREMENTS |
| // |
| //---------------------------------------------------------------------------- |
| // REFERENCES |
| // |
| //------------------------------------------------------------------------------ |
| // CAUTION |
| // |
| //------------------------------------------------------------------------------ |
| OSCL_EXPORT_REF int32 CAMRFileParser::GetNextBundledAccessUnits(uint32 *aNumSamples, GAU *aGau) |
| { |
| // AMR format has already been identified in InitAMRFile function. |
| // Check if AMR format is valid as the safeguard |
| if (iAMRFormat == EAMRUnrecognized) |
| { |
| PVMF_AMRPARSER_LOGERROR((0, "CAMRFileParser::GetNextBundledAccessUnits Failed - Unrecognized format")); |
| return bitstreamObject::MISC_ERROR; |
| } |
| |
| // Check the requested number of frames is not greater than the max supported |
| if (*aNumSamples > MAX_NUM_FRAMES_PER_BUFF) |
| { |
| PVMF_AMRPARSER_LOGERROR((0, "CAMRFileParser::GetNextBundledAccessUnits Failed - requested number of frames is greater than the max supported")); |
| return bitstreamObject::MISC_ERROR; |
| } |
| |
| int32 returnValue = bitstreamObject::EVERYTHING_OK; |
| |
| if (iEndOfFileReached) |
| { |
| *aNumSamples = 0; |
| return bitstreamObject::END_OF_FILE; |
| } |
| |
| uint8* pTempGau = (uint8 *) aGau->buf.fragments[0].ptr; |
| uint32 gauBufferSize = aGau->buf.fragments[0].len; |
| uint32 i, bytesReadInGau = 0, numSamplesRead = 0; |
| |
| for (i = 0; i < *aNumSamples && !iEndOfFileReached; i++) |
| { |
| // get the next frame |
| bool bHeaderIncluded = true; |
| returnValue = ipBSO->getNextFrame(iAMRFrameBuffer, iAMRFrameHeaderBuffer[i], bHeaderIncluded); |
| if (returnValue == bitstreamObject::END_OF_FILE) |
| { |
| iEndOfFileReached = true; |
| break; |
| } |
| else if (returnValue == bitstreamObject::EVERYTHING_OK) |
| { |
| } |
| else |
| { // error happens!! |
| *aNumSamples = 0; |
| return bitstreamObject::READ_ERROR; |
| } |
| |
| // Now a frame exists in iAMRFrameBuffer, move it to aGau |
| int32 frame_size = 0; |
| if (iAMRFormat == EAMRIF2) |
| { |
| frame_size = If2DecInputBytes[(uint16)iAMRFrameHeaderBuffer[i]]; |
| } |
| else if (iAMRFormat == EAMRIETF_SingleNB) |
| { |
| frame_size = IetfDecInputBytes[(uint16)iAMRFrameHeaderBuffer[i]]; |
| } |
| else if (iAMRFormat == EAMRIETF_SingleWB) |
| { |
| frame_size = IetfWBDecInputBytes[(uint16)iAMRFrameHeaderBuffer[i]]; |
| } |
| else |
| { |
| PVMF_AMRPARSER_LOGERROR((0, "AMRBitstreamObject::refill- Misc Error")); |
| return bitstreamObject::MISC_ERROR; |
| } |
| |
| // Check whether the gau buffer will be overflow |
| if (bytesReadInGau + frame_size >= gauBufferSize) |
| { |
| // Undo the read |
| ipBSO->undoGetNextFrame(frame_size); |
| break; |
| } |
| |
| if (frame_size > 0) |
| { |
| oscl_memcpy(pTempGau, iAMRFrameBuffer, frame_size); |
| |
| pTempGau += frame_size; |
| bytesReadInGau += frame_size; |
| } |
| aGau->info[i].len = frame_size; |
| aGau->info[i].ts = (iTotalNumFramesRead + (numSamplesRead++)) * TIME_STAMP_PER_FRAME; |
| |
| } // end of: for(i = 0; i < *aNumSamples && !iEndOfFileReached; i++) |
| |
| aGau->info[0].ts = iTotalNumFramesRead * TIME_STAMP_PER_FRAME; |
| |
| *aNumSamples = numSamplesRead; |
| iTotalNumFramesRead += numSamplesRead; |
| |
| //We may have reached EOF but also found some samples. |
| //don't return EOF until there are no samples left. |
| if (returnValue == bitstreamObject::END_OF_FILE |
| && numSamplesRead > 0) |
| return bitstreamObject::EVERYTHING_OK; |
| |
| return returnValue; |
| } |
| |
| OSCL_EXPORT_REF int32 CAMRFileParser::PeekNextTimestamp(uint32 *aTimestamp) |
| { |
| |
| *aTimestamp = iTotalNumFramesRead * TIME_STAMP_PER_FRAME; |
| |
| return bitstreamObject::EVERYTHING_OK; |
| } |
| |
| |
| OSCL_EXPORT_REF uint8 CAMRFileParser::GetFrameTypeInCurrentBundledAccessUnits(uint32 frameIndex) |
| { |
| if (frameIndex >= MAX_NUM_FRAMES_PER_BUFF) |
| { |
| return 0; |
| } |
| return iAMRFrameHeaderBuffer[frameIndex]; |
| } |
| |
| OSCL_EXPORT_REF int32 CAMRFileParser::getTrackMaxBufferSizeDB() |
| { |
| if (ipBSO) |
| { |
| return ipBSO->getTrackMaxBufferSizeDB(); |
| } |
| else |
| { |
| return -1; |
| } |
| } |
| |
| |
| OSCL_EXPORT_REF uint8* CAMRFileParser::getCodecSpecificInfo() |
| { |
| |
| bool bHeaderIncluded = true; |
| ipBSO->getNextFrame(iAMRFrameBuffer, iAMRFrameHeaderBuffer[1], bHeaderIncluded); |
| return iAMRFrameHeaderBuffer; |
| } |
| |
| |
