| /* ------------------------------------------------------------------ |
| * Copyright (C) 2008 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. |
| * ------------------------------------------------------------------- |
| */ |
| #include "pv_avifile_streamlist.h" |
| |
| PVAviFileStreamlist::PVAviFileStreamlist(PVFile *aFp, uint32 aStrListSz) |
| { |
| iCodecSpecificHdrDataSize = 0; |
| iStreamListSize = aStrListSz; |
| ipCodecSpecificHdrData = NULL; |
| iError = PV_AVI_FILE_PARSER_SUCCESS; |
| uint32 bytesRead = 0; |
| uint32 chunkType = 0; |
| |
| while (bytesRead < iStreamListSize) |
| { |
| if ((iError = PVAviFileParserUtils::ReadNextChunkType(aFp, chunkType)) != PV_AVI_FILE_PARSER_SUCCESS) |
| { |
| PVAVIFILE_LOGINFO((0, "PVAviFileStreamlist::PVAviFileStreamlist: Unsupported chunk")); |
| |
| if (PV_AVI_FILE_PARSER_UNSUPPORTED_CHUNK == iError) |
| { |
| uint32 chksz = 0; |
| if (PV_AVI_FILE_PARSER_SUCCESS != PVAviFileParserUtils::read32(aFp, chksz, true)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Read Error")); |
| iError = PV_AVI_FILE_PARSER_READ_ERROR; |
| break; |
| } |
| aFp->Seek(chksz, Oscl_File::SEEKCUR); |
| bytesRead += chksz + CHUNK_SIZE + CHUNK_SIZE; // data + chunk size + chunk type |
| |
| PVAVIFILE_LOGINFO((0, "PVAviFileStreamlist::PVAviFileStreamlist: Unsupported Chunk Skipped")); |
| |
| iError = PV_AVI_FILE_PARSER_SUCCESS; |
| continue; |
| } |
| else |
| { |
| |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Read Error")); |
| iError = PV_AVI_FILE_PARSER_READ_ERROR; |
| break; |
| } |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (STRH == chunkType) |
| { |
| PVAVIFILE_LOGINFO((0, "PVAviFileStreamlist::PVAviFileStreamlist: Found Stream Header")); |
| |
| uint32 aviStrhSize = 0; |
| if (PV_AVI_FILE_PARSER_SUCCESS != PVAviFileParserUtils::read32(aFp, aviStrhSize, true)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Read Error")); |
| iError = PV_AVI_FILE_PARSER_READ_ERROR; |
| break; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (bytesRead > iStreamListSize) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File & Byte Count mismatch")); |
| iError = PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| break; |
| |
| } |
| |
| if ((aviStrhSize <= 0) || (aviStrhSize > iStreamListSize)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: stream header size greater than stream list size")); |
| iError = PV_AVI_FILE_PARSER_WRONG_SIZE; |
| break; |
| |
| } |
| |
| if ((iError = ParseStreamHeader(aFp, aviStrhSize)) != PV_AVI_FILE_PARSER_SUCCESS) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: ParseStreamHeader function error")); |
| break; |
| } |
| |
| bytesRead += aviStrhSize; |
| if (bytesRead > iStreamListSize) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Size & Byte Count Mismatch")); |
| iError = PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| break; |
| |
| } |
| } |
| else if (STRF == chunkType) |
| { |
| PVAVIFILE_LOGINFO((0, "PVAviFileStreamlist::PVAviFileStreamlist: Found Stream Format Header")); |
| |
| uint32 aviStrfSize = 0; |
| if (PV_AVI_FILE_PARSER_SUCCESS != PVAviFileParserUtils::read32(aFp, aviStrfSize, true)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Read Error")); |
| iError = PV_AVI_FILE_PARSER_READ_ERROR; |
| break; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (bytesRead > iStreamListSize) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Size & Byte Count Mismatch")); |
| iError = PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| break; |
| |
| } |
| |
| if ((aviStrfSize <= 0) || (aviStrfSize > iStreamListSize)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: Stream Format Header Size Greater Than Stream List Size")); |
| iError = PV_AVI_FILE_PARSER_WRONG_SIZE; |
| break; |
| |
| } |
| |
| if ((iError = ParseStreamFormat(aFp, aviStrfSize)) != PV_AVI_FILE_PARSER_SUCCESS) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: ParseStreamFormat returned error")); |
| break; |
| } |
| |
| bytesRead += aviStrfSize; |
| if (bytesRead > iStreamListSize) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Size & Byte Count Mismatch")); |
| iError = PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| break; |
| |
| } |
| } |
| else if (STRD == chunkType) |
| { |
| if (PV_AVI_FILE_PARSER_SUCCESS != PVAviFileParserUtils::read32(aFp, iCodecSpecificHdrDataSize, true)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Read Error")); |
| iError = PV_AVI_FILE_PARSER_READ_ERROR; |
| break; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if ((iCodecSpecificHdrDataSize <= 0) || (iCodecSpecificHdrDataSize > iStreamListSize)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Size & Byte Count Mismatch")); |
| iError = PV_AVI_FILE_PARSER_WRONG_SIZE; |
| break; |
| } |
| |
| ipCodecSpecificHdrData = (uint8*)oscl_malloc(iCodecSpecificHdrDataSize); |
| if (0 == PVAviFileParserUtils::read8(aFp, ipCodecSpecificHdrData, iCodecSpecificHdrDataSize)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Read Error")); |
| iError = PV_AVI_FILE_PARSER_READ_ERROR; |
| break; |
| } |
| |
| bytesRead += iCodecSpecificHdrDataSize; |
| if (bytesRead > iStreamListSize) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Size & Byte Count Mismatch")); |
| iError = PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| break; |
| } |
| } |
| else if (STRN == chunkType) |
| { |
| PVAVIFILE_LOGINFO((0, "PVAviFileStreamlist::PVAviFileStreamlist: Found stream name")); |
| |
| uint32 strnSz = 0; |
| if (PV_AVI_FILE_PARSER_SUCCESS != PVAviFileParserUtils::read32(aFp, strnSz, true)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Read Error")); |
| iError = PV_AVI_FILE_PARSER_READ_ERROR; |
| break; |
| } |
| bytesRead += CHUNK_SIZE; |
| if (strnSz >= MAX_STRN_SZ) |
| { |
| uint8* strn = (uint8*)oscl_malloc(strnSz); |
| if (PVAviFileParserUtils::read8(aFp, strn, strnSz) == 0) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Read Error")); |
| iError = PV_AVI_FILE_PARSER_READ_ERROR; |
| break; |
| } |
| |
| oscl_strncpy(iStreamName, (char*)strn, MAX_STRN_SZ); |
| oscl_free(strn); |
| } |
| else |
| { |
| if (PVAviFileParserUtils::read8(aFp, (uint8*)iStreamName, strnSz) == 0) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Read Error")); |
| iError = PV_AVI_FILE_PARSER_READ_ERROR; |
| break; |
| } |
| } |
| |
| bytesRead += strnSz; |
| if (bytesRead > iStreamListSize) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Size & Byte Count Mismatch")); |
| iError = PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| break; |
| } |
| |
| } |
| else if (JUNK == chunkType) |
| { |
| PVAVIFILE_LOGINFO((0, "PVAviFileStreamlist::PVAviFileStreamlist: Skip Junk Data")); |
| |
| uint32 junkSize = 0; |
| if (PV_AVI_FILE_PARSER_SUCCESS != PVAviFileParserUtils::read32(aFp, junkSize, true)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Read Error")); |
| iError = PV_AVI_FILE_PARSER_READ_ERROR; |
| break; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| if (bytesRead > iStreamListSize) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Size & Byte Count Mismatch")); |
| iError = PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| break; |
| } |
| |
| if ((junkSize <= 0) || (junkSize > iStreamListSize)) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: Junk data size more than stream list size")); |
| iError = PV_AVI_FILE_PARSER_WRONG_SIZE; |
| break; |
| } |
| |
| aFp->Seek(junkSize, Oscl_File::SEEKCUR); |
| bytesRead += junkSize; |
| if (bytesRead > iStreamListSize) |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: File Size & Byte Count Mismatch")); |
| iError = PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| break; |
| } |
| |
| } |
| else |
| { |
| PVAVIFILE_LOGERROR((0, "PVAviFileStreamlist::PVAviFileStreamlist: Unexpected chunk in stream list")); |
| iError = PV_AVI_FILE_PARSER_WRONG_CHUNK; |
| break; |
| } |
| |
| |
| } //while(bytesRead <= iStreamListSize) |
| |
| } |
| |
| |
| PV_AVI_FILE_PARSER_ERROR_TYPE |
| PVAviFileStreamlist::ParseStreamHeader(PVFile *aFp, uint32 aHdrSize) |
| { |
| |
| uint32 bytesRead = 0; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != PVAviFileParserUtils::read32(aFp, iStreamHdr.iStreamTypeFCC)) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (0 == (PVAviFileParserUtils::read8(aFp, iStreamHdr.iStreamHandler, CHUNK_SIZE))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamHdr.iFlags))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (iStreamHdr.iFlags != 0) |
| { |
| if (iStreamHdr.iFlags & AVISF_VIDEO_PALCHANGES) |
| iStreamHdr.iIsVidPalChangeAvailable = true; |
| |
| if (iStreamHdr.iFlags & AVISF_DISABLED) |
| iStreamHdr.iAVISF_Disabled = true; |
| } |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamHdr.iPriority, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += sizeof(iStreamHdr.iPriority); |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamHdr.iLanguage, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += sizeof(iStreamHdr.iPriority); |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamHdr.iInitFrames, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamHdr.iScale, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamHdr.iRate, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamHdr.iStart, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamHdr.iLength, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamHdr.iSugBufSize, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamHdr.iQuality, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamHdr.iSampleSize, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| |
| if (bytesRead > aHdrSize) |
| { |
| return PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| } |
| else if (bytesRead == aHdrSize) |
| { |
| return PV_AVI_FILE_PARSER_SUCCESS; |
| } |
| else // read rcFrame |
| { |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamHdr.ircFrame.left, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| else |
| { |
| bytesRead += sizeof(uint16); |
| } |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamHdr.ircFrame.top, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| else |
| { |
| bytesRead += sizeof(uint16); |
| } |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamHdr.ircFrame.right, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| else |
| { |
| bytesRead += sizeof(uint16); |
| } |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamHdr.ircFrame.bottom, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| else |
| { |
| bytesRead += sizeof(uint16); |
| } |
| } |
| |
| if (bytesRead != aHdrSize) |
| { |
| return PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| } |
| |
| iStreamHdr.iSamplingRate = iStreamHdr.iRate / iStreamHdr.iScale; |
| |
| return PV_AVI_FILE_PARSER_SUCCESS; |
| } |
| |
| |
| PV_AVI_FILE_PARSER_ERROR_TYPE |
| PVAviFileStreamlist::ParseStreamFormat(PVFile *aFp, uint32 aHdrSize) |
| { |
| uint32 bytesRead = 0; |
| switch (iStreamHdr.iStreamTypeFCC) |
| { |
| case AUDS: |
| { |
| iStreamFmt.iType = AUDIO; |
| } |
| break; |
| case VIDS: |
| { |
| iStreamFmt.iType = VIDEO; |
| } |
| break; |
| case MIDI: |
| { |
| iStreamFmt.iType = MIDI; |
| } |
| break; |
| case TXTS: |
| { |
| iStreamFmt.iType = TEXT; |
| } |
| break; |
| default: |
| { |
| return PV_AVI_FILE_PARSER_ERROR_STREAM_TYPE_UNKNOWN; |
| } |
| |
| } |
| ; //end switch |
| |
| if (iStreamFmt.iType == AUDIO) |
| { |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamFmt.iAudWaveFormatEx.FormatTag, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += sizeof(uint16); |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamFmt.iAudWaveFormatEx.Channels, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += sizeof(uint16); |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iAudWaveFormatEx.SamplesPerSec, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iAudWaveFormatEx.AvgBytesPerSec, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += CHUNK_SIZE; |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamFmt.iAudWaveFormatEx.BlockAlign, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += sizeof(uint16); |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamFmt.iAudWaveFormatEx.BitsPerSample, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| bytesRead += sizeof(uint16); |
| |
| if (bytesRead < aHdrSize) |
| { |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamFmt.iAudWaveFormatEx.Size, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| } |
| else |
| { |
| iStreamFmt.iAudWaveFormatEx.Size = 0; |
| } |
| |
| } |
| else if (iStreamFmt.iType == VIDEO) |
| { |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiSize, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiWidth, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiHeight, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiPlanes, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += sizeof(uint16); |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read16(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiBitCount, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += sizeof(uint16); |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiCompression, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiSizeImage, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiXPelsPerMeter, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiYPelsPerMeter, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiClrUsed, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += CHUNK_SIZE; |
| |
| if (PV_AVI_FILE_PARSER_SUCCESS != (PVAviFileParserUtils::read32(aFp, iStreamFmt.iVidBitMapInfo.BmiHeader.BiClrImportant, true))) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| bytesRead += CHUNK_SIZE; |
| |
| //get the color table size |
| uint32 colorTblSize = iStreamFmt.iVidBitMapInfo.BmiHeader.BiClrUsed; |
| |
| if (colorTblSize == 0) |
| { |
| switch (iStreamFmt.iVidBitMapInfo.BmiHeader.BiBitCount) |
| { |
| case BIT_COUNT1: |
| { |
| colorTblSize = 2; |
| } |
| break; |
| case BIT_COUNT2: |
| { |
| colorTblSize = 4; |
| } |
| break; |
| case BIT_COUNT4: |
| { |
| colorTblSize = 16; |
| } |
| break; |
| case BIT_COUNT8: |
| { |
| colorTblSize = 256; |
| } |
| break; |
| case BIT_COUNT16: |
| case BIT_COUNT32: |
| { |
| if (BI_BITFIELDS == iStreamFmt.iVidBitMapInfo.BmiHeader.BiCompression) |
| { |
| colorTblSize = 3; |
| } |
| else if (BI_ALPHABITFIELDS == iStreamFmt.iVidBitMapInfo.BmiHeader.BiCompression) |
| { |
| colorTblSize = 4; |
| } |
| else if (BI_RGB == iStreamFmt.iVidBitMapInfo.BmiHeader.BiCompression) |
| { |
| colorTblSize = 0; |
| } |
| |
| } |
| break; |
| case BIT_COUNT24: |
| { |
| colorTblSize = 0; |
| } |
| break; |
| default: |
| return PV_AVI_FILE_PARSER_WRONG_BIT_COUNT; |
| |
| } //switch |
| } |
| |
| iStreamFmt.iVidBitMapInfo.BmiColorsCount = colorTblSize; |
| |
| uint32 length = 1; |
| //get color table entries |
| for (uint32 ii = 0; ii < colorTblSize; ii++) |
| { |
| if (length != PVAviFileParserUtils::read8(aFp, &(iStreamFmt.iVidBitMapInfo.BmiColors[ii].Blue), length)) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| if (length != PVAviFileParserUtils::read8(aFp, &(iStreamFmt.iVidBitMapInfo.BmiColors[ii].Green), length)) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| if (length != PVAviFileParserUtils::read8(aFp, &(iStreamFmt.iVidBitMapInfo.BmiColors[ii].Red), length)) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| if (length != PVAviFileParserUtils::read8(aFp, &(iStreamFmt.iVidBitMapInfo.BmiColors[ii].Reserved), length)) |
| { |
| return PV_AVI_FILE_PARSER_READ_ERROR; |
| } |
| |
| } |
| bytesRead += colorTblSize * sizeof(RGBQuad); |
| |
| |
| } |
| |
| if (bytesRead != aHdrSize) |
| { |
| return PV_AVI_FILE_PARSER_BYTE_COUNT_ERROR; |
| } |
| |
| return PV_AVI_FILE_PARSER_SUCCESS; |
| } |
| |
| OSCL_HeapString<OsclMemAllocator> PVAviFileStreamlist::GetStreamMimeType() |
| { |
| OSCL_HeapString<OsclMemAllocator> mime_str; |
| |
| if (AUDS == iStreamHdr.iStreamTypeFCC) |
| { |
| mime_str = "audio"; |
| } |
| else if (VIDS == iStreamHdr.iStreamTypeFCC) |
| { |
| mime_str = "video"; |
| } |
| else if (MIDS == iStreamHdr.iStreamTypeFCC) |
| { |
| mime_str = "midi"; |
| } |
| else if (TXTS == iStreamHdr.iStreamTypeFCC) |
| { |
| mime_str = "text"; |
| } |
| else |
| { |
| return 0; |
| } |
| |
| return mime_str; |
| } |
| |
| bool PVAviFileStreamlist::GetHandlerType(uint8* aHdlr, uint32& aSize) |
| { |
| if (aSize < CHUNK_SIZE) |
| { |
| return false; |
| } |
| |
| oscl_memcpy(aHdlr, iStreamHdr.iStreamHandler, CHUNK_SIZE); |
| aSize = CHUNK_SIZE; |
| return true; |
| } |
| |
| uint32 PVAviFileStreamlist::GetBitsPerSample() |
| { |
| if (AUDIO == iStreamFmt.iType) |
| { |
| return (iStreamFmt.iAudWaveFormatEx).BitsPerSample; |
| } |
| else if (VIDEO == iStreamFmt.iType) |
| |
| { |
| return (iStreamFmt.iVidBitMapInfo).BmiHeader.BiBitCount; |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| uint32 PVAviFileStreamlist::GetAudioFormat() |
| { |
| if (AUDIO == iStreamFmt.iType) |
| { |
| return (iStreamFmt.iAudWaveFormatEx).FormatTag; |
| } |
| else |
| { |
| return WAVE_FORMAT_UNKNOWN; |
| } |
| } |
| |
| uint32 PVAviFileStreamlist::GetNumAudioChannels() |
| { |
| if (AUDIO == iStreamFmt.iType) |
| { |
| return (iStreamFmt.iAudWaveFormatEx).Channels; |
| } |
| else |
| { |
| return 0; |
| } |
| |
| } |
| |
| uint32 PVAviFileStreamlist::GetVideoWidth() |
| { |
| if (VIDEO == iStreamFmt.iType) |
| { |
| return (iStreamFmt.iVidBitMapInfo).BmiHeader.BiWidth; |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| uint32 PVAviFileStreamlist::GetVideoHeight(bool& rBottomUp) |
| { |
| if (VIDEO == iStreamFmt.iType) |
| { |
| int32 height = (iStreamFmt.iVidBitMapInfo).BmiHeader.BiHeight; |
| if (height < 0) //negative height |
| { |
| rBottomUp = false; |
| height = oscl_abs(height); |
| } |
| else |
| { |
| rBottomUp = true; |
| } |
| |
| return ((uint32)height); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| bool PVAviFileStreamlist::GetFormatSpecificInfo(uint8*& aBuff, uint32& aSize) |
| { |
| if (AUDIO == iStreamFmt.iType) |
| { |
| aSize = sizeof(WaveFormatExStruct); |
| aBuff = OSCL_STATIC_CAST(uint8*, &(iStreamFmt.iAudWaveFormatEx)); |
| } |
| else if (VIDEO == iStreamFmt.iType) |
| { |
| aSize = sizeof(BitmapInfoHhr) + (sizeof(RGBQuad) * iStreamFmt.iVidBitMapInfo.BmiColorsCount); |
| aBuff = OSCL_STATIC_CAST(uint8*, &(iStreamFmt.iVidBitMapInfo)); |
| } |
| else |
| { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool PVAviFileStreamlist::GetCodecSpecificData(uint8*& aBuff, uint32& aSize) |
| { |
| if (iCodecSpecificHdrDataSize > 0) |
| { |
| aBuff = ipCodecSpecificHdrData; |
| aSize = iCodecSpecificHdrDataSize; |
| } |
| else |
| { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| |
