ref: 3fc6ad0d7c312a7aea77ad7f0d52dae330a30488
parent: b8dedfd0147dbd2c548a4ecd7da9e3bd2c009190
author: menno <menno>
date: Sat Oct 5 11:21:31 EDT 2002
Now using mpeg4ip mp4av library
--- /dev/null
+++ b/common/mp4av/aac.cpp
@@ -1,0 +1,133 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+/*
+ * Notes:
+ * - file formatted with tabstops == 4 spaces
+ */
+
+#include <mp4av_common.h>
+
+/*
+ * AAC Config in ES:
+ *
+ * AudioObjectType 5 bits
+ * samplingFrequencyIndex 4 bits
+ * if (samplingFrequencyIndex == 0xF)
+ * samplingFrequency 24 bits
+ * channelConfiguration 4 bits
+ * GA_SpecificConfig
+ * FrameLengthFlag 1 bit 1024 or 960
+ * DependsOnCoreCoder 1 bit (always 0)
+ * ExtensionFlag 1 bit (always 0)
+ */
+
+extern "C" u_int8_t MP4AV_AacConfigGetSamplingRateIndex(u_int8_t* pConfig)
+{+ return ((pConfig[0] << 1) | (pConfig[1] >> 7)) & 0xF;
+}
+
+extern "C" u_int32_t MP4AV_AacConfigGetSamplingRate(u_int8_t* pConfig)
+{+ u_int8_t index =
+ MP4AV_AacConfigGetSamplingRateIndex(pConfig);
+
+ if (index == 0xF) {+ return (pConfig[1] & 0x7F) << 17
+ | pConfig[2] << 9
+ | pConfig[3] << 1
+ | (pConfig[4] >> 7);
+ }
+ return AdtsSamplingRates[index];
+}
+
+extern "C" u_int16_t MP4AV_AacConfigGetSamplingWindow(u_int8_t* pConfig)
+{+ u_int8_t adjust = 0;
+
+ if (MP4AV_AacConfigGetSamplingRateIndex(pConfig) == 0xF) {+ adjust = 3;
+ }
+
+ if ((pConfig[1 + adjust] >> 2) & 0x1) {+ return 960;
+ }
+ return 1024;
+}
+
+extern "C" u_int8_t MP4AV_AacConfigGetChannels(u_int8_t* pConfig)
+{+ u_int8_t adjust = 0;
+
+ if (MP4AV_AacConfigGetSamplingRateIndex(pConfig) == 0xF) {+ adjust = 3;
+ }
+ return (pConfig[1 + adjust] >> 3) & 0xF;
+}
+
+extern "C" bool MP4AV_AacGetConfigurationFromAdts(
+ u_int8_t** ppConfig,
+ u_int32_t* pConfigLength,
+ u_int8_t* pHdr)
+{+ return MP4AV_AacGetConfiguration(
+ ppConfig,
+ pConfigLength,
+ MP4AV_AdtsGetProfile(pHdr),
+ MP4AV_AdtsGetSamplingRate(pHdr),
+ MP4AV_AdtsGetChannels(pHdr));
+}
+
+extern "C" bool MP4AV_AacGetConfiguration(
+ u_int8_t** ppConfig,
+ u_int32_t* pConfigLength,
+ u_int8_t profile,
+ u_int32_t samplingRate,
+ u_int8_t channels)
+{+ /* create the appropriate decoder config */
+
+ u_int8_t* pConfig = (u_int8_t*)malloc(2);
+
+ if (pConfig == NULL) {+ return false;
+ }
+
+ u_int8_t samplingRateIndex =
+ MP4AV_AdtsFindSamplingRateIndex(samplingRate);
+
+ pConfig[0] =
+ ((profile + 1) << 3) | ((samplingRateIndex & 0xe) >> 1);
+ pConfig[1] =
+ ((samplingRateIndex & 0x1) << 7) | (channels << 3);
+
+ /* LATER this option is not currently used in MPEG4IP
+ if (samplesPerFrame == 960) {+ pConfig[1] |= (1 << 2);
+ }
+ */
+
+ *ppConfig = pConfig;
+ *pConfigLength = 2;
+
+ return true;
+}
+
--- /dev/null
+++ b/common/mp4av/adts.cpp
@@ -1,0 +1,273 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+/*
+ * Notes:
+ * - file formatted with tabstops == 4 spaces
+ */
+
+#include <mp4av_common.h>
+
+/*
+ * ADTS Header:
+ * MPEG-2 version 56 bits (byte aligned)
+ * MPEG-4 version 58 bits (not byte aligned)
+ *
+ * syncword 12 bits
+ * id 1 bit
+ * layer 2 bits
+ * protection_absent 1 bit
+ * profile 2 bits
+ * sampling_frequency_index 4 bits
+ * private 1 bit
+ * channel_configuraton 3 bits
+ * original 1 bit
+ * home 1 bit
+ * emphasis 2 bits
+ * copyright_id 1 bit
+ * copyright_id_start 1 bit
+ * aac_frame_length 13 bits
+ * adts_buffer_fullness 11 bits
+ * num_raw_data_blocks 2 bits
+ *
+ * if (protection_absent == 0)
+ * crc_check 16 bits
+ */
+
+u_int32_t AdtsSamplingRates[NUM_ADTS_SAMPLING_RATES] = {+ 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
+ 16000, 12000, 11025, 8000, 7350, 0, 0, 0
+};
+
+/*
+ * compute ADTS frame size
+ */
+extern "C" u_int16_t MP4AV_AdtsGetFrameSize(u_int8_t* pHdr)
+{+ /* extract the necessary fields from the header */
+ u_int8_t isMpeg4 = !(pHdr[1] & 0x08);
+ u_int16_t frameLength;
+
+ if (isMpeg4) {+ frameLength = (((u_int16_t)pHdr[4]) << 5) | (pHdr[5] >> 3);
+ } else { /* MPEG-2 */+ frameLength = (((u_int16_t)(pHdr[3] & 0x3)) << 11)
+ | (((u_int16_t)pHdr[4]) << 3) | (pHdr[5] >> 5);
+ }
+ return frameLength;
+}
+
+/*
+ * Compute length of ADTS header in bits
+ */
+extern "C" u_int16_t MP4AV_AdtsGetHeaderBitSize(u_int8_t* pHdr)
+{+ u_int8_t isMpeg4 = !(pHdr[1] & 0x08);
+ u_int8_t hasCrc = !(pHdr[1] & 0x01);
+ u_int16_t hdrSize;
+
+ if (isMpeg4) {+ hdrSize = 58;
+ } else {+ hdrSize = 56;
+ }
+ if (hasCrc) {+ hdrSize += 16;
+ }
+ return hdrSize;
+}
+
+extern "C" u_int16_t MP4AV_AdtsGetHeaderByteSize(u_int8_t* pHdr)
+{+ return (MP4AV_AdtsGetHeaderBitSize(pHdr) + 7) / 8;
+}
+
+extern "C" u_int8_t MP4AV_AdtsGetVersion(u_int8_t* pHdr)
+{+ return (pHdr[1] & 0x08) >> 3;
+}
+
+extern "C" u_int8_t MP4AV_AdtsGetProfile(u_int8_t* pHdr)
+{+ return (pHdr[2] & 0xc0) >> 6;
+}
+
+extern "C" u_int8_t MP4AV_AdtsGetSamplingRateIndex(u_int8_t* pHdr)
+{+ return (pHdr[2] & 0x3c) >> 2;
+}
+
+extern "C" u_int8_t MP4AV_AdtsFindSamplingRateIndex(u_int32_t samplingRate)
+{+ for (u_int8_t i = 0; i < NUM_ADTS_SAMPLING_RATES; i++) {+ if (samplingRate == AdtsSamplingRates[i]) {+ return i;
+ }
+ }
+ return NUM_ADTS_SAMPLING_RATES - 1;
+}
+
+extern "C" u_int32_t MP4AV_AdtsGetSamplingRate(u_int8_t* pHdr)
+{+ return AdtsSamplingRates[MP4AV_AdtsGetSamplingRateIndex(pHdr)];
+}
+
+extern "C" u_int8_t MP4AV_AdtsGetChannels(u_int8_t* pHdr)
+{+ return ((pHdr[2] & 0x1) << 2) | ((pHdr[3] & 0xc0) >> 6);
+}
+
+extern "C" bool MP4AV_AdtsMakeFrameFromMp4Sample(
+ MP4FileHandle mp4File,
+ MP4TrackId trackId,
+ MP4SampleId sampleId,
+ u_int8_t** ppAdtsData,
+ u_int32_t* pAdtsDataLength)
+{+ static MP4FileHandle lastMp4File = MP4_INVALID_FILE_HANDLE;
+ static MP4TrackId lastMp4TrackId = MP4_INVALID_TRACK_ID;
+ static bool isMpeg2;
+ static u_int8_t profile;
+ static u_int32_t samplingFrequency;
+ static u_int8_t channels;
+
+ if (mp4File != lastMp4File || trackId != lastMp4TrackId) {+
+ // changed cached file and track info
+
+ lastMp4File = mp4File;
+ lastMp4TrackId = trackId;
+
+ u_int8_t audioType = MP4GetTrackAudioType(mp4File, trackId);
+
+ if (MP4_IS_MPEG2_AAC_AUDIO_TYPE(audioType)) {+ isMpeg2 = true;
+ profile = audioType - MP4_MPEG2_AAC_MAIN_AUDIO_TYPE;
+ } else if (audioType == MP4_MPEG4_AUDIO_TYPE) {+ isMpeg2 = false;
+ profile = MP4GetTrackAudioMpeg4Type(mp4File, trackId) - 1;
+ } else {+ lastMp4File = MP4_INVALID_FILE_HANDLE;
+ lastMp4TrackId = MP4_INVALID_TRACK_ID;
+ return false;
+ }
+
+ u_int8_t* pConfig = NULL;
+ u_int32_t configLength;
+
+ MP4GetTrackESConfiguration(
+ mp4File,
+ trackId,
+ &pConfig,
+ &configLength);
+
+ if (pConfig == NULL || configLength < 2) {+ lastMp4File = MP4_INVALID_FILE_HANDLE;
+ lastMp4TrackId = MP4_INVALID_TRACK_ID;
+ return false;
+ }
+
+ samplingFrequency = MP4AV_AacConfigGetSamplingRate(pConfig);
+
+ channels = MP4AV_AacConfigGetChannels(pConfig);
+
+ }
+
+ bool rc;
+ u_int8_t* pSample = NULL;
+ u_int32_t sampleSize = 0;
+
+ rc = MP4ReadSample(
+ mp4File,
+ trackId,
+ sampleId,
+ &pSample,
+ &sampleSize);
+
+ if (!rc) {+ return false;
+ }
+
+ rc = MP4AV_AdtsMakeFrame(
+ pSample,
+ sampleSize,
+ isMpeg2,
+ profile,
+ samplingFrequency,
+ channels,
+ ppAdtsData,
+ pAdtsDataLength);
+
+ free(pSample);
+
+ return rc;
+}
+
+extern "C" bool MP4AV_AdtsMakeFrame(
+ u_int8_t* pData,
+ u_int16_t dataLength,
+ bool isMpeg2,
+ u_int8_t profile,
+ u_int32_t samplingFrequency,
+ u_int8_t channels,
+ u_int8_t** ppAdtsData,
+ u_int32_t* pAdtsDataLength)
+{+ *pAdtsDataLength = (isMpeg2 ? 7 : 8) + dataLength;
+
+ CMemoryBitstream adts;
+
+ try {+ adts.AllocBytes(*pAdtsDataLength);
+ *ppAdtsData = adts.GetBuffer();
+
+ // build adts header
+ adts.PutBits(0xFFF, 12); // syncword
+ adts.PutBits(isMpeg2, 1); // id
+ adts.PutBits(0, 2); // layer
+ adts.PutBits(1, 1); // protection_absent
+ adts.PutBits(profile, 2); // profile
+ adts.PutBits(
+ MP4AV_AdtsFindSamplingRateIndex(samplingFrequency),
+ 4); // sampling_frequency_index
+ adts.PutBits(0, 1); // private
+ adts.PutBits(channels, 3); // channel_configuration
+ adts.PutBits(0, 1); // original
+ adts.PutBits(0, 1); // home
+ if (!isMpeg2) {+ adts.PutBits(0, 2); // emphasis
+ }
+ adts.PutBits(0, 1); // copyright_id
+ adts.PutBits(0, 1); // copyright_id_start
+ adts.PutBits(*pAdtsDataLength, 13); // aac_frame_length
+ adts.PutBits(0x7FF, 11); // adts_buffer_fullness
+ adts.PutBits(0, 2); // num_raw_data_blocks
+
+ // copy audio frame data
+ adts.PutBytes(pData, dataLength);
+ }
+ catch (int e) {+ return false;
+ }
+
+ return true;
+}
+
--- /dev/null
+++ b/common/mp4av/audio.cpp
@@ -1,0 +1,212 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+/*
+ * Notes:
+ * - file formatted with tabstops == 4 spaces
+ */
+
+#include <mp4av_common.h>
+
+static MP4AV_Mp3Header GetMp3Header(
+ MP4FileHandle mp4File,
+ MP4TrackId audioTrackId)
+{+ u_int8_t* pMp3Frame = NULL;
+ u_int32_t mp3FrameLength = 0;
+
+ bool rc = MP4ReadSample(
+ mp4File,
+ audioTrackId,
+ 1,
+ &pMp3Frame,
+ &mp3FrameLength);
+
+ if (!rc || mp3FrameLength < 4) {+ return 0;
+ }
+
+ MP4AV_Mp3Header mp3Hdr =
+ MP4AV_Mp3HeaderFromBytes(pMp3Frame);
+ free(pMp3Frame);
+
+ return mp3Hdr;
+}
+
+extern "C" u_int8_t MP4AV_AudioGetChannels(
+ MP4FileHandle mp4File,
+ MP4TrackId audioTrackId)
+{+ u_int8_t audioType =
+ MP4GetTrackAudioType(mp4File, audioTrackId);
+
+ if (audioType == MP4_INVALID_AUDIO_TYPE) {+ return 0;
+ }
+
+ if (MP4_IS_MP3_AUDIO_TYPE(audioType)) {+ MP4AV_Mp3Header mp3Hdr =
+ GetMp3Header(mp4File, audioTrackId);
+
+ if (mp3Hdr == 0) {+ return 0;
+ }
+ return MP4AV_Mp3GetChannels(mp3Hdr);
+
+ } else if (MP4_IS_AAC_AUDIO_TYPE(audioType)) {+ u_int8_t* pAacConfig = NULL;
+ u_int32_t aacConfigLength;
+
+ MP4GetTrackESConfiguration(
+ mp4File,
+ audioTrackId,
+ &pAacConfig,
+ &aacConfigLength);
+
+ if (pAacConfig == NULL || aacConfigLength < 2) {+ return 0;
+ }
+
+ u_int8_t channels =
+ MP4AV_AacConfigGetChannels(pAacConfig);
+
+ free(pAacConfig);
+
+ return channels;
+
+ } else if ((audioType == MP4_PCM16_LITTLE_ENDIAN_AUDIO_TYPE) ||
+ (audioType == MP4_PCM16_BIG_ENDIAN_AUDIO_TYPE)) {+ u_int32_t samplesPerFrame =
+ MP4GetSampleSize(mp4File, audioTrackId, 1) / 2;
+
+ MP4Duration frameDuration =
+ MP4GetSampleDuration(mp4File, audioTrackId, 1);
+
+ if (frameDuration == 0) {+ return 0;
+ }
+
+ // assumes track time scale == sampling rate
+ return samplesPerFrame / frameDuration;
+ }
+
+ return 0;
+}
+
+extern "C" u_int32_t MP4AV_AudioGetSamplingRate(
+ MP4FileHandle mp4File,
+ MP4TrackId audioTrackId)
+{+ u_int8_t audioType =
+ MP4GetTrackAudioType(mp4File, audioTrackId);
+
+ if (audioType == MP4_INVALID_AUDIO_TYPE) {+ return 0;
+ }
+
+ if (MP4_IS_MP3_AUDIO_TYPE(audioType)) {+ MP4AV_Mp3Header mp3Hdr =
+ GetMp3Header(mp4File, audioTrackId);
+
+ if (mp3Hdr == 0) {+ return 0;
+ }
+ return MP4AV_Mp3GetHdrSamplingRate(mp3Hdr);
+
+ } else if (MP4_IS_AAC_AUDIO_TYPE(audioType)) {+ u_int8_t* pAacConfig = NULL;
+ u_int32_t aacConfigLength;
+
+ MP4GetTrackESConfiguration(
+ mp4File,
+ audioTrackId,
+ &pAacConfig,
+ &aacConfigLength);
+
+ if (pAacConfig == NULL || aacConfigLength < 2) {+ return 0;
+ }
+
+ u_int32_t samplingRate =
+ MP4AV_AacConfigGetSamplingRate(pAacConfig);
+
+ free(pAacConfig);
+
+ return samplingRate;
+
+ } else if ((audioType == MP4_PCM16_LITTLE_ENDIAN_AUDIO_TYPE)||
+ (audioType == MP4_PCM16_BIG_ENDIAN_AUDIO_TYPE)) {+ return MP4GetTrackTimeScale(mp4File, audioTrackId);
+ }
+
+ return 0;
+}
+
+extern "C" u_int16_t MP4AV_AudioGetSamplingWindow(
+ MP4FileHandle mp4File,
+ MP4TrackId audioTrackId)
+{+ u_int8_t audioType =
+ MP4GetTrackAudioType(mp4File, audioTrackId);
+
+ if (audioType == MP4_INVALID_AUDIO_TYPE) {+ return 0;
+ }
+
+ if (MP4_IS_MP3_AUDIO_TYPE(audioType)) {+ MP4AV_Mp3Header mp3Hdr =
+ GetMp3Header(mp4File, audioTrackId);
+
+ return MP4AV_Mp3GetHdrSamplingWindow(mp3Hdr);
+
+ } else if (MP4_IS_AAC_AUDIO_TYPE(audioType)) {+ u_int8_t* pAacConfig = NULL;
+ u_int32_t aacConfigLength;
+
+ MP4GetTrackESConfiguration(
+ mp4File,
+ audioTrackId,
+ &pAacConfig,
+ &aacConfigLength);
+
+ if (pAacConfig == NULL || aacConfigLength < 2) {+ return 0;
+ }
+
+ u_int32_t samplingWindow =
+ MP4AV_AacConfigGetSamplingWindow(pAacConfig);
+
+ free(pAacConfig);
+
+ return samplingWindow;
+
+ } else if ((audioType == MP4_PCM16_LITTLE_ENDIAN_AUDIO_TYPE)||
+ (audioType == MP4_PCM16_BIG_ENDIAN_AUDIO_TYPE)) {+ MP4Duration frameDuration =
+ MP4GetSampleDuration(mp4File, audioTrackId, 1);
+
+ // assumes track time scale == sampling rate
+ // and constant frame size was used
+ return frameDuration;
+ }
+
+ return 0;
+}
--- /dev/null
+++ b/common/mp4av/audio_hinters.cpp
@@ -1,0 +1,201 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+/*
+ * Notes:
+ * - file formatted with tabstops == 4 spaces
+ */
+
+#include <mp4av_common.h>
+
+bool MP4AV_AudioConsecutiveHinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ MP4Duration sampleDuration,
+ u_int8_t perPacketHeaderSize,
+ u_int8_t perSampleHeaderSize,
+ u_int8_t maxSamplesPerPacket,
+ u_int16_t maxPayloadSize,
+ MP4AV_AudioSampleSizer pSizer,
+ MP4AV_AudioConcatenator pConcatenator,
+ MP4AV_AudioFragmenter pFragmenter)
+{+ bool rc;
+ u_int32_t numSamples =
+ MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
+
+ u_int16_t bytesThisHint = perPacketHeaderSize;
+ u_int16_t samplesThisHint = 0;
+ MP4SampleId* pSampleIds =
+ new MP4SampleId[maxSamplesPerPacket];
+
+ for (MP4SampleId sampleId = 1; sampleId <= numSamples; sampleId++) {+
+ u_int32_t sampleSize =
+ (*pSizer)(mp4File, mediaTrackId, sampleId);
+
+ // sample won't fit in this packet
+ // or we've reached the limit on samples per packet
+ if ((int16_t)(sampleSize + perSampleHeaderSize)
+ > maxPayloadSize - bytesThisHint
+ || samplesThisHint == maxSamplesPerPacket) {+
+ if (samplesThisHint > 0) {+ rc = (*pConcatenator)(mp4File, mediaTrackId, hintTrackId,
+ samplesThisHint, pSampleIds,
+ samplesThisHint * sampleDuration,
+ maxPayloadSize);
+
+ if (!rc) {+ return false;
+ }
+ }
+
+ // start a new hint
+ samplesThisHint = 0;
+ bytesThisHint = perPacketHeaderSize;
+
+ // fall thru
+ }
+
+ // sample is less than remaining payload size
+ if ((int16_t)(sampleSize + perSampleHeaderSize)
+ <= maxPayloadSize - bytesThisHint) {+
+ // add it to this hint
+ bytesThisHint += (sampleSize + perSampleHeaderSize);
+ pSampleIds[samplesThisHint++] = sampleId;
+
+ } else { + // jumbo frame, need to fragment it
+ rc = (*pFragmenter)(mp4File, mediaTrackId, hintTrackId,
+ sampleId, sampleSize, sampleDuration, maxPayloadSize);
+
+ if (!rc) {+ return false;
+ }
+
+ // start a new hint
+ samplesThisHint = 0;
+ bytesThisHint = perPacketHeaderSize;
+ }
+ }
+
+ delete [] pSampleIds;
+
+ return true;
+}
+
+bool MP4AV_AudioInterleaveHinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ MP4Duration sampleDuration,
+ u_int8_t stride,
+ u_int8_t bundle,
+ u_int16_t maxPayloadSize,
+ MP4AV_AudioConcatenator pConcatenator)
+{+ bool rc;
+ u_int32_t numSamples =
+ MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
+
+ MP4SampleId* pSampleIds = new MP4SampleId[bundle];
+
+ for (u_int32_t i = 1; i <= numSamples; i += stride * bundle) {+ for (u_int32_t j = 0; j < stride; j++) {+ u_int32_t k;
+ for (k = 0; k < bundle; k++) {+
+ MP4SampleId sampleId = i + j + (k * stride);
+
+ // out of samples for this bundle
+ if (sampleId > numSamples) {+ break;
+ }
+
+ // add sample to this hint
+ pSampleIds[k] = sampleId;
+ }
+
+ if (k == 0) {+ break;
+ }
+
+ // compute hint duration
+ // note this is used to control the RTP timestamps
+ // that are emitted for the packet,
+ // it isn't the actual duration of the samples in the packet
+ MP4Duration hintDuration;
+ if (j + 1 == stride) {+ // at the end of the track
+ if (i + (stride * bundle) > numSamples) {+ hintDuration = ((numSamples - i) - j) * sampleDuration;
+ } else {+ hintDuration = ((stride * bundle) - j) * sampleDuration;
+ }
+ } else {+ hintDuration = sampleDuration;
+ }
+
+ // write hint
+ rc = (*pConcatenator)(mp4File, mediaTrackId, hintTrackId,
+ k, pSampleIds, hintDuration, maxPayloadSize);
+
+ if (!rc) {+ return false;
+ }
+ }
+ }
+
+ delete [] pSampleIds;
+
+ return true;
+}
+
+MP4Duration MP4AV_GetAudioSampleDuration(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId)
+{+ MP4SampleId sampleId = 1;
+ MP4SampleId numSamples =
+ MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
+
+ // find first non-zero size sample
+ // we need to search in case an empty audio sample has been added
+ // at the beginning of the track to achieve sync with video
+ for (; sampleId <= numSamples; sampleId++) {+ if (MP4GetSampleSize(mp4File, mediaTrackId, sampleId) > 0) {+ break;
+ }
+ }
+ if (sampleId >= numSamples) {+ return MP4_INVALID_DURATION;
+ }
+
+ // get sample duration
+ return MP4GetSampleDuration(mp4File, mediaTrackId, sampleId);
+
+ // OPTION may want to scan all non-zero sized samples
+ // and check that sample durations are +/-1 the same value
+}
+
--- /dev/null
+++ b/common/mp4av/audio_hinters.h
@@ -1,0 +1,78 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#ifndef __AUDIO_HINTERS_INCLUDED__
+#define __AUDIO_HINTERS_INCLUDED__
+
+// Generic Audio Hinters
+
+typedef u_int32_t (*MP4AV_AudioSampleSizer)(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4SampleId sampleId);
+
+typedef bool (*MP4AV_AudioConcatenator)(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ u_int8_t samplesThisHint,
+ MP4SampleId* pSampleIds,
+ MP4Duration hintDuration,
+ u_int16_t maxPayloadSize);
+
+typedef bool (*MP4AV_AudioFragmenter)(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ MP4SampleId sampleId,
+ u_int32_t sampleSize,
+ MP4Duration sampleDuration,
+ u_int16_t maxPayloadSize);
+
+bool MP4AV_AudioConsecutiveHinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ MP4Duration sampleDuration,
+ u_int8_t perPacketHeaderSize,
+ u_int8_t perSampleHeaderSize,
+ u_int8_t maxSamplesPerPacket,
+ u_int16_t maxPayloadSize,
+ MP4AV_AudioSampleSizer pSizer,
+ MP4AV_AudioConcatenator pConcatenator,
+ MP4AV_AudioFragmenter pFragmenter);
+
+bool MP4AV_AudioInterleaveHinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ MP4Duration sampleDuration,
+ u_int8_t stride,
+ u_int8_t bundle,
+ u_int16_t maxPayloadSize,
+ MP4AV_AudioConcatenator pConcatenator);
+
+MP4Duration MP4AV_GetAudioSampleDuration(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId);
+
+#endif /* __AUDIO_HINTERS_INCLUDED__ */
+
--- /dev/null
+++ b/common/mp4av/l16.cpp
@@ -1,0 +1,167 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Bill May [email protected]
+ */
+
+#include <mp4av_common.h>
+
+//#define DEBUG_L16 1
+extern "C" bool L16Hinter (MP4FileHandle mp4file,
+ MP4TrackId trackid,
+ uint16_t maxPayloadSize)
+{+ uint32_t numSamples;
+ uint8_t audioType;
+ MP4SampleId sampleId;
+ uint32_t sampleSize;
+ MP4Duration duration;
+ char buffer[40];
+ MP4TrackId hintTrackId;
+ uint8_t payload;
+ int chans;
+ uint32_t bytes_this_hint;
+ uint32_t sampleOffset;
+
+#ifdef DEBUG_L16
+ printf("time scale %u\n", MP4GetTrackTimeScale(mp4file, trackid));+
+ printf("Track fixed sample %llu\n", MP4GetTrackFixedSampleDuration(mp4file, trackid));+#endif
+
+ numSamples = MP4GetTrackNumberOfSamples(mp4file, trackid);
+
+ if (numSamples == 0) return false;
+
+
+#ifdef DEBUG_L16
+ for (unsigned int ix = 1; ix < MIN(10, numSamples); ix++) {+ printf("sampleId %d, size %u duration %llu time %llu\n",+ ix, MP4GetSampleSize(mp4file, trackid, ix),
+ MP4GetSampleDuration(mp4file, trackid, ix),
+ MP4GetSampleTime(mp4file, trackid, ix));
+ }
+#endif
+
+ audioType = MP4GetTrackAudioType(mp4file, trackid);
+
+ if (audioType != MP4_PCM16_BIG_ENDIAN_AUDIO_TYPE) return false;
+
+ sampleId = 1;
+ while ((sampleSize = MP4GetSampleSize(mp4file, trackid, sampleId)) == 0) {+ if (sampleId >= numSamples) return false;
+ sampleId++;
+ }
+
+ // we have a sampleID with a size. Give me duration, and we know the
+ // number of channels based on the sample size for that duration
+ duration = MP4GetSampleDuration(mp4file, trackid, sampleId);
+
+ sampleSize /= sizeof(uint16_t);
+
+ if ((sampleSize % duration) != 0) {+#ifdef DEBUG_L16
+ printf("Number of samples not correct - duration %llu sample %d\n", + duration, sampleSize);
+#endif
+ return false;
+ }
+
+ chans = sampleSize / duration;
+ snprintf(buffer, sizeof(buffer), "%d", chans);
+
+ hintTrackId = MP4AddHintTrack(mp4file, trackid);
+
+ if (hintTrackId == MP4_INVALID_TRACK_ID) {+ return false;
+ }
+
+ payload = 0;
+ if (MP4GetTrackTimeScale(mp4file, trackid) == 44100) {+ if (chans == 1) payload = 11;
+ else if (chans == 2) payload = 10;
+ }
+ MP4SetHintTrackRtpPayload(mp4file, hintTrackId, "L16", &payload, 0,
+ chans == 1 ? NULL : buffer);
+
+ sampleId = 1;
+ sampleSize = MP4GetSampleSize(mp4file, trackid, sampleId);
+ sampleOffset = 0;
+ bytes_this_hint = 0;
+
+ if (maxPayloadSize & 0x1) maxPayloadSize--;
+
+ while (1) {+ if (bytes_this_hint == 0) {+#ifdef DEBUG_L16
+ printf("Adding hint/packet\n");+#endif
+ MP4AddRtpHint(mp4file, hintTrackId);
+ MP4AddRtpPacket(mp4file, hintTrackId, false); // marker bit 0
+ }
+ uint16_t bytes_left_this_packet;
+ bytes_left_this_packet = maxPayloadSize - bytes_this_hint;
+ if (sampleSize >= bytes_left_this_packet) {+ MP4AddRtpSampleData(mp4file, hintTrackId,
+ sampleId, sampleOffset, bytes_left_this_packet);
+ bytes_this_hint += bytes_left_this_packet;
+ sampleSize -= bytes_left_this_packet;
+ sampleOffset += bytes_left_this_packet;
+#ifdef DEBUG_L16
+ printf("Added sample with %d bytes\n", bytes_left_this_packet);+#endif
+ } else {+ MP4AddRtpSampleData(mp4file, hintTrackId,
+ sampleId, sampleOffset, sampleSize);
+ bytes_this_hint += sampleSize;
+#ifdef DEBUG_L16
+ printf("Added sample with %d bytes\n", sampleSize);+#endif
+ sampleSize = 0;
+ }
+
+ if (bytes_this_hint >= maxPayloadSize) {+ // Write the hint
+ // duration is 1/2 of the bytes written
+ MP4WriteRtpHint(mp4file, hintTrackId, bytes_this_hint / (2 * chans));
+#ifdef DEBUG_L16
+ printf("Finished packet - bytes %d\n", bytes_this_hint);+#endif
+ bytes_this_hint = 0;
+ }
+ if (sampleSize == 0) {+ // next sample
+ sampleId++;
+ if (sampleId > numSamples) {+ // finish it and exit
+ if (bytes_this_hint != 0) {+ MP4WriteRtpHint(mp4file, hintTrackId, bytes_this_hint / 2);
+ return true;
+ }
+ }
+ sampleSize = MP4GetSampleSize(mp4file, trackid, sampleId);
+#ifdef DEBUG_L16
+ printf("Next sample %d - size %d\n", sampleId, sampleSize);+#endif
+ sampleOffset = 0;
+ }
+ }
+
+ return true; // will never reach here
+}
+
--- /dev/null
+++ b/common/mp4av/libmp4av.dsp
@@ -1,0 +1,184 @@
+# Microsoft Developer Studio Project File - Name="libmp4av" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=libmp4av - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "libmp4av.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "libmp4av.mak" CFG="libmp4av - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "libmp4av - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "libmp4av - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "libmp4av - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "libmp4av___Win32_Release"
+# PROP BASE Intermediate_Dir "libmp4av___Win32_Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "MRelease"
+# PROP Intermediate_Dir "MRelease"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /I "..\mp4v2" /I "..\..\include" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF "$(CFG)" == "libmp4av - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "MDebug"
+# PROP Intermediate_Dir "MDebug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "." /I "..\mp4v2" /I "..\..\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "_WIN32" /D "_WINDOWS" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF
+
+# Begin Target
+
+# Name "libmp4av - Win32 Release"
+# Name "libmp4av - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\aac.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\adts.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\audio.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\audio_hinters.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mbs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp3.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mpeg3.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mpeg4.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rfc2250.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rfc3016.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rfc3119.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rfcisma.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\audio_hinters.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mbs.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_aac.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_adts.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_audio.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_common.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_hinters.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_mp3.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_mpeg3.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_mpeg4.h
+# End Source File
+# End Group
+# End Target
+# End Project
--- /dev/null
+++ b/common/mp4av/libmp4av_st.dsp
@@ -1,0 +1,176 @@
+# Microsoft Developer Studio Project File - Name="libmp4av_st" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=libmp4av_st - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "libmp4av_st.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "libmp4av_st.mak" CFG="libmp4av_st - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "libmp4av_st - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "libmp4av_st - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "libmp4av_st - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\mp4v2" /I ".\\" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF "$(CFG)" == "libmp4av_st - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\mp4v2" /I ".\\" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF
+
+# Begin Target
+
+# Name "libmp4av_st - Win32 Release"
+# Name "libmp4av_st - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\aac.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\adts.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\audio_hinters.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\l16.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mbs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp3.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mpeg3.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mpeg4.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rfc2250.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rfc3016.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rfc3119.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rfcisma.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\audio_hinters.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mbs.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_aac.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_adts.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_common.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_hinters.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_mp3.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp4av_mpeg4.h
+# End Source File
+# End Group
+# End Target
+# End Project
--- /dev/null
+++ b/common/mp4av/libmp4av_st.vcproj
@@ -1,0 +1,180 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="7.00"
+ Name="libmp4av_st"
+ ProjectGUID="{8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}"+ SccProjectName=""
+ SccLocalPath="">
+ <Platforms>
+ <Platform
+ Name="Win32"/>
+ </Platforms>
+ <Configurations>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory=".\Release"
+ IntermediateDirectory=".\Release"
+ ConfigurationType="4"
+ UseOfMFC="0"
+ ATLMinimizesCRunTimeLibraryUsage="FALSE"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ InlineFunctionExpansion="1"
+ AdditionalIncludeDirectories="..\mp4v2,.\"
+ PreprocessorDefinitions="WIN32,NDEBUG,_LIB"
+ StringPooling="TRUE"
+ RuntimeLibrary="4"
+ EnableFunctionLevelLinking="TRUE"
+ UsePrecompiledHeader="2"
+ PrecompiledHeaderFile=".\Release/libmp4av_st.pch"
+ AssemblerListingLocation=".\Release/"
+ ObjectFile=".\Release/"
+ ProgramDataBaseFileName=".\Release/"
+ WarningLevel="3"
+ SuppressStartupBanner="TRUE"
+ CompileAs="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLibrarianTool"
+ OutputFile=".\Release\libmp4av_st.lib"
+ SuppressStartupBanner="TRUE"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"
+ PreprocessorDefinitions="NDEBUG"
+ Culture="1033"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ </Configuration>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory=".\Debug"
+ IntermediateDirectory=".\Debug"
+ ConfigurationType="4"
+ UseOfMFC="0"
+ ATLMinimizesCRunTimeLibraryUsage="FALSE"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="..\mp4v2,.\"
+ PreprocessorDefinitions="WIN32,_DEBUG,_LIB"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="5"
+ UsePrecompiledHeader="2"
+ PrecompiledHeaderFile=".\Debug/libmp4av_st.pch"
+ AssemblerListingLocation=".\Debug/"
+ ObjectFile=".\Debug/"
+ ProgramDataBaseFileName=".\Debug/"
+ WarningLevel="3"
+ SuppressStartupBanner="TRUE"
+ DebugInformationFormat="4"
+ CompileAs="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLibrarianTool"
+ OutputFile=".\Debug\libmp4av_st.lib"
+ SuppressStartupBanner="TRUE"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"
+ PreprocessorDefinitions="_DEBUG"
+ Culture="1033"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ </Configuration>
+ </Configurations>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
+ <File
+ RelativePath=".\aac.cpp">
+ </File>
+ <File
+ RelativePath=".\adts.cpp">
+ </File>
+ <File
+ RelativePath=".\audio_hinters.cpp">
+ </File>
+ <File
+ RelativePath=".\l16.cpp">
+ </File>
+ <File
+ RelativePath=".\mbs.cpp">
+ </File>
+ <File
+ RelativePath=".\mp3.cpp">
+ </File>
+ <File
+ RelativePath=".\mpeg3.cpp">
+ </File>
+ <File
+ RelativePath=".\mpeg4.cpp">
+ </File>
+ <File
+ RelativePath=".\rfc2250.cpp">
+ </File>
+ <File
+ RelativePath=".\rfc3016.cpp">
+ </File>
+ <File
+ RelativePath=".\rfc3119.cpp">
+ </File>
+ <File
+ RelativePath=".\rfcisma.cpp">
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl">
+ <File
+ RelativePath=".\audio_hinters.h">
+ </File>
+ <File
+ RelativePath=".\mbs.h">
+ </File>
+ <File
+ RelativePath=".\mp4av.h">
+ </File>
+ <File
+ RelativePath=".\mp4av_aac.h">
+ </File>
+ <File
+ RelativePath=".\mp4av_adts.h">
+ </File>
+ <File
+ RelativePath=".\mp4av_common.h">
+ </File>
+ <File
+ RelativePath=".\mp4av_hinters.h">
+ </File>
+ <File
+ RelativePath=".\mp4av_mp3.h">
+ </File>
+ <File
+ RelativePath=".\mp4av_mpeg4.h">
+ </File>
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>
--- /dev/null
+++ b/common/mp4av/mbs.cpp
@@ -1,0 +1,93 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#include "mp4av_common.h"
+
+void CMemoryBitstream::AllocBytes(u_int32_t numBytes)
+{+ m_pBuf = (u_int8_t*)calloc(numBytes, 1);
+ if (!m_pBuf) {+ throw ENOMEM;
+ }
+ m_bitPos = 0;
+ m_numBits = numBytes << 3;
+}
+
+void CMemoryBitstream::SetBytes(u_int8_t* pBytes, u_int32_t numBytes)
+{+ m_pBuf = pBytes;
+ m_bitPos = 0;
+ m_numBits = numBytes << 3;
+}
+
+void CMemoryBitstream::PutBytes(u_int8_t* pBytes, u_int32_t numBytes)
+{+ u_int32_t numBits = numBytes << 3;
+
+ if (numBits + m_bitPos > m_numBits) {+ throw EIO;
+ }
+
+ if ((m_bitPos & 7) == 0) {+ memcpy(&m_pBuf[m_bitPos >> 3], pBytes, numBytes);
+ m_bitPos += numBits;
+ } else {+ for (u_int32_t i = 0; i < numBytes; i++) {+ PutBits(pBytes[i], 8);
+ }
+ }
+}
+
+void CMemoryBitstream::PutBits(u_int32_t bits, u_int32_t numBits)
+{+ if (numBits + m_bitPos > m_numBits) {+ throw EIO;
+ }
+ if (numBits > 32) {+ throw EIO;
+ }
+
+ for (int8_t i = numBits - 1; i >= 0; i--) {+ m_pBuf[m_bitPos >> 3] |= ((bits >> i) & 1) << (7 - (m_bitPos & 7));
+ m_bitPos++;
+ }
+}
+
+u_int32_t CMemoryBitstream::GetBits(u_int32_t numBits)
+{+ if (numBits + m_bitPos > m_numBits) {+ throw EIO;
+ }
+ if (numBits > 32) {+ throw EIO;
+ }
+
+ u_int32_t bits = 0;
+
+ for (u_int8_t i = 0; i < numBits; i++) {+ bits <<= 1;
+ bits |= (m_pBuf[m_bitPos >> 3] >> (7 - (m_bitPos & 7))) & 1;
+ m_bitPos++;
+ }
+
+ return bits;
+}
+
--- /dev/null
+++ b/common/mp4av/mbs.h
@@ -1,0 +1,81 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#ifndef __MBS_INCLUDED__
+#define __MBS_INCLUDED__
+
+class CMemoryBitstream {+public:
+ CMemoryBitstream() {+ m_pBuf = NULL;
+ m_bitPos = 0;
+ m_numBits = 0;
+ }
+
+ void AllocBytes(u_int32_t numBytes);
+
+ void SetBytes(u_int8_t* pBytes, u_int32_t numBytes);
+
+ void PutBytes(u_int8_t* pBytes, u_int32_t numBytes);
+
+ void PutBits(u_int32_t bits, u_int32_t numBits);
+
+ u_int32_t GetBits(u_int32_t numBits);
+
+ void SkipBytes(u_int32_t numBytes) {+ SkipBits(numBytes << 3);
+ }
+
+ void SkipBits(u_int32_t numBits) {+ SetBitPosition(GetBitPosition() + numBits);
+ }
+
+ u_int32_t GetBitPosition() {+ return m_bitPos;
+ }
+
+ void SetBitPosition(u_int32_t bitPos) {+ if (bitPos > m_numBits) {+ throw;
+ }
+ m_bitPos = bitPos;
+ }
+
+ u_int8_t* GetBuffer() {+ return m_pBuf;
+ }
+
+ u_int32_t GetNumberOfBytes() {+ return (GetNumberOfBits() + 7) / 8;
+ }
+
+ u_int32_t GetNumberOfBits() {+ return m_numBits;
+ }
+
+protected:
+ u_int8_t* m_pBuf;
+ u_int32_t m_bitPos;
+ u_int32_t m_numBits;
+};
+
+#endif /* __MBS_INCLUDED__ */
+
--- /dev/null
+++ b/common/mp4av/mp3.cpp
@@ -1,0 +1,350 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+/*
+ * Notes:
+ * - file formatted with tabstops == 4 spaces
+ */
+
+#include <mp4av_common.h>
+
+static u_int16_t Mp3BitRates[5][14] = {+ /* MPEG-1, Layer III */
+ { 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 },+ /* MPEG-1, Layer II */
+ { 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 },+ /* MPEG-1, Layer I */
+ { 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },+ /* MPEG-2 or 2.5, Layer II or III */
+ { 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 },+ /* MPEG-2 or 2.5, Layer I */
+ { 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 }+};
+
+static u_int16_t Mp3SampleRates[4][3] = {+ { 11025, 12000, 8000 }, /* MPEG-2.5 */+ { 0, 0, 0 },+ { 22050, 24000, 16000 }, /* MPEG-2 */+ { 44100, 48000, 32000 } /* MPEG-1 */+};
+
+extern "C" bool MP4AV_Mp3GetNextFrame(
+ const u_int8_t* pSrc,
+ u_int32_t srcLength,
+ const u_int8_t** ppFrame,
+ u_int32_t* pFrameSize,
+ bool allowLayer4,
+ bool donthack)
+{+ u_int state = 0;
+ u_int dropped = 0;
+ u_char bytes[4];
+ u_int32_t srcPos = 0;
+
+ while (true) {+ /* read a byte */
+ if (srcPos >= srcLength) {+ return false;
+ }
+ u_char b = pSrc[srcPos++];
+
+ if (state == 3) {+ bytes[state] = b;
+ *ppFrame = pSrc + dropped;
+ u_int32_t header = (bytes[0] << 24) | (bytes[1] << 16)
+ | (bytes[2] << 8) | bytes[3];
+ *pFrameSize = MP4AV_Mp3GetFrameSize(header);
+ return true;
+ }
+ if (state == 2) {+ if ((b & 0xF0) == 0 || (b & 0xF0) == 0xF0 || (b & 0x0C) == 0x0C) {+ if (bytes[1] == 0xFF) {+ state = 1;
+ } else {+ state = 0;
+ }
+ } else {+ bytes[state] = b;
+ state = 3;
+ }
+ }
+ if (state == 1) {+ if ((b & 0xE0) == 0xE0 && (b & 0x18) != 0x08 &&
+ ((b & 0x06) != 0 || allowLayer4)) {+ bytes[state] = b;
+ state = 2;
+ } else {+ state = 0;
+ }
+ }
+ if (state == 0) {+ if (b == 0xFF) {+ bytes[state] = b;
+ state = 1;
+ } else {+ if (donthack == FALSE &&
+ (dropped == 0 &&
+ ((b & 0xE0) == 0xE0 &&
+ (b & 0x18) != 0x08 &&
+ ((b & 0x06) != 0 || allowLayer4)))) {+ /*
+ * HACK have seen files where previous frame
+ * was marked as padded, but the byte was never added
+ * which results in the next frame's leading 0XFF being
+ * eaten. We attempt to repair that situation here.
+ */
+ bytes[0] = 0xFF;
+ bytes[1] = b;
+ state = 2;
+ } else {+ /* else drop it */
+ dropped++;
+ }
+ }
+ }
+ }
+}
+
+extern "C" MP4AV_Mp3Header MP4AV_Mp3HeaderFromBytes(const u_int8_t* pBytes)
+{+ return (pBytes[0] << 24) | (pBytes[1] << 16)
+ | (pBytes[2] << 8) | pBytes[3];
+}
+
+// MP3 Header
+// syncword 11 bits
+// version 2 bits
+// layer 2 bits
+// protection 1 bit
+// bitrate_index 4 bits
+// sampling_rate 2 bits
+// padding 1 bit
+// private 1 bit
+// mode 2 bits
+// mode_ext 2 bits
+// copyright 1 bit
+// original 1 bit
+// emphasis 2 bits
+
+extern "C" u_int8_t MP4AV_Mp3GetHdrVersion(MP4AV_Mp3Header hdr)
+{+ /* extract the necessary field from the MP3 header */
+ return ((hdr >> 19) & 0x3);
+}
+
+extern "C" u_int8_t MP4AV_Mp3GetHdrLayer(MP4AV_Mp3Header hdr)
+{+ /* extract the necessary field from the MP3 header */
+ return ((hdr >> 17) & 0x3);
+}
+
+extern "C" u_int8_t MP4AV_Mp3GetChannels(MP4AV_Mp3Header hdr)
+{+ if (((hdr >> 6) & 0x3) == 3) {+ return 1;
+ }
+ return 2;
+}
+
+extern "C" u_int16_t MP4AV_Mp3GetHdrSamplingRate(MP4AV_Mp3Header hdr)
+{+ /* extract the necessary fields from the MP3 header */
+ u_int8_t version = MP4AV_Mp3GetHdrVersion(hdr);
+ u_int8_t sampleRateIndex = (hdr >> 10) & 0x3;
+
+ return Mp3SampleRates[version][sampleRateIndex];
+}
+
+extern "C" u_int16_t MP4AV_Mp3GetHdrSamplingWindow(MP4AV_Mp3Header hdr)
+{+ u_int8_t version = MP4AV_Mp3GetHdrVersion(hdr);
+ u_int8_t layer = MP4AV_Mp3GetHdrLayer(hdr);
+ u_int16_t samplingWindow;
+
+ if (layer == 1) {+ if (version == 3) {+ samplingWindow = 1152;
+ } else {+ samplingWindow = 576;
+ }
+ } else if (layer == 2) {+ samplingWindow = 1152;
+ } else {+ samplingWindow = 384;
+ }
+
+ return samplingWindow;
+}
+
+extern "C" u_int16_t MP4AV_Mp3GetSamplingWindow(u_int16_t samplingRate)
+{+ // assumes MP3 usage
+ if (samplingRate > 24000) {+ return 1152;
+ }
+ return 576;
+}
+
+extern "C" u_int16_t MP4AV_Mp3GetBitRate (MP4AV_Mp3Header hdr)
+{+ u_int8_t version = MP4AV_Mp3GetHdrVersion(hdr);
+ u_int8_t layer = MP4AV_Mp3GetHdrLayer(hdr);
+ u_int8_t bitRateIndex1;
+ u_int8_t bitRateIndex2 = (hdr >> 12) & 0xF;
+
+ if (version == 3) {+ /* MPEG-1 */
+ bitRateIndex1 = layer - 1;
+ } else {+ /* MPEG-2 or MPEG-2.5 */
+ if (layer == 3) {+ /* Layer I */
+ bitRateIndex1 = 4;
+ } else {+ bitRateIndex1 = 3;
+ }
+ }
+ return Mp3BitRates[bitRateIndex1][bitRateIndex2-1];
+}
+/*
+ * compute MP3 frame size
+ */
+extern "C" u_int16_t MP4AV_Mp3GetFrameSize(MP4AV_Mp3Header hdr)
+{+ /* extract the necessary fields from the MP3 header */
+ u_int8_t version = MP4AV_Mp3GetHdrVersion(hdr);
+ u_int8_t layer = MP4AV_Mp3GetHdrLayer(hdr);
+ u_int8_t bitRateIndex1;
+ u_int8_t bitRateIndex2 = (hdr >> 12) & 0xF;
+ u_int8_t sampleRateIndex = (hdr >> 10) & 0x3;
+ bool isPadded = (hdr >> 9) & 0x1;
+ u_int16_t frameSize = 0;
+
+ if (version == 3) {+ /* MPEG-1 */
+ bitRateIndex1 = layer - 1;
+ } else {+ /* MPEG-2 or MPEG-2.5 */
+ if (layer == 3) {+ /* Layer I */
+ bitRateIndex1 = 4;
+ } else {+ bitRateIndex1 = 3;
+ }
+ }
+
+ /* compute frame size */
+ frameSize = (144 * 1000 * Mp3BitRates[bitRateIndex1][bitRateIndex2-1])
+ / (Mp3SampleRates[version][sampleRateIndex] << !(version & 1));
+
+ if (isPadded) {+ if (layer == 3) {+ /* Layer I */
+ frameSize += 4; /* 4 byte pad is present */
+ } else {+ frameSize++; /* 1 byte pad is present */
+ }
+ }
+
+ return frameSize;
+}
+
+extern "C" u_int16_t
+MP4AV_Mp3GetAduOffset(const u_int8_t* pFrame, u_int32_t frameSize)
+{+ if (frameSize < 2) {+ return 0;
+ }
+
+ u_int8_t version = (pFrame[1] >> 3) & 0x3;
+ u_int8_t layer = (pFrame[1] >> 1) & 0x3;
+ bool isProtected = !(pFrame[1] & 0x1);
+ u_int8_t crcSize = isProtected ? 2 : 0;
+
+ // protect against garbage input
+ if (frameSize < (u_int32_t)(5 + crcSize + (version == 3 ? 1 : 0))) {+ return 0;
+ }
+ if (layer != 1) {+ return 0;
+ }
+
+ if (version == 3) {+ // MPEG-1
+ return (pFrame[4 + crcSize] << 1) | (pFrame[5 + crcSize] >> 7);
+ } else {+ // MPEG-2 or 2.5
+ return pFrame[4 + crcSize];
+ }
+}
+
+extern "C" u_int8_t MP4AV_Mp3GetCrcSize(MP4AV_Mp3Header hdr)
+{+ return ((hdr & 0x00010000) ? 0 : 2);
+}
+
+extern "C" u_int8_t MP4AV_Mp3GetSideInfoSize(MP4AV_Mp3Header hdr)
+{+ u_int8_t version = MP4AV_Mp3GetHdrVersion(hdr);
+ u_int8_t layer = MP4AV_Mp3GetHdrLayer(hdr);
+ u_int8_t mode = (hdr >> 6) & 0x3;
+ u_int8_t channels = (mode == 3 ? 1 : 2);
+
+ // check that this is layer 3
+ if (layer != 1) {+ return 0;
+ }
+
+ if (version == 3) {+ // MPEG-1
+ if (channels == 1) {+ return 17;
+ } else { + return 32;
+ }
+ } else {+ // MPEG-2 or 2.5
+ if (channels == 1) {+ return 9;
+ } else { + return 17;
+ }
+ }
+}
+
+extern "C" u_int8_t MP4AV_Mp3ToMp4AudioType(u_int8_t mpegVersion)
+{+ u_int8_t audioType = MP4_INVALID_AUDIO_TYPE;
+
+ switch (mpegVersion) {+ case 3:
+ audioType = MP4_MPEG1_AUDIO_TYPE;
+ break;
+ case 2:
+ case 0:
+ audioType = MP4_MPEG2_AUDIO_TYPE;
+ break;
+ case 1:
+ break;
+ }
+ return audioType;
+}
+
--- /dev/null
+++ b/common/mp4av/mp4av.h
@@ -1,0 +1,46 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#ifndef __MP4AV_INCLUDED__
+#define __MP4AV_INCLUDED__
+
+#include <mp4.h>
+
+#ifdef __cplusplus
+/* exploit C++ ability of default values for function parameters */
+#define DEFAULT_PARM(x) =x
+#else
+#define DEFAULT_PARM(x)
+#endif
+
+/* MP4AV library API */
+#include "mp4av_aac.h"
+#include "mp4av_adts.h"
+#include "mp4av_mp3.h"
+#include "mp4av_mpeg4.h"
+#include "mp4av_audio.h"
+#include "mp4av_hinters.h"
+#include "mp4av_mpeg3.h"
+
+#undef DEFAULT_PARM
+
+#endif /* __MP4AV_INCLUDED__ */
+
--- /dev/null
+++ b/common/mp4av/mp4av_aac.h
@@ -1,0 +1,61 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#ifndef __MP4AV_AAC_INCLUDED__
+#define __MP4AV_AAC_INCLUDED__
+
+#define MP4AV_AAC_MAIN_PROFILE 0
+#define MP4AV_AAC_LC_PROFILE 1
+#define MP4AV_AAC_SSR_PROFILE 2
+#define MP4AV_AAC_LTP_PROFILE 3
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+u_int8_t MP4AV_AacConfigGetSamplingRateIndex(
+ u_int8_t* pConfig);
+
+u_int32_t MP4AV_AacConfigGetSamplingRate(
+ u_int8_t* pConfig);
+
+u_int16_t MP4AV_AacConfigGetSamplingWindow(
+ u_int8_t* pConfig);
+
+u_int8_t MP4AV_AacConfigGetChannels(
+ u_int8_t* pConfig);
+
+bool MP4AV_AacGetConfigurationFromAdts(
+ u_int8_t** ppConfig,
+ u_int32_t* pConfigLength,
+ u_int8_t* pAdtsHdr);
+
+bool MP4AV_AacGetConfiguration(
+ u_int8_t** ppConfig,
+ u_int32_t* pConfigLength,
+ u_int8_t profile,
+ u_int32_t samplingRate,
+ u_int8_t channels);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __MP4AV_AAC_INCLUDED__ */
--- /dev/null
+++ b/common/mp4av/mp4av_adts.h
@@ -1,0 +1,86 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#ifndef __MP4AV_ADTS_INCLUDED__
+#define __MP4AV_ADTS_INCLUDED__
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+#define NUM_ADTS_SAMPLING_RATES 16
+
+extern u_int32_t AdtsSamplingRates[NUM_ADTS_SAMPLING_RATES];
+
+bool MP4AV_AdtsGetNextFrame(
+ u_int8_t* pSrc,
+ u_int32_t srcLength,
+ u_int8_t** ppFrame,
+ u_int32_t* pFrameSize);
+
+u_int16_t MP4AV_AdtsGetFrameSize(
+ u_int8_t* pHdr);
+
+u_int16_t MP4AV_AdtsGetHeaderBitSize(
+ u_int8_t* pHdr);
+
+u_int16_t MP4AV_AdtsGetHeaderByteSize(
+ u_int8_t* pHdr);
+
+u_int8_t MP4AV_AdtsGetVersion(
+ u_int8_t* pHdr);
+
+u_int8_t MP4AV_AdtsGetProfile(
+ u_int8_t* pHdr);
+
+u_int8_t MP4AV_AdtsGetSamplingRateIndex(
+ u_int8_t* pHdr);
+
+u_int8_t MP4AV_AdtsFindSamplingRateIndex(
+ u_int32_t samplingRate);
+
+u_int32_t MP4AV_AdtsGetSamplingRate(
+ u_int8_t* pHdr);
+
+u_int8_t MP4AV_AdtsGetChannels(
+ u_int8_t* pHdr);
+
+bool MP4AV_AdtsMakeFrame(
+ u_int8_t* pData,
+ u_int16_t dataLength,
+ bool isMpeg2,
+ u_int8_t profile,
+ u_int32_t samplingFrequency,
+ u_int8_t channels,
+ u_int8_t** ppAdtsData,
+ u_int32_t* pAdtsDataLength);
+
+bool MP4AV_AdtsMakeFrameFromMp4Sample(
+ MP4FileHandle mp4File,
+ MP4TrackId trackId,
+ MP4SampleId sampleId,
+ u_int8_t** ppAdtsData,
+ u_int32_t* pAdtsDataLength);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __MP4AV_ADTS_INCLUDED__ */
--- /dev/null
+++ b/common/mp4av/mp4av_audio.h
@@ -1,0 +1,45 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#ifndef __MP4AV_AUDIO_INCLUDED__
+#define __MP4AV_AUDIO_INCLUDED__
+
+// Audio Track Utitlites
+#ifdef __cplusplus
+extern "C" {+#endif
+
+u_int8_t MP4AV_AudioGetChannels(
+ MP4FileHandle mp4File,
+ MP4TrackId audioTrackId);
+
+u_int32_t MP4AV_AudioGetSamplingRate(
+ MP4FileHandle mp4File,
+ MP4TrackId audioTrackId);
+
+u_int16_t MP4AV_AudioGetSamplingWindow(
+ MP4FileHandle mp4File,
+ MP4TrackId audioTrackId);
+#ifdef __cplusplus
+}
+#endif
+#endif /* __MP4AV_AUDIO_INCLUDED__ */
+
--- /dev/null
+++ b/common/mp4av/mp4av_common.h
@@ -1,0 +1,33 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#ifndef __MP4AV_COMMON_INCLUDED__
+#define __MP4AV_COMMON_INCLUDED__
+
+// the external interface
+#include "mp4av.h"
+
+// the internal interfaces
+#include "mbs.h"
+#include "audio_hinters.h"
+
+#endif /* __MP4AV_COMMON_INCLUDED__ */
+
--- /dev/null
+++ b/common/mp4av/mp4av_hinters.h
@@ -1,0 +1,71 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#ifndef __MP4AV_HINTERS_INCLUDED__
+#define __MP4AV_HINTERS_INCLUDED__
+
+#define MP4AV_DFLT_PAYLOAD_SIZE 1460
+
+// Audio Hinters
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+bool MP4AV_Rfc2250Hinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ bool interleave DEFAULT_PARM(false),
+ u_int16_t maxPayloadSize DEFAULT_PARM(MP4AV_DFLT_PAYLOAD_SIZE));
+
+bool MP4AV_Rfc3119Hinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ bool interleave DEFAULT_PARM(false),
+ u_int16_t maxPayloadSize DEFAULT_PARM(MP4AV_DFLT_PAYLOAD_SIZE));
+
+bool MP4AV_RfcIsmaHinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ bool interleave DEFAULT_PARM(false),
+ u_int16_t maxPayloadSize DEFAULT_PARM(MP4AV_DFLT_PAYLOAD_SIZE));
+
+
+// Video Hinters
+
+bool MP4AV_Rfc3016Hinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ u_int16_t maxPayloadSize DEFAULT_PARM(MP4AV_DFLT_PAYLOAD_SIZE));
+
+bool L16Hinter(MP4FileHandle mp4File,
+ MP4TrackId mediaTrackID,
+ uint16_t maxPayloadSize DEFAULT_PARM(MP4AV_DFLT_PAYLOAD_SIZE));
+
+bool Mpeg12Hinter(MP4FileHandle mp4File,
+ MP4TrackId mediaTrackID,
+ uint16_t maxPayloadSize DEFAULT_PARM(MP4AV_DFLT_PAYLOAD_SIZE));
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MP4AV_HINTERS_INCLUDED__ */
+
--- /dev/null
+++ b/common/mp4av/mp4av_mp3.h
@@ -1,0 +1,68 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#ifndef __MP4AV_MP3_INCLUDED__
+#define __MP4AV_MP3_INCLUDED__
+
+typedef u_int32_t MP4AV_Mp3Header;
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+bool MP4AV_Mp3GetNextFrame(
+ const u_int8_t* pSrc,
+ u_int32_t srcLength,
+ const u_int8_t** ppFrame,
+ u_int32_t* pFrameSize,
+ bool allowLayer4 DEFAULT_PARM(false),
+ bool donthack DEFAULT_PARM(false));
+
+MP4AV_Mp3Header MP4AV_Mp3HeaderFromBytes(const u_int8_t* pBytes);
+
+u_int8_t MP4AV_Mp3GetHdrVersion(MP4AV_Mp3Header hdr);
+
+u_int8_t MP4AV_Mp3GetHdrLayer(MP4AV_Mp3Header hdr);
+
+u_int8_t MP4AV_Mp3GetChannels(MP4AV_Mp3Header hdr);
+
+u_int16_t MP4AV_Mp3GetHdrSamplingRate(MP4AV_Mp3Header hdr);
+
+u_int16_t MP4AV_Mp3GetHdrSamplingWindow(MP4AV_Mp3Header hdr);
+
+u_int16_t MP4AV_Mp3GetSamplingWindow(u_int16_t samplingRate);
+
+u_int16_t MP4AV_Mp3GetBitRate(MP4AV_Mp3Header hdr);
+
+u_int16_t MP4AV_Mp3GetFrameSize(MP4AV_Mp3Header hdr);
+
+u_int16_t MP4AV_Mp3GetAduOffset(const u_int8_t* pFrame, u_int32_t frameSize);
+
+u_int8_t MP4AV_Mp3GetCrcSize(MP4AV_Mp3Header hdr);
+
+u_int8_t MP4AV_Mp3GetSideInfoSize(MP4AV_Mp3Header hdr);
+
+u_int8_t MP4AV_Mp3ToMp4AudioType(u_int8_t mpegVersion);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __MP4AV_MP3_INCLUDED__ */
--- /dev/null
+++ b/common/mp4av/mp4av_mpeg3.h
@@ -1,0 +1,40 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Bill May ([email protected])
+ */
+#ifndef __MP4AV_MPEG3_H__
+#define __MP4AV_MPEG3_H__ 1
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+ int MP4AV_Mpeg3ParseSeqHdr(uint8_t *pbuffer, uint32_t buflen,
+ int *have_mpeg2,
+ uint32_t *height, uint32_t *width,
+ double *frame_rate, double *bitrate);
+
+ int MP4AV_Mpeg3PictHdrType(uint8_t *pbuffer);
+
+ int MP4AV_Mpeg3FindGopOrPictHdr(uint8_t *pbuffer, uint32_t buflen, int *ftype);
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/common/mp4av/mp4av_mpeg4.h
@@ -1,0 +1,97 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+#ifndef __MP4AV_MPEG4_INCLUDED__
+#define __MP4AV_MPEG4_INCLUDED__
+
+#define MP4AV_MPEG4_SYNC 0x000001
+#define MP4AV_MPEG4_VOSH_START 0xB0
+#define MP4AV_MPEG4_VOL_START 0x20
+#define MP4AV_MPEG4_GOV_START 0xB3
+#define MP4AV_MPEG4_VO_START 0xB5
+#define MP4AV_MPEG4_VOP_START 0xB6
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+bool MP4AV_Mpeg4ParseVosh(
+ u_int8_t* pVoshBuf,
+ u_int32_t voshSize,
+ u_int8_t* pProfileLevel);
+
+bool MP4AV_Mpeg4CreateVosh(
+ u_int8_t** ppBytes,
+ u_int32_t* pNumBytes,
+ u_int8_t profileLevel);
+
+bool MP4AV_Mpeg4CreateVo(
+ u_int8_t** ppBytes,
+ u_int32_t* pNumBytes,
+ u_int8_t objectId);
+
+bool MP4AV_Mpeg4ParseVol(
+ u_int8_t* pVolBuf,
+ u_int32_t volSize,
+ u_int8_t* pTimeBits,
+ u_int16_t* pTimeTicks,
+ u_int16_t* pFrameDuration,
+ u_int16_t* pFrameWidth,
+ u_int16_t* pFrameHeight);
+
+bool MP4AV_Mpeg4CreateVol(
+ u_int8_t** ppBytes,
+ u_int32_t* pNumBytes,
+ u_int8_t profile,
+ float frameRate,
+ bool shortTime,
+ bool variableRate,
+ u_int16_t width,
+ u_int16_t height,
+ u_int8_t quantType,
+ u_int8_t* pTimeBits DEFAULT_PARM(NULL));
+
+bool MP4AV_Mpeg4ParseGov(
+ u_int8_t* pGovBuf,
+ u_int32_t govSize,
+ u_int8_t* pHours,
+ u_int8_t* pMinutes,
+ u_int8_t* pSeconds);
+
+bool MP4AV_Mpeg4ParseVop(
+ u_int8_t* pVopBuf,
+ u_int32_t vopSize,
+ u_char* pVopType,
+ u_int8_t timeBits,
+ u_int16_t timeTicks,
+ u_int32_t* pVopTimeIncrement);
+
+u_int8_t MP4AV_Mpeg4VideoToSystemsProfileLevel(
+ u_int8_t videoProfileLevel);
+
+u_char MP4AV_Mpeg4GetVopType(
+ u_int8_t* pVopBuf,
+ u_int32_t vopSize);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __MP4AV_MPEG4_INCLUDED__ */
--- /dev/null
+++ b/common/mp4av/mpeg3.cpp
@@ -1,0 +1,450 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Bill May ([email protected])
+ */
+
+#include "mpeg4ip.h"
+#include "mp4av.h"
+
+//#define DEBUG_MPEG3_HINT 1
+
+static double mpeg3_frame_rate_table[16] =
+{+ 0.0, /* Pad */
+ 24000.0/1001.0, /* Official frame rates */
+ 24.0,
+ 25.0,
+ 30000.0/1001.0,
+ 30.0,
+ 50.0,
+ ((60.0*1000.0)/1001.0),
+ 60.0,
+
+ 1, /* Unofficial economy rates */
+ 5,
+ 10,
+ 12,
+ 15,
+ 0,
+ 0,
+};
+#define MPEG3_START_CODE_PREFIX 0x000001
+#define MPEG3_SEQUENCE_START_CODE 0x000001b3
+#define MPEG3_PICTURE_START_CODE 0x00000100
+#define MPEG3_GOP_START_CODE 0x000001b8
+#define MPEG3_EXT_START_CODE 0x000001b5
+#define MPEG3_SLICE_MIN_START 0x00000101
+#define MPEG3_SLICE_MAX_START 0x000001af
+
+#define SEQ_ID 1
+extern "C" int MP4AV_Mpeg3ParseSeqHdr (uint8_t *pbuffer,
+ uint32_t buflen,
+ int *have_mpeg2,
+ uint32_t *height,
+ uint32_t *width,
+ double *frame_rate,
+ double *bitrate)
+{+ uint32_t framerate_code;
+ uint32_t bitrate_int;
+ uint32_t bitrate_ext;
+#if 1
+ uint32_t scode, ix;
+ int found = -1;
+ *have_mpeg2 = 0;
+ buflen -= 6;
+ bitrate_int = 0;
+ for (ix = 0; ix < buflen; ix++, pbuffer++) {+ scode = (pbuffer[0] << 24) | (pbuffer[1] << 16) | (pbuffer[2] << 8) |
+ pbuffer[3];
+
+ if (scode == MPEG3_SEQUENCE_START_CODE) {+ pbuffer += sizeof(uint32_t);
+ *width = (pbuffer[0]);
+ *width <<= 4;
+ *width |= ((pbuffer[1] >> 4) &0xf);
+ *height = (pbuffer[1] & 0xf);
+ *height <<= 8;
+ *height |= pbuffer[2];
+ framerate_code = pbuffer[3] & 0xf;
+ *frame_rate = mpeg3_frame_rate_table[framerate_code];
+ // 18 bits
+ bitrate_int = (pbuffer[4] << 10) |
+ (pbuffer[5] << 2) |
+ ((pbuffer[6] >> 6) & 0x3);
+ *bitrate = bitrate_int;
+ *bitrate *= 400.0;
+ ix += sizeof(uint32_t) + 7;
+ pbuffer += 7;
+ found = 0;
+ } else if (found == 0) {+ if (scode == MPEG3_EXT_START_CODE) {+ pbuffer += sizeof(uint32_t);
+ ix += sizeof(uint32_t);
+ switch ((pbuffer[0] >> 4) & 0xf) {+ case SEQ_ID:
+ *have_mpeg2 = 1;
+ *height = ((pbuffer[1] & 0x1) << 13) |
+ ((pbuffer[2] & 0x80) << 5) |
+ (*height & 0x0fff);
+ *width = (((pbuffer[2] >> 5) & 0x3) << 12) | (*width & 0x0fff);
+ bitrate_ext = (pbuffer[2] & 0x1f) << 7;
+ bitrate_ext |= (pbuffer[3] >> 1) & 0x7f;
+ bitrate_int |= (bitrate_ext << 18);
+ *bitrate = bitrate_int;
+ *bitrate *= 400.0;
+ break;
+ default:
+ break;
+ }
+ pbuffer++;
+ ix++;
+ } else if (scode == MPEG3_PICTURE_START_CODE) {+ return found;
+ }
+ }
+ }
+ return found;
+
+#else
+ // if you want to do the whole frame
+ int ix;
+ CBitstream bs(pbuffer, buflen);
+
+
+ try {+
+ while (bs.PeekBits(32) != MPEG3_SEQUENCE_START_CODE) {+ bs.GetBits(8);
+ }
+
+ bs.GetBits(32); // start code
+
+ *height = bs.GetBits(12);
+ *width = bs.GetBits(12);
+ bs.GetBits(4);
+ framerate_code = bs.GetBits(4);
+ *frame_rate = mpeg3_frame_rate_table[framerate_code];
+
+ bs.GetBits(18); // bitrate
+ bs.GetBits(1); // marker bit
+ bs.GetBits(10); // vbv buffer
+ bs.GetBits(1); // constrained params
+ if (bs.GetBits(1)) { // intra_quantizer_matrix+ for (ix = 0; ix < 64; ix++) {+ bs.GetBits(8);
+ }
+ }
+ if (bs.GetBits(1)) { // non_intra_quantizer_matrix+ for (ix = 0; ix < 64; ix++) {+ bs.GetBits(8);
+ }
+ }
+ } catch (...) {+ return false;
+ }
+ return true;
+#endif
+}
+
+extern "C" int MP4AV_Mpeg3PictHdrType (uint8_t *pbuffer)
+{+ pbuffer += sizeof(uint32_t);
+ return ((pbuffer[1] >> 3) & 0x7);
+}
+
+static int FindNextStart (uint8_t *pbuffer,
+ uint32_t buflen,
+ uint32_t *optr,
+ uint32_t *scode)
+{+ uint32_t value;
+ uint32_t offset;
+
+ for (offset = 0; offset < buflen; offset++, pbuffer++) {+ value = (pbuffer[0] << 16) | (pbuffer[1] << 8) | (pbuffer[2] << 0);
+
+ if (value == MPEG3_START_CODE_PREFIX) {+ *optr = offset;
+ *scode = (value << 8) | pbuffer[3];
+ return 0;
+ }
+ }
+ return -1;
+}
+
+static int FindNextSliceStart (uint8_t *pbuffer,
+ uint32_t startoffset,
+ uint32_t buflen,
+ uint32_t *slice_offset)
+{+ uint32_t slicestart, code;
+ while (FindNextStart(pbuffer + startoffset,
+ buflen - startoffset,
+ &slicestart,
+ &code) >= 0) {+#ifdef DEBUG_MPEG3_HINT
+ printf("Code %x at offset %d\n", + code, startoffset + slicestart);
+#endif
+ if ((code >= MPEG3_SLICE_MIN_START) &&
+ (code <= MPEG3_SLICE_MAX_START)) {+ *slice_offset = slicestart + startoffset;
+ return 0;
+ }
+ startoffset += slicestart + 4;
+ }
+ return -1;
+}
+
+extern "C" int MP4AV_Mpeg3FindGopOrPictHdr (uint8_t *pbuffer,
+ uint32_t buflen,
+ int *frame_type)
+{+ uint32_t value;
+ uint32_t offset;
+ int ftype;
+ for (offset = 0; offset < buflen; offset++, pbuffer++) {+ value = (pbuffer[0] << 24) | (pbuffer[1] << 16) | (pbuffer[2] << 8) |
+ pbuffer[3];
+
+ if (value == MPEG3_PICTURE_START_CODE) {+ ftype = MP4AV_Mpeg3PictHdrType(pbuffer);
+ if (frame_type != NULL) *frame_type = ftype;
+ if (ftype == 1) {+ return 0;
+ } else {+ return -1;
+ }
+ } else if (value == MPEG3_GOP_START_CODE) {+ return 1;
+ }
+ }
+ return -1;
+}
+
+extern "C" bool Mpeg12Hinter (MP4FileHandle mp4file,
+ MP4TrackId trackid,
+ uint16_t maxPayloadSize)
+{+ uint32_t numSamples, maxSampleSize;
+ uint8_t videoType;
+ uint8_t rfc2250[4], rfc2250_2;
+ uint32_t offset;
+ uint32_t scode;
+ int have_seq;
+ bool stop;
+ uint8_t *buffer, *pbuffer;
+ uint8_t *pstart;
+ uint8_t type;
+ uint32_t next_slice, prev_slice;
+ bool slice_at_begin;
+ uint32_t sampleSize;
+ MP4SampleId sid;
+
+ MP4TrackId hintTrackId;
+
+ numSamples = MP4GetTrackNumberOfSamples(mp4file, trackid);
+ maxSampleSize = MP4GetTrackMaxSampleSize(mp4file, trackid);
+
+ if (numSamples == 0) return false;
+
+ videoType = MP4GetTrackVideoType(mp4file, trackid);
+
+ if (videoType != MP4_MPEG1_VIDEO_TYPE &&
+ videoType != MP4_MPEG2_VIDEO_TYPE) {+ return false;
+ }
+
+ hintTrackId = MP4AddHintTrack(mp4file, trackid);
+ if (hintTrackId == MP4_INVALID_TRACK_ID) {+ return false;
+ }
+
+ uint8_t payload = 32;
+ MP4SetHintTrackRtpPayload(mp4file, hintTrackId, "MPV", &payload, 0);
+
+
+ buffer = (uint8_t *)malloc(maxSampleSize);
+ if (buffer == NULL) {+ MP4DeleteTrack(mp4file, hintTrackId);
+ return false;
+ }
+
+ maxPayloadSize -= 24; // this is for the 4 byte header
+
+ for (sid = 1; sid <= numSamples; sid++) {+ sampleSize = maxSampleSize;
+ MP4Timestamp startTime;
+ MP4Duration duration;
+ MP4Duration renderingOffset;
+ bool isSyncSample;
+
+ bool rc = MP4ReadSample(mp4file, trackid, sid,
+ &buffer, &sampleSize,
+ &startTime, &duration,
+ &renderingOffset, &isSyncSample);
+#ifdef DEBUG_MPEG3_HINT
+ printf("sid %d - sample size %d\n", sid, sampleSize);+#endif
+ if (rc == false) {+ MP4DeleteTrack(mp4file, hintTrackId);
+ return false;
+ }
+
+ // need to add rfc2250 header
+ offset = 0;
+ have_seq = 0;
+ pbuffer = buffer;
+ stop = false;
+ do {+ uint32_t oldoffset;
+ oldoffset = offset;
+ if (FindNextStart(pbuffer + offset,
+ sampleSize - offset,
+ &offset,
+ &scode) < 0) {+ // didn't find the start code
+#ifdef DEBUG_MPEG3_HINT
+ printf("didn't find start code\n");+#endif
+ stop = true;
+ } else {+ offset += oldoffset;
+#ifdef DEBUG_MPEG3_HINT
+ printf("next sscode %x found at %d\n", scode, offset);+#endif
+ if (scode == MPEG3_SEQUENCE_START_CODE) have_seq = 1;
+ offset += 4; // start with next value
+ }
+ } while (scode != MPEG3_PICTURE_START_CODE && stop == false);
+
+ pstart = pbuffer + offset; // point to inside of picture start
+ type = (pstart[1] >> 3) & 0x7;
+
+ rfc2250[0] = (*pstart >> 6) & 0x3;
+ rfc2250[1] = (pstart[0] << 2) | ((pstart[1] >> 6) & 0x3); // temporal ref
+ rfc2250[2] = type;
+ if (have_seq != 0) {+ rfc2250[2] |= 0x20;
+ have_seq = 0;
+ }
+ rfc2250_2 = rfc2250[2];
+
+ rfc2250[3] = 0;
+ if (type == 2 || type == 3) {+ rfc2250[3] = pstart[3] << 5;
+ if ((pstart[4] & 0x80) != 0) rfc2250[3] |= 0x10;
+ if (type == 3) {+ rfc2250[3] |= (pstart[4] >> 3) & 0xf;
+ }
+ }
+
+ MP4AddRtpVideoHint(mp4file, hintTrackId, type == 3, renderingOffset);
+ // Find the next slice. Then we can add the header if the next
+ // slice will be in the start. This lets us set the S bit in
+ // rfc2250[2]. Then we need to loop to find the next slice that's
+ // not in the buffer size - this should be in the while loop.
+
+ prev_slice = 0;
+ if (FindNextSliceStart(pbuffer, offset, sampleSize, &next_slice) < 0) {+ slice_at_begin = false;
+ } else {+ slice_at_begin = true;
+ }
+
+#ifdef DEBUG_MPEG3_HINT
+ printf("starting slice at %d\n", next_slice);+#endif
+ offset = 0;
+ bool nomoreslices = false;
+ bool found_slice = slice_at_begin;
+ bool onfirst = true;
+
+ while (sampleSize > 0) {+ bool isLastPacket;
+ uint32_t len_to_write;
+
+ if (sampleSize <= maxPayloadSize) {+ // leave started_slice alone
+ len_to_write = sampleSize;
+ isLastPacket = true;
+ prev_slice = 0;
+ } else {+ found_slice = (onfirst == false) && (nomoreslices == false) && (next_slice <= maxPayloadSize);
+ onfirst = false;
+ isLastPacket = false;
+
+ while (nomoreslices == false && next_slice <= maxPayloadSize) {+ prev_slice = next_slice;
+ if (FindNextSliceStart(pbuffer, next_slice + 4, sampleSize, &next_slice) >= 0) {+#ifdef DEBUG_MPEG3_HINT
+ printf("prev_slice %u next slice %u %u\n", prev_slice, next_slice,+ offset + next_slice);
+#endif
+ found_slice = true;
+ } else {+ // at end
+ nomoreslices = true;
+ }
+ }
+ // prev_slice should have the end value. If it's not 0, we have
+ // the end of the slice.
+ if (found_slice) len_to_write = prev_slice;
+ else len_to_write = MIN(maxPayloadSize, sampleSize);
+ }
+
+ rfc2250[2] = rfc2250_2;
+ if (slice_at_begin) {+ rfc2250[2] |= 0x10; // set b bit
+ }
+ if (found_slice || isLastPacket) {+ rfc2250[2] |= 0x08; // set end of slice bit
+ slice_at_begin = true; // for next time
+ } else {+ slice_at_begin = false;
+ }
+
+#ifdef DEBUG_MPEG3_HINT
+ printf("Adding packet, sid %u prev slice %u len_to_write %u\n",+ sid, prev_slice, len_to_write);
+ printf("Next slice %u offset %u %x %x %x %x\n\n", + next_slice, offset,
+ rfc2250[0], rfc2250[1], rfc2250[2], rfc2250[3]);
+#endif
+
+ // okay - we can now write out this packet.
+ MP4AddRtpPacket(mp4file, hintTrackId, isLastPacket);
+ // add the 4 byte header
+ MP4AddRtpImmediateData(mp4file, hintTrackId, rfc2250, sizeof(rfc2250));
+
+ // add the immediate data
+ MP4AddRtpSampleData(mp4file, hintTrackId, sid, offset, len_to_write);
+ offset += len_to_write;
+ sampleSize -= len_to_write;
+ prev_slice = 0;
+ next_slice -= len_to_write;
+ pbuffer += len_to_write;
+ }
+ MP4WriteRtpHint(mp4file, hintTrackId, duration, type == 1);
+ }
+
+ free(buffer);
+ return true;
+}
--- /dev/null
+++ b/common/mp4av/mpeg4.cpp
@@ -1,0 +1,572 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+/*
+ * Notes:
+ * - file formatted with tabstops == 4 spaces
+ */
+
+#include <mp4av_common.h>
+
+extern "C" bool MP4AV_Mpeg4ParseVosh(
+ u_int8_t* pVoshBuf,
+ u_int32_t voshSize,
+ u_int8_t* pProfileLevel)
+{+ CMemoryBitstream vosh;
+
+ vosh.SetBytes(pVoshBuf, voshSize);
+
+ try {+ vosh.GetBits(32); // start code
+ *pProfileLevel = vosh.GetBits(8);
+ }
+ catch (int e) {+ return false;
+ }
+
+ return true;
+}
+
+extern "C" bool MP4AV_Mpeg4CreateVosh(
+ u_int8_t** ppBytes,
+ u_int32_t* pNumBytes,
+ u_int8_t profileLevel)
+{+ CMemoryBitstream vosh;
+
+ try {+ if (*ppBytes) {+ // caller must guarantee buffer against overrun
+ memset((*ppBytes) + (*pNumBytes), 0, 5);
+ vosh.SetBytes(*ppBytes, (*pNumBytes) + 5);
+ vosh.SetBitPosition((*pNumBytes) << 3);
+ } else {+ vosh.AllocBytes(5);
+ }
+
+ vosh.PutBits(MP4AV_MPEG4_SYNC, 24);
+ vosh.PutBits(MP4AV_MPEG4_VOSH_START, 8);
+ vosh.PutBits(profileLevel, 8);
+
+ *ppBytes = vosh.GetBuffer();
+ *pNumBytes = vosh.GetNumberOfBytes();
+ }
+ catch (int e) {+ return false;
+ }
+
+ return true;
+}
+
+extern "C" bool MP4AV_Mpeg4CreateVo(
+ u_int8_t** ppBytes,
+ u_int32_t* pNumBytes,
+ u_int8_t objectId)
+{+ CMemoryBitstream vo;
+
+ try {+ if (*ppBytes) {+ // caller must guarantee buffer against overrun
+ memset((*ppBytes) + (*pNumBytes), 0, 9);
+ vo.SetBytes(*ppBytes, *pNumBytes + 9);
+ vo.SetBitPosition((*pNumBytes) << 3);
+ } else {+ vo.AllocBytes(9);
+ }
+
+ vo.PutBits(MP4AV_MPEG4_SYNC, 24);
+ vo.PutBits(MP4AV_MPEG4_VO_START, 8);
+ vo.PutBits(0x08, 8); // no verid, priority, or signal type
+ vo.PutBits(MP4AV_MPEG4_SYNC, 24);
+ vo.PutBits(objectId - 1, 8);
+
+ *ppBytes = vo.GetBuffer();
+ *pNumBytes = vo.GetNumberOfBytes();
+ }
+ catch (int e) {+ return false;
+ }
+
+ return true;
+}
+
+extern "C" bool MP4AV_Mpeg4ParseVol(
+ u_int8_t* pVolBuf,
+ u_int32_t volSize,
+ u_int8_t* pTimeBits,
+ u_int16_t* pTimeTicks,
+ u_int16_t* pFrameDuration,
+ u_int16_t* pFrameWidth,
+ u_int16_t* pFrameHeight)
+{+ CMemoryBitstream vol;
+
+ vol.SetBytes(pVolBuf, volSize);
+
+ try {+ vol.SkipBits(32); // start code
+
+ vol.SkipBits(1); // random accessible vol
+ vol.SkipBits(8); // object type id
+ u_int8_t verid = 0;
+ if (vol.GetBits(1)) { // is object layer id+ verid = vol.GetBits(4); // object layer verid
+ vol.SkipBits(3); // object layer priority
+ }
+ if (vol.GetBits(4) == 0xF) { // aspect ratio info+ vol.SkipBits(8); // par width
+ vol.SkipBits(8); // par height
+ }
+ if (vol.GetBits(1)) { // vol control parameters+ vol.SkipBits(2); // chroma format
+ vol.SkipBits(1); // low delay
+ if (vol.GetBits(1)) { // vbv parameters+ vol.SkipBits(15); // first half bit rate
+ vol.SkipBits(1); // marker bit
+ vol.SkipBits(15); // latter half bit rate
+ vol.SkipBits(1); // marker bit
+ vol.SkipBits(15); // first half vbv buffer size
+ vol.SkipBits(1); // marker bit
+ vol.SkipBits(3); // latter half vbv buffer size
+ vol.SkipBits(11); // first half vbv occupancy
+ vol.SkipBits(1); // marker bit
+ vol.SkipBits(15); // latter half vbv occupancy
+ vol.SkipBits(1); // marker bit
+ }
+ }
+ u_int8_t shape = vol.GetBits(2); // object layer shape
+ if (shape == 3 /* GRAYSCALE */ && verid != 1) {+ vol.SkipBits(4); // object layer shape extension
+ }
+ vol.SkipBits(1); // marker bit
+ *pTimeTicks = vol.GetBits(16); // vop time increment resolution
+
+ u_int8_t i;
+ u_int32_t powerOf2 = 1;
+ for (i = 0; i < 16; i++) {+ if (*pTimeTicks < powerOf2) {+ break;
+ }
+ powerOf2 <<= 1;
+ }
+ *pTimeBits = i;
+
+ vol.SkipBits(1); // marker bit
+ if (vol.GetBits(1)) { // fixed vop rate+ // fixed vop time increment
+ *pFrameDuration = vol.GetBits(*pTimeBits);
+ } else {+ *pFrameDuration = 0;
+ }
+ if (shape == 0 /* RECTANGULAR */) {+ vol.SkipBits(1); // marker bit
+ *pFrameWidth = vol.GetBits(13); // object layer width
+ vol.SkipBits(1); // marker bit
+ *pFrameHeight = vol.GetBits(13);// object layer height
+ vol.SkipBits(1); // marker bit
+ } else {+ *pFrameWidth = 0;
+ *pFrameHeight = 0;
+ }
+ // there's more, but we don't need it
+ }
+ catch (int e) {+ return false;
+ }
+
+ return true;
+}
+
+extern "C" bool MP4AV_Mpeg4CreateVol(
+ u_int8_t** ppBytes,
+ u_int32_t* pNumBytes,
+ u_int8_t profile,
+ float frameRate,
+ bool shortTime,
+ bool variableRate,
+ u_int16_t width,
+ u_int16_t height,
+ u_int8_t quantType,
+ u_int8_t* pTimeBits)
+{+ CMemoryBitstream vol;
+
+ try {+ if (*ppBytes) {+ // caller must guarantee buffer against overrun
+ memset((*ppBytes) + (*pNumBytes), 0, 20);
+ vol.SetBytes(*ppBytes, *pNumBytes + 20);
+ vol.SetBitPosition((*pNumBytes) << 3);
+ } else {+ vol.AllocBytes(20);
+ }
+
+ /* VOL - Video Object Layer */
+ vol.PutBits(MP4AV_MPEG4_SYNC, 24);
+ vol.PutBits(MP4AV_MPEG4_VOL_START, 8);
+
+ /* 1 bit - random access = 0 (1 only if every VOP is an I frame) */
+ vol.PutBits(0, 1);
+ /*
+ * 8 bits - type indication
+ * = 1 (simple profile)
+ * = 4 (main profile)
+ */
+ vol.PutBits(profile, 8);
+ /* 1 bit - is object layer id = 1 */
+ vol.PutBits(1, 1);
+ /* 4 bits - visual object layer ver id = 2 */
+ vol.PutBits(2, 4);
+ /* 3 bits - visual object layer priority = 1 */
+ vol.PutBits(1, 3);
+
+ /* 4 bits - aspect ratio info = 1 (square pixels) */
+ vol.PutBits(1, 4);
+ /* 1 bit - VOL control params = 0 */
+ vol.PutBits(0, 1);
+ /* 2 bits - VOL shape = 0 (rectangular) */
+ vol.PutBits(0, 2);
+ /* 1 bit - marker = 1 */
+ vol.PutBits(1, 1);
+
+ u_int16_t ticks;
+ if (shortTime /* && frameRate == (float)((int)frameRate) */) {+ ticks = (u_int16_t)(frameRate + 0.5);
+ } else {+ ticks = 30000;
+ }
+ /* 16 bits - VOP time increment resolution */
+ vol.PutBits(ticks, 16);
+ /* 1 bit - marker = 1 */
+ vol.PutBits(1, 1);
+
+ u_int8_t rangeBits = 1;
+ while (ticks > (1 << rangeBits)) {+ rangeBits++;
+ }
+ if (pTimeBits) {+ *pTimeBits = rangeBits;
+ }
+
+ /* 1 bit - fixed vop rate = 0 or 1 */
+ if (variableRate) {+ vol.PutBits(0, 1);
+ } else {+ vol.PutBits(1, 1);
+
+ u_int16_t frameDuration =
+ (u_int16_t)((float)ticks / frameRate);
+
+ /* 1-16 bits - fixed vop time increment in ticks */
+ vol.PutBits(frameDuration, rangeBits);
+ }
+ /* 1 bit - marker = 1 */
+ vol.PutBits(1, 1);
+ /* 13 bits - VOL width */
+ vol.PutBits(width, 13);
+ /* 1 bit - marker = 1 */
+ vol.PutBits(1, 1);
+ /* 13 bits - VOL height */
+ vol.PutBits(height, 13);
+ /* 1 bit - marker = 1 */
+ vol.PutBits(1, 1);
+ /* 1 bit - interlaced = 0 */
+ vol.PutBits(0, 1);
+
+ /* 1 bit - overlapped block motion compensation disable = 1 */
+ vol.PutBits(1, 1);
+ /* 2 bits - sprite usage = 0 */
+ vol.PutBits(0, 2);
+ /* 1 bit - not 8 bit pixels = 0 */
+ vol.PutBits(0, 1);
+ /* 1 bit - quant type = 0 */
+ vol.PutBits(quantType, 1);
+ if (quantType) {+ /* 1 bit - load intra quant mat = 0 */
+ vol.PutBits(0, 1);
+ /* 1 bit - load inter quant mat = 0 */
+ vol.PutBits(0, 1);
+ }
+ /* 1 bit - quarter pixel = 0 */
+ vol.PutBits(0, 1);
+ /* 1 bit - complexity estimation disable = 1 */
+ vol.PutBits(1, 1);
+ /* 1 bit - resync marker disable = 1 */
+ vol.PutBits(1, 1);
+ /* 1 bit - data partitioned = 0 */
+ vol.PutBits(0, 1);
+ /* 1 bit - newpred = 0 */
+ vol.PutBits(0, 1);
+ /* 1 bit - reduced resolution vop = 0 */
+ vol.PutBits(0, 1);
+ /* 1 bit - scalability = 0 */
+ vol.PutBits(0, 1);
+
+ /* pad to byte boundary with 0 then as many 1's as needed */
+ vol.PutBits(0, 1);
+ if ((vol.GetBitPosition() & 7) != 0) {+ vol.PutBits(0xFF, 8 - (vol.GetBitPosition() & 7));
+ }
+
+ *ppBytes = vol.GetBuffer();
+ *pNumBytes = vol.GetBitPosition() >> 3;
+ }
+ catch (int e) {+ return false;
+ }
+
+ return true;
+}
+
+extern "C" bool MP4AV_Mpeg4ParseGov(
+ u_int8_t* pGovBuf,
+ u_int32_t govSize,
+ u_int8_t* pHours,
+ u_int8_t* pMinutes,
+ u_int8_t* pSeconds)
+{+ CMemoryBitstream gov;
+
+ gov.SetBytes(pGovBuf, govSize);
+
+ try {+ gov.SkipBits(32); // start code
+ *pHours = gov.GetBits(5);
+ *pMinutes = gov.GetBits(6);
+ gov.SkipBits(1); // marker bit
+ *pSeconds = gov.GetBits(6);
+ }
+ catch (int e) {+ return false;
+ }
+
+ return true;
+}
+
+static bool Mpeg4ParseShortHeaderVop(
+ u_int8_t* pVopBuf,
+ u_int32_t vopSize,
+ u_char* pVopType)
+{+ CMemoryBitstream vop;
+
+ vop.SetBytes(pVopBuf, vopSize);
+
+ try {+ // skip start code, temporal ref, and into type
+ vop.SkipBits(22 + 8 + 5 + 3);
+ if (vop.GetBits(1) == 0) {+ *pVopType = 'I';
+ } else {+ *pVopType = 'P';
+ }
+ }
+ catch (int e) {+ return false;
+ }
+
+ return true;
+}
+
+extern "C" bool MP4AV_Mpeg4ParseVop(
+ u_int8_t* pVopBuf,
+ u_int32_t vopSize,
+ u_char* pVopType,
+ u_int8_t timeBits,
+ u_int16_t timeTicks,
+ u_int32_t* pVopTimeIncrement)
+{+ CMemoryBitstream vop;
+
+ vop.SetBytes(pVopBuf, vopSize);
+
+ try {+ vop.SkipBits(32); // skip start code
+
+ switch (vop.GetBits(2)) {+ case 0:
+ /* Intra */
+ *pVopType = 'I';
+ break;
+ case 1:
+ /* Predictive */
+ *pVopType = 'P';
+ break;
+ case 2:
+ /* Bidirectional Predictive */
+ *pVopType = 'B';
+ break;
+ case 3:
+ /* Sprite */
+ *pVopType = 'S';
+ break;
+ }
+
+ if (!pVopTimeIncrement) {+ return true;
+ }
+
+ u_int8_t numSecs = 0;
+ while (vop.GetBits(1) != 0) {+ numSecs++;
+ }
+ vop.SkipBits(1); // skip marker
+ u_int16_t numTicks = vop.GetBits(timeBits);
+ *pVopTimeIncrement = (numSecs * timeTicks) + numTicks;
+ }
+ catch (int e) {+ return false;
+ }
+
+ return true;
+}
+
+// Map from ISO IEC 14496-2:2000 Appendix G
+// to ISO IEC 14496-1:2001 8.6.4.2 Table 6
+extern "C" u_int8_t
+MP4AV_Mpeg4VideoToSystemsProfileLevel(u_int8_t videoProfileLevel)
+{+ switch (videoProfileLevel) {+ // Simple Profile
+ case 0x01: // L1
+ return 0x03;
+ case 0x02: // L2
+ return 0x02;
+ case 0x03: // L3
+ return 0x01;
+ // Simple Scalable Profile
+ case 0x11: // L1
+ return 0x05;
+ case 0x12: // L2
+ return 0x04;
+ // Core Profile
+ case 0x21: // L1
+ return 0x07;
+ case 0x22: // L2
+ return 0x06;
+ // Main Profile
+ case 0x32: // L2
+ return 0x0A;
+ case 0x33: // L3
+ return 0x09;
+ case 0x34: // L4
+ return 0x08;
+ // N-bit Profile
+ case 0x42: // L2
+ return 0x0B;
+ // Scalable Texture
+ case 0x51: // L1
+ return 0x12;
+ case 0x52: // L2
+ return 0x11;
+ case 0x53: // L3
+ return 0x10;
+ // Simple Face Animation Profile
+ case 0x61: // L1
+ return 0x14;
+ case 0x62: // L2
+ return 0x13;
+ // Simple FBA Profile
+ case 0x63: // L1
+ case 0x64: // L2
+ return 0xFE;
+ // Basic Animated Texture Profile
+ case 0x71: // L1
+ return 0x0F;
+ case 0x72: // L2
+ return 0x0E;
+ // Hybrid Profile
+ case 0x81: // L1
+ return 0x0D;
+ case 0x82: // L2
+ return 0x0C;
+ // Advanced Real Time Simple Profile
+ case 0x91: // L1
+ case 0x92: // L2
+ case 0x93: // L3
+ case 0x94: // L4
+ // Core Scalable Profile
+ case 0xA1: // L1
+ case 0xA2: // L2
+ case 0xA3: // L3
+ // Advanced Coding Efficiency Profle
+ case 0xB1: // L1
+ case 0xB2: // L2
+ case 0xB3: // L3
+ case 0xB4: // L4
+ // Advanced Core Profile
+ case 0xC1: // L1
+ case 0xC2: // L2
+ // Advanced Scalable Texture Profile
+ case 0xD1: // L1
+ case 0xD2: // L2
+ case 0xD3: // L3
+ // from draft amendments
+ // Simple Studio
+ case 0xE1: // L1
+ case 0xE2: // L2
+ case 0xE3: // L3
+ case 0xE4: // L4
+ // Core Studio Profile
+ case 0xE5: // L1
+ case 0xE6: // L2
+ case 0xE7: // L3
+ case 0xE8: // L4
+ // Advanced Simple Profile
+ case 0xF1: // L0
+ case 0xF2: // L1
+ case 0xF3: // L2
+ case 0xF4: // L3
+ case 0xF5: // L4
+ // Fine Granularity Scalable Profile
+ case 0xF6: // L0
+ case 0xF7: // L1
+ case 0xF8: // L2
+ case 0xF9: // L3
+ case 0xFA: // L4
+ default:
+ return 0xFE;
+ }
+}
+
+extern "C" u_char MP4AV_Mpeg4GetVopType(u_int8_t* pVopBuf, u_int32_t vopSize)
+{+ u_char vopType = 0;
+
+ if (vopSize <= 4) {+ return vopType;
+ }
+
+ if (pVopBuf[0] == 0 && pVopBuf[1] == 0
+ && (pVopBuf[2] & 0xFC) == 0x08 && (pVopBuf[3] & 0x03) == 0x02) {+ // H.263, (MPEG-4 short header mode)
+ Mpeg4ParseShortHeaderVop(pVopBuf, vopSize, &vopType);
+
+ } else {+ // MPEG-4 (normal mode)
+ MP4AV_Mpeg4ParseVop(pVopBuf, vopSize, &vopType, 0, 0, NULL);
+ }
+
+ return vopType;
+}
+
--- /dev/null
+++ b/common/mp4av/rfc2250.cpp
@@ -1,0 +1,165 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+/*
+ * Notes:
+ * - file formatted with tabstops == 4 spaces
+ */
+
+#include <mp4av_common.h>
+
+extern "C" bool MP4AV_Rfc2250Hinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ bool interleave,
+ u_int16_t maxPayloadSize)
+{+ // RFC 2250 doesn't support interleaving
+ if (interleave) {+ return false;
+ }
+
+ u_int32_t numSamples =
+ MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
+
+ if (numSamples == 0) {+ return false;
+ }
+
+ u_int8_t audioType =
+ MP4GetTrackAudioType(mp4File, mediaTrackId);
+
+ if (!MP4_IS_MP3_AUDIO_TYPE(audioType)) {+ return false;
+ }
+
+ MP4Duration sampleDuration =
+ MP4AV_GetAudioSampleDuration(mp4File, mediaTrackId);
+
+ if (sampleDuration == MP4_INVALID_DURATION) {+ return false;
+ }
+
+ MP4TrackId hintTrackId =
+ MP4AddHintTrack(mp4File, mediaTrackId);
+
+ if (hintTrackId == MP4_INVALID_TRACK_ID) {+ return false;
+ }
+
+ u_int8_t payloadNumber = 0; // use dynamic payload number
+
+ if (MP4GetTrackTimeScale(mp4File, mediaTrackId) == 90000) {+ payloadNumber = 14;
+ }
+
+ MP4SetHintTrackRtpPayload(mp4File, hintTrackId,
+ "MPA", &payloadNumber, 0);
+
+ u_int16_t bytesThisHint = 0;
+ u_int16_t samplesThisHint = 0;
+
+ MP4AddRtpHint(mp4File, hintTrackId);
+ MP4AddRtpPacket(mp4File, hintTrackId, true);
+
+ for (MP4SampleId sampleId = 1; sampleId <= numSamples; sampleId++) {+ u_int32_t sampleSize =
+ MP4GetSampleSize(mp4File, mediaTrackId, sampleId);
+
+ if (samplesThisHint > 0) {+ if (bytesThisHint + sampleSize <= maxPayloadSize) {+ // add the mp3 frame to current hint
+ MP4AddRtpSampleData(mp4File, hintTrackId,
+ sampleId, 0, sampleSize);
+
+ samplesThisHint++;
+ bytesThisHint += sampleSize;
+ continue;
+ } else {+ // write out current hint
+ MP4WriteRtpHint(mp4File, hintTrackId,
+ samplesThisHint * sampleDuration);
+
+ // start a new hint
+ samplesThisHint = 0;
+ bytesThisHint = 0;
+
+ MP4AddRtpHint(mp4File, hintTrackId);
+ MP4AddRtpPacket(mp4File, hintTrackId, true);
+
+ // fall thru
+ }
+ }
+
+ if (sampleSize + 4 <= maxPayloadSize) {+ // add rfc 2250 payload header
+ static u_int32_t zero32 = 0;
+
+ MP4AddRtpImmediateData(mp4File, hintTrackId,
+ (u_int8_t*)&zero32, sizeof(zero32));
+
+ // add the mp3 frame to current hint
+ MP4AddRtpSampleData(mp4File, hintTrackId,
+ sampleId, 0, sampleSize);
+
+ bytesThisHint += (4 + sampleSize);
+ } else {+ // jumbo frame, need to fragment it
+ u_int16_t sampleOffset = 0;
+
+ while (sampleOffset < sampleSize) {+ u_int16_t fragLength =
+ MIN(sampleSize - sampleOffset, maxPayloadSize) - 4;
+
+ u_int8_t payloadHeader[4];
+ payloadHeader[0] = payloadHeader[1] = 0;
+ payloadHeader[2] = (sampleOffset >> 8);
+ payloadHeader[3] = sampleOffset & 0xFF;
+
+ MP4AddRtpImmediateData(mp4File, hintTrackId,
+ (u_int8_t*)&payloadHeader, sizeof(payloadHeader));
+
+ MP4AddRtpSampleData(mp4File, hintTrackId,
+ sampleId, sampleOffset, fragLength);
+
+ sampleOffset += fragLength;
+
+ // if we're not at the last fragment
+ if (sampleOffset < sampleSize) {+ MP4AddRtpPacket(mp4File, hintTrackId, false);
+ }
+ }
+
+ // lie to ourselves so as to force next frame to output
+ // our hint as is, and start a new hint for itself
+ bytesThisHint = maxPayloadSize;
+ }
+
+ samplesThisHint = 1;
+ }
+
+ // write out current (final) hint
+ MP4WriteRtpHint(mp4File, hintTrackId,
+ samplesThisHint * sampleDuration);
+
+ return true;
+}
+
--- /dev/null
+++ b/common/mp4av/rfc3016.cpp
@@ -1,0 +1,167 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+/*
+ * Notes:
+ * - file formatted with tabstops == 4 spaces
+ */
+
+#include <mp4av_common.h>
+#include <mp4av_mpeg4.h>
+
+extern "C" bool MP4AV_Rfc3016Hinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ u_int16_t maxPayloadSize)
+{+ u_int32_t numSamples = MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
+ u_int32_t maxSampleSize = MP4GetTrackMaxSampleSize(mp4File, mediaTrackId);
+
+ if (numSamples == 0 || maxSampleSize == 0) {+ return false;
+ }
+
+ MP4TrackId hintTrackId =
+ MP4AddHintTrack(mp4File, mediaTrackId);
+
+ if (hintTrackId == MP4_INVALID_TRACK_ID) {+ return false;
+ }
+
+ u_int8_t payloadNumber = 0;
+
+ MP4SetHintTrackRtpPayload(mp4File, hintTrackId,
+ "MP4V-ES", &payloadNumber, 0);
+
+ /* get the mpeg4 video configuration */
+ u_int8_t* pConfig;
+ u_int32_t configSize;
+ u_int8_t systemsProfileLevel = 0xFE;
+
+ MP4GetTrackESConfiguration(mp4File, mediaTrackId, &pConfig, &configSize);
+
+ if (pConfig) {+ // attempt to get a valid profile-level
+ static u_int8_t voshStartCode[4] = { + 0x00, 0x00, 0x01, MP4AV_MPEG4_VOSH_START
+ };
+ if (configSize >= 5 && !memcmp(pConfig, voshStartCode, 4)) {+ systemsProfileLevel =
+ MP4AV_Mpeg4VideoToSystemsProfileLevel(pConfig[4]);
+ }
+ if (systemsProfileLevel == 0xFE) {+ u_int8_t iodProfileLevel = MP4GetVideoProfileLevel(mp4File);
+ if (iodProfileLevel > 0 && iodProfileLevel < 0xFE) {+ systemsProfileLevel = iodProfileLevel;
+ } else {+ systemsProfileLevel = 1;
+ }
+ }
+
+ /* convert it into ASCII form */
+ char* sConfig = MP4BinaryToBase16(pConfig, configSize);
+ if (sConfig == NULL) {+ MP4DeleteTrack(mp4File, hintTrackId);
+ return false;
+ }
+
+ /* create the appropriate SDP attribute */
+ char* sdpBuf = (char*)malloc(strlen(sConfig) + 128);
+
+ sprintf(sdpBuf,
+ "a=fmtp:%u profile-level-id=%u; config=%s;\015\012",
+ payloadNumber,
+ systemsProfileLevel,
+ sConfig);
+
+ /* add this to the track's sdp */
+ MP4AppendHintTrackSdp(mp4File, hintTrackId, sdpBuf);
+
+ free(sConfig);
+ free(sdpBuf);
+
+ }
+
+ u_int8_t* pSampleBuffer = (u_int8_t*)malloc(maxSampleSize);
+ if (pSampleBuffer == NULL) {+ MP4DeleteTrack(mp4File, hintTrackId);
+ return false;
+ }
+
+ for (MP4SampleId sampleId = 1; sampleId <= numSamples; sampleId++) {+ u_int32_t sampleSize = maxSampleSize;
+ MP4Timestamp startTime;
+ MP4Duration duration;
+ MP4Duration renderingOffset;
+ bool isSyncSample;
+
+ bool rc = MP4ReadSample(
+ mp4File, mediaTrackId, sampleId,
+ &pSampleBuffer, &sampleSize,
+ &startTime, &duration,
+ &renderingOffset, &isSyncSample);
+
+ if (!rc) {+ MP4DeleteTrack(mp4File, hintTrackId);
+ return false;
+ }
+
+ bool isBFrame =
+ (MP4AV_Mpeg4GetVopType(pSampleBuffer, sampleSize) == 'B');
+
+ MP4AddRtpVideoHint(mp4File, hintTrackId, isBFrame, renderingOffset);
+
+ if (sampleId == 1) {+ MP4AddRtpESConfigurationPacket(mp4File, hintTrackId);
+ }
+
+ u_int32_t offset = 0;
+ u_int32_t remaining = sampleSize;
+
+ // TBD should scan for resync markers (if enabled in ES config)
+ // and packetize on those boundaries
+
+ while (remaining) {+ bool isLastPacket = false;
+ u_int32_t length;
+
+ if (remaining <= maxPayloadSize) {+ length = remaining;
+ isLastPacket = true;
+ } else {+ length = maxPayloadSize;
+ }
+
+ MP4AddRtpPacket(mp4File, hintTrackId, isLastPacket);
+
+ MP4AddRtpSampleData(mp4File, hintTrackId, sampleId,
+ offset, length);
+
+ offset += length;
+ remaining -= length;
+ }
+
+ MP4WriteRtpHint(mp4File, hintTrackId, duration, isSyncSample);
+ }
+
+ return true;
+}
+
--- /dev/null
+++ b/common/mp4av/rfc3119.cpp
@@ -1,0 +1,526 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+/*
+ * Notes:
+ * - file formatted with tabstops == 4 spaces
+ */
+
+#include <mp4av_common.h>
+
+// LATER get these on the stack so library is thread-safe!
+// file globals
+static bool doInterleave;
+static u_int32_t samplesPerPacket;
+static u_int32_t samplesPerGroup;
+static MP4AV_Mp3Header* pFrameHeaders = NULL;
+static u_int16_t* pAduOffsets = NULL;
+
+static bool GetFrameInfo(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4AV_Mp3Header** ppFrameHeaders,
+ u_int16_t** ppAduOffsets)
+{+ // allocate memory to hold the frame info that we need
+ u_int32_t numSamples =
+ MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
+
+ *ppFrameHeaders =
+ (MP4AV_Mp3Header*)calloc((numSamples + 2), sizeof(u_int32_t));
+ if (*ppFrameHeaders == NULL) {+ return false;
+ }
+
+ *ppAduOffsets =
+ (u_int16_t*)calloc((numSamples + 2), sizeof(u_int16_t));
+ if (*ppAduOffsets == NULL) {+ free(*ppFrameHeaders);
+ return false;
+ }
+
+ // for each sample
+ for (MP4SampleId sampleId = 1; sampleId <= numSamples; sampleId++) { + u_int8_t* pSample = NULL;
+ u_int32_t sampleSize = 0;
+
+ // read it
+ MP4ReadSample(
+ mp4File,
+ mediaTrackId,
+ sampleId,
+ &pSample,
+ &sampleSize);
+
+ // extract the MP3 frame header
+ MP4AV_Mp3Header mp3hdr =
+ MP4AV_Mp3HeaderFromBytes(pSample);
+
+ // store what we need
+ (*ppFrameHeaders)[sampleId] = mp3hdr;
+
+ (*ppAduOffsets)[sampleId] =
+ MP4AV_Mp3GetAduOffset(pSample, sampleSize);
+
+ free(pSample);
+ }
+
+ return true;
+}
+
+static u_int16_t GetFrameHeaderSize(MP4SampleId sampleId)
+{+ return 4 + MP4AV_Mp3GetCrcSize(pFrameHeaders[sampleId])
+ + MP4AV_Mp3GetSideInfoSize(pFrameHeaders[sampleId]);
+}
+
+static u_int16_t GetFrameDataSize(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4SampleId sampleId)
+{+ return MP4GetSampleSize(mp4File, mediaTrackId, sampleId)
+ - GetFrameHeaderSize(sampleId);
+}
+
+u_int32_t MP4AV_Rfc3119GetAduSize(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4SampleId sampleId)
+{+ u_int32_t sampleSize = MP4GetSampleSize(mp4File, mediaTrackId, sampleId);
+
+ return pAduOffsets[sampleId] + sampleSize - pAduOffsets[sampleId + 1];
+}
+
+static u_int16_t GetMaxAduSize(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId)
+{+ u_int32_t numSamples =
+ MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
+
+ u_int16_t maxAduSize = 0;
+
+ for (MP4SampleId sampleId = 1; sampleId <= numSamples; sampleId++) { + u_int16_t aduSize =
+ MP4AV_Rfc3119GetAduSize(mp4File, mediaTrackId, sampleId);
+
+ if (aduSize > maxAduSize) {+ maxAduSize = aduSize;
+ }
+ }
+
+ return maxAduSize;
+}
+
+static u_int16_t GetAduDataSize(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4SampleId sampleId)
+{+ return MP4AV_Rfc3119GetAduSize(mp4File, mediaTrackId, sampleId)
+ - GetFrameHeaderSize(sampleId);
+}
+
+static void AddFrameHeader(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ MP4SampleId sampleId)
+{+ // when interleaving we replace the 11 bit mp3 frame sync
+ if (doInterleave) {+ // compute interleave index and interleave cycle from sampleId
+ u_int8_t interleaveIndex =
+ (sampleId - 1) % samplesPerGroup;
+ u_int8_t interleaveCycle =
+ ((sampleId - 1) / samplesPerGroup) & 0x7;
+
+ u_int8_t interleaveHeader[4];
+ interleaveHeader[0] =
+ interleaveIndex;
+ interleaveHeader[1] =
+ (interleaveCycle << 5) | ((pFrameHeaders[sampleId] >> 16) & 0x1F);
+ interleaveHeader[2] =
+ (pFrameHeaders[sampleId] >> 8) & 0xFF;
+ interleaveHeader[3] =
+ pFrameHeaders[sampleId] & 0xFF;
+
+ MP4AddRtpImmediateData(mp4File, hintTrackId,
+ interleaveHeader, 4);
+
+ // add crc and side info from current mp3 frame
+ MP4AddRtpSampleData(mp4File, hintTrackId,
+ sampleId, 4, GetFrameHeaderSize(sampleId) - 4);
+ } else {+ // add mp3 header, crc, and side info from current mp3 frame
+ MP4AddRtpSampleData(mp4File, hintTrackId,
+ sampleId, 0, GetFrameHeaderSize(sampleId));
+ }
+}
+
+static void CollectAduDataBlocks(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ MP4SampleId sampleId,
+ u_int8_t* pNumBlocks,
+ u_int32_t** ppOffsets,
+ u_int32_t** ppSizes)
+{+ // go back from sampleId until
+ // accumulated data bytes can fill sample's ADU
+ MP4SampleId sid = sampleId;
+ u_int8_t numBlocks = 1;
+ u_int32_t prevDataBytes = 0;
+ const u_int8_t maxBlocks = 8;
+
+ *ppOffsets = new u_int32_t[maxBlocks];
+ *ppSizes = new u_int32_t[maxBlocks];
+
+ (*ppOffsets)[0] = GetFrameHeaderSize(sampleId);
+ (*ppSizes)[0] = GetFrameDataSize(mp4File, mediaTrackId, sid);
+
+ while (true) {+ if (prevDataBytes >= pAduOffsets[sampleId]) {+ u_int32_t adjust =
+ prevDataBytes - pAduOffsets[sampleId];
+
+ (*ppOffsets)[numBlocks-1] += adjust;
+ (*ppSizes)[numBlocks-1] -= adjust;
+
+ break;
+ }
+
+ sid--;
+ numBlocks++;
+
+ if (sid == 0 || numBlocks > maxBlocks) {+ throw EIO; // media bitstream error
+ }
+
+ (*ppOffsets)[numBlocks-1] = GetFrameHeaderSize(sid);
+ (*ppSizes)[numBlocks-1] = GetFrameDataSize(mp4File, mediaTrackId, sid);
+ prevDataBytes += (*ppSizes)[numBlocks-1];
+ }
+
+ *pNumBlocks = numBlocks;
+}
+
+bool MP4AV_Rfc3119Concatenator(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ u_int8_t samplesThisHint,
+ MP4SampleId* pSampleIds,
+ MP4Duration hintDuration,
+ u_int16_t maxPayloadSize)
+{+ // handle degenerate case
+ if (samplesThisHint == 0) {+ return true;
+ }
+
+ // construct the new hint
+ MP4AddRtpHint(mp4File, hintTrackId);
+ MP4AddRtpPacket(mp4File, hintTrackId, false);
+
+ // rfc 3119 per adu payload header
+ u_int8_t payloadHeader[2];
+
+ // for each given sample
+ for (u_int8_t i = 0; i < samplesThisHint; i++) {+ MP4SampleId sampleId = pSampleIds[i];
+
+ u_int16_t aduSize =
+ MP4AV_Rfc3119GetAduSize(mp4File, mediaTrackId, sampleId);
+
+ // add the per ADU payload header
+ payloadHeader[0] = 0x40 | ((aduSize >> 8) & 0x3F);
+ payloadHeader[1] = aduSize & 0xFF;
+
+ MP4AddRtpImmediateData(mp4File, hintTrackId,
+ (u_int8_t*)&payloadHeader, sizeof(payloadHeader));
+ // add the mp3 frame header and side info
+ AddFrameHeader(mp4File, mediaTrackId, hintTrackId, sampleId);
+
+ // collect the info on the adu main data fragments
+ u_int8_t numDataBlocks;
+ u_int32_t* pDataOffsets;
+ u_int32_t* pDataSizes;
+
+ CollectAduDataBlocks(mp4File, mediaTrackId, hintTrackId, sampleId,
+ &numDataBlocks, &pDataOffsets, &pDataSizes);
+
+ // collect the needed blocks of data
+ u_int16_t dataSize = 0;
+ u_int16_t aduDataSize =
+ GetAduDataSize(mp4File, mediaTrackId, sampleId);
+
+ for (int8_t i = numDataBlocks - 1;
+ i >= 0 && dataSize < aduDataSize; i--) {+ u_int32_t blockSize = pDataSizes[i];
+
+ if ((u_int32_t)(aduDataSize - dataSize) < blockSize) {+ blockSize = (u_int32_t)(aduDataSize - dataSize);
+ }
+
+ MP4AddRtpSampleData(mp4File, hintTrackId,
+ sampleId - i, pDataOffsets[i], blockSize);
+
+ dataSize += blockSize;
+ }
+
+ delete [] pDataOffsets;
+ delete [] pDataSizes;
+ }
+
+ // write the hint
+ MP4WriteRtpHint(mp4File, hintTrackId, hintDuration);
+
+ return true;
+}
+
+bool MP4AV_Rfc3119Fragmenter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ MP4SampleId sampleId,
+ u_int32_t aduSize,
+ MP4Duration sampleDuration,
+ u_int16_t maxPayloadSize)
+{+ MP4AddRtpHint(mp4File, hintTrackId);
+ MP4AddRtpPacket(mp4File, hintTrackId, false);
+
+ // rfc 3119 payload header
+ u_int8_t payloadHeader[2];
+
+ u_int16_t payloadSize =
+ sizeof(payloadHeader) + GetFrameHeaderSize(sampleId);
+
+ // guard against ridiculous payload sizes
+ if (payloadSize > maxPayloadSize) {+ return false;
+ }
+
+ // add the per ADU fragment payload header
+ payloadHeader[0] = 0x40 | ((aduSize >> 8) & 0x3F);
+ payloadHeader[1] = aduSize & 0xFF;
+
+ MP4AddRtpImmediateData(mp4File, hintTrackId,
+ (u_int8_t*)&payloadHeader, sizeof(payloadHeader));
+
+ payloadHeader[0] |= 0x80; // mark future packets as continuations
+
+ // add the mp3 frame header and side info
+ AddFrameHeader(mp4File, mediaTrackId, hintTrackId, sampleId);
+
+ // collect the info on the adu main data fragments
+ u_int8_t numDataBlocks;
+ u_int32_t* pDataOffsets;
+ u_int32_t* pDataSizes;
+
+ CollectAduDataBlocks(mp4File, mediaTrackId, hintTrackId, sampleId,
+ &numDataBlocks, &pDataOffsets, &pDataSizes);
+
+ u_int16_t dataSize = 0;
+ u_int16_t aduDataSize =
+ GetAduDataSize(mp4File, mediaTrackId, sampleId);
+
+ // for each data block
+ for (int8_t i = numDataBlocks - 1; i >= 0 && dataSize < aduDataSize; i--) {+ u_int32_t blockSize = pDataSizes[i];
+ u_int32_t blockOffset = pDataOffsets[i];
+
+ // we may not need all of a block
+ if ((u_int32_t)(aduDataSize - dataSize) < blockSize) {+ blockSize = (u_int32_t)(aduDataSize - dataSize);
+ }
+
+ dataSize += blockSize;
+
+ // while data left in this block
+ while (blockSize > 0) {+ u_int16_t payloadRemaining = maxPayloadSize - payloadSize;
+
+ if (blockSize < payloadRemaining) {+ // the entire block fits in this packet
+ MP4AddRtpSampleData(mp4File, hintTrackId,
+ sampleId - i, blockOffset, blockSize);
+
+ payloadSize += blockSize;
+ blockSize = 0;
+
+ } else {+ // the block fills this packet
+ MP4AddRtpSampleData(mp4File, hintTrackId,
+ sampleId - i, blockOffset, payloadRemaining);
+
+ blockOffset += payloadRemaining;
+ blockSize -= payloadRemaining;
+
+ // start a new RTP packet
+ MP4AddRtpPacket(mp4File, hintTrackId, false);
+
+ // add the fragment payload header
+ MP4AddRtpImmediateData(mp4File, hintTrackId,
+ (u_int8_t*)&payloadHeader, sizeof(payloadHeader));
+
+ payloadSize = sizeof(payloadHeader);
+ }
+ }
+ }
+
+ // write the hint
+ MP4WriteRtpHint(mp4File, hintTrackId, sampleDuration);
+
+ // cleanup
+ delete [] pDataOffsets;
+ delete [] pDataSizes;
+
+ return true;
+}
+
+extern "C" bool MP4AV_Rfc3119Hinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ bool interleave,
+ u_int16_t maxPayloadSize)
+{+ int rc;
+
+ u_int32_t numSamples =
+ MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
+
+ if (numSamples == 0) {+ return false;
+ }
+
+ u_int8_t audioType =
+ MP4GetTrackAudioType(mp4File, mediaTrackId);
+
+ if (!MP4_IS_MP3_AUDIO_TYPE(audioType)) {+ return false;
+ }
+
+ MP4Duration sampleDuration =
+ MP4AV_GetAudioSampleDuration(mp4File, mediaTrackId);
+
+ if (sampleDuration == MP4_INVALID_DURATION) {+ return false;
+ }
+
+ // choose 500 ms max latency
+ MP4Duration maxLatency =
+ MP4GetTrackTimeScale(mp4File, mediaTrackId) / 2;
+ if (maxLatency == 0) {+ return false;
+ }
+
+ MP4TrackId hintTrackId =
+ MP4AddHintTrack(mp4File, mediaTrackId);
+
+ if (hintTrackId == MP4_INVALID_TRACK_ID) {+ return false;
+ }
+
+ doInterleave = interleave;
+
+ u_int8_t payloadNumber = 0;
+
+ MP4SetHintTrackRtpPayload(mp4File, hintTrackId,
+ "mpa-robust", &payloadNumber, 0);
+
+ // load mp3 frame information into memory
+ rc = GetFrameInfo(
+ mp4File,
+ mediaTrackId,
+ &pFrameHeaders,
+ &pAduOffsets);
+
+ if (!rc) {+ MP4DeleteTrack(mp4File, hintTrackId);
+ return false;
+ }
+
+ if (doInterleave) {+ u_int32_t maxAduSize =
+ GetMaxAduSize(mp4File, mediaTrackId);
+
+ // compute how many maximum size samples would fit in a packet
+ samplesPerPacket =
+ maxPayloadSize / (maxAduSize + 2);
+
+ // can't interleave if this number is 0 or 1
+ if (samplesPerPacket < 2) {+ doInterleave = false;
+ }
+ }
+
+ if (doInterleave) {+ // initial estimate of samplesPerGroup
+ samplesPerGroup = maxLatency / sampleDuration;
+ // use that to compute an integral stride
+ u_int8_t stride = samplesPerGroup / samplesPerPacket;
+ // and then recompute samples per group to deal with rounding
+ samplesPerGroup = stride * samplesPerPacket;
+
+ rc = MP4AV_AudioInterleaveHinter(
+ mp4File,
+ mediaTrackId,
+ hintTrackId,
+ sampleDuration,
+ samplesPerGroup / samplesPerPacket, // stride
+ samplesPerPacket, // bundle
+ maxPayloadSize,
+ MP4AV_Rfc3119Concatenator);
+
+ } else {+ rc = MP4AV_AudioConsecutiveHinter(
+ mp4File,
+ mediaTrackId,
+ hintTrackId,
+ sampleDuration,
+ 0, // perPacketHeaderSize
+ 2, // perSampleHeaderSize
+ maxLatency / sampleDuration, // maxSamplesPerPacket
+ maxPayloadSize,
+ MP4AV_Rfc3119GetAduSize,
+ MP4AV_Rfc3119Concatenator,
+ MP4AV_Rfc3119Fragmenter);
+ }
+
+ // cleanup
+ free(pFrameHeaders);
+ pFrameHeaders = NULL;
+ free(pAduOffsets);
+ pAduOffsets = NULL;
+
+ if (!rc) {+ MP4DeleteTrack(mp4File, hintTrackId);
+ return false;
+ }
+
+ return true;
+}
+
--- /dev/null
+++ b/common/mp4av/rfcisma.cpp
@@ -1,0 +1,349 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is MPEG4IP.
+ *
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Dave Mackie [email protected]
+ */
+
+/*
+ * Notes:
+ * - file formatted with tabstops == 4 spaces
+ */
+
+#include <mp4av_common.h>
+
+bool MP4AV_RfcIsmaConcatenator(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ u_int8_t samplesThisHint,
+ MP4SampleId* pSampleIds,
+ MP4Duration hintDuration,
+ u_int16_t maxPayloadSize)
+{+ // handle degenerate case
+ if (samplesThisHint == 0) {+ return true;
+ }
+
+ u_int8_t auPayloadHdrSize;
+
+ // LATER would be more efficient if this were a parameter
+ u_int8_t mpeg4AudioType =
+ MP4GetTrackAudioMpeg4Type(mp4File, mediaTrackId);
+
+ if (mpeg4AudioType == MP4_MPEG4_CELP_AUDIO_TYPE) {+ auPayloadHdrSize = 1;
+ } else {+ auPayloadHdrSize = 2;
+ }
+
+ // construct the new hint
+ MP4AddRtpHint(mp4File, hintTrackId);
+ MP4AddRtpPacket(mp4File, hintTrackId, true);
+
+ u_int8_t payloadHeader[2];
+
+ u_int16_t numHdrBits = samplesThisHint * auPayloadHdrSize * 8;
+ payloadHeader[0] = numHdrBits >> 8;
+ payloadHeader[1] = numHdrBits & 0xFF;
+
+ MP4AddRtpImmediateData(mp4File, hintTrackId,
+ (u_int8_t*)&payloadHeader, sizeof(payloadHeader));
+
+ u_int8_t i;
+
+ // first the headers
+ for (i = 0; i < samplesThisHint; i++) {+ MP4SampleId sampleId = pSampleIds[i];
+
+ u_int32_t sampleSize =
+ MP4GetSampleSize(mp4File, mediaTrackId, sampleId);
+
+ if (auPayloadHdrSize == 1) {+ // AU payload header is 6 bits of size
+ // follow by 2 bits of the difference between sampleId's - 1
+ payloadHeader[0] = sampleSize << 2;
+
+ } else { // auPayloadHdrSize == 2+ // AU payload header is 13 bits of size
+ // follow by 3 bits of the difference between sampleId's - 1
+ payloadHeader[0] = sampleSize >> 5;
+ payloadHeader[1] = (sampleSize & 0x1F) << 3;
+ }
+
+ if (i > 0) {+ payloadHeader[auPayloadHdrSize - 1]
+ |= ((sampleId - pSampleIds[i-1]) - 1);
+ }
+
+ MP4AddRtpImmediateData(mp4File, hintTrackId,
+ (u_int8_t*)&payloadHeader, auPayloadHdrSize);
+ }
+
+ // then the samples
+ for (i = 0; i < samplesThisHint; i++) {+ MP4SampleId sampleId = pSampleIds[i];
+
+ u_int32_t sampleSize =
+ MP4GetSampleSize(mp4File, mediaTrackId, sampleId);
+
+ MP4AddRtpSampleData(mp4File, hintTrackId, sampleId, 0, sampleSize);
+ }
+
+ // write the hint
+ MP4WriteRtpHint(mp4File, hintTrackId, hintDuration);
+
+ return true;
+}
+
+bool MP4AV_RfcIsmaFragmenter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ MP4TrackId hintTrackId,
+ MP4SampleId sampleId,
+ u_int32_t sampleSize,
+ MP4Duration sampleDuration,
+ u_int16_t maxPayloadSize)
+{+ MP4AddRtpHint(mp4File, hintTrackId);
+
+ MP4AddRtpPacket(mp4File, hintTrackId, false);
+
+ // Note: CELP is never fragmented
+ // so we assume the two byte AAC-hbr payload header
+ u_int8_t payloadHeader[4];
+ payloadHeader[0] = 0;
+ payloadHeader[1] = 16;
+ payloadHeader[2] = sampleSize >> 5;
+ payloadHeader[3] = (sampleSize & 0x1F) << 3;
+
+ MP4AddRtpImmediateData(mp4File, hintTrackId,
+ (u_int8_t*)&payloadHeader, sizeof(payloadHeader));
+
+ u_int16_t sampleOffset = 0;
+ u_int16_t fragLength = maxPayloadSize - 4;
+
+ do {+ MP4AddRtpSampleData(mp4File, hintTrackId,
+ sampleId, sampleOffset, fragLength);
+
+ sampleOffset += fragLength;
+
+ if (sampleSize - sampleOffset > maxPayloadSize) {+ fragLength = maxPayloadSize;
+ MP4AddRtpPacket(mp4File, hintTrackId, false);
+ } else {+ fragLength = sampleSize - sampleOffset;
+ if (fragLength) {+ MP4AddRtpPacket(mp4File, hintTrackId, true);
+ }
+ }
+ } while (sampleOffset < sampleSize);
+
+ MP4WriteRtpHint(mp4File, hintTrackId, sampleDuration);
+
+ return true;
+}
+
+extern "C" bool MP4AV_RfcIsmaHinter(
+ MP4FileHandle mp4File,
+ MP4TrackId mediaTrackId,
+ bool interleave,
+ u_int16_t maxPayloadSize)
+{+ // gather information, and check for validity
+
+ u_int32_t numSamples =
+ MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
+
+ if (numSamples == 0) {+ return false;
+ }
+
+ u_int32_t timeScale =
+ MP4GetTrackTimeScale(mp4File, mediaTrackId);
+
+ if (timeScale == 0) {+ return false;
+ }
+
+ u_int8_t audioType =
+ MP4GetTrackAudioType(mp4File, mediaTrackId);
+
+ if (audioType != MP4_MPEG4_AUDIO_TYPE
+ && !MP4_IS_AAC_AUDIO_TYPE(audioType)) {+ return false;
+ }
+
+ u_int8_t mpeg4AudioType =
+ MP4GetTrackAudioMpeg4Type(mp4File, mediaTrackId);
+
+ if (audioType == MP4_MPEG4_AUDIO_TYPE) {+ // check that track contains either MPEG-4 AAC or CELP
+ if (!MP4_IS_MPEG4_AAC_AUDIO_TYPE(mpeg4AudioType)
+ && mpeg4AudioType != MP4_MPEG4_CELP_AUDIO_TYPE) {+ return false;
+ }
+ }
+
+ MP4Duration sampleDuration =
+ MP4AV_GetAudioSampleDuration(mp4File, mediaTrackId);
+
+ if (sampleDuration == MP4_INVALID_DURATION) {+ return false;
+ }
+
+ /* get the ES configuration */
+ u_int8_t* pConfig = NULL;
+ u_int32_t configSize;
+ uint8_t channels;
+
+ MP4GetTrackESConfiguration(mp4File, mediaTrackId, &pConfig, &configSize);
+
+ if (!pConfig) {+ return false;
+ }
+
+ channels = MP4AV_AacConfigGetChannels(pConfig);
+
+ /* convert ES Config into ASCII form */
+ char* sConfig =
+ MP4BinaryToBase16(pConfig, configSize);
+
+ free(pConfig);
+
+ if (!sConfig) {+ return false;
+ }
+
+ /* create the appropriate SDP attribute */
+ char* sdpBuf =
+ (char*)malloc(strlen(sConfig) + 256);
+
+ if (!sdpBuf) {+ free(sConfig);
+ return false;
+ }
+
+
+ // now add the hint track
+ MP4TrackId hintTrackId =
+ MP4AddHintTrack(mp4File, mediaTrackId);
+
+ if (hintTrackId == MP4_INVALID_TRACK_ID) {+ free(sConfig);
+ free(sdpBuf);
+ return false;
+ }
+
+ u_int8_t payloadNumber = 0;
+ char buffer[10];
+ if (channels != 1) {+ snprintf(buffer, sizeof(buffer), "%u", channels);
+ }
+ MP4SetHintTrackRtpPayload(mp4File, hintTrackId,
+ "mpeg4-generic", &payloadNumber, 0,
+ channels != 1 ? buffer : NULL);
+
+ MP4Duration maxLatency;
+
+ if (mpeg4AudioType == MP4_MPEG4_CELP_AUDIO_TYPE) {+ sprintf(sdpBuf,
+ "a=fmtp:%u "
+ "streamtype=5; profile-level-id=15; mode=CELP-vbr; config=%s; "
+ "SizeLength=6; IndexLength=2; IndexDeltaLength=2; Profile=0;"
+ "\015\012",
+ payloadNumber,
+ sConfig);
+
+ // 200 ms max latency for ISMA profile 1
+ maxLatency = timeScale / 5;
+
+ } else { // AAC+ sprintf(sdpBuf,
+ "a=fmtp:%u "
+ "streamtype=5; profile-level-id=15; mode=AAC-hbr; config=%s; "
+ "SizeLength=13; IndexLength=3; IndexDeltaLength=3; Profile=1;"
+ "\015\012",
+ payloadNumber,
+ sConfig);
+
+ // 500 ms max latency for ISMA profile 1
+ maxLatency = timeScale / 2;
+ }
+
+ /* add this to the track's sdp */
+ MP4AppendHintTrackSdp(mp4File, hintTrackId, sdpBuf);
+
+ free(sConfig);
+ free(sdpBuf);
+
+ u_int32_t samplesPerPacket = 0;
+
+ if (interleave) {+ u_int32_t maxSampleSize =
+ MP4GetTrackMaxSampleSize(mp4File, mediaTrackId);
+
+ // compute how many maximum size samples would fit in a packet
+ samplesPerPacket =
+ (maxPayloadSize - 2) / (maxSampleSize + 2);
+
+ // can't interleave if this number is 0 or 1
+ if (samplesPerPacket < 2) {+ interleave = false;
+ }
+ }
+
+ bool rc;
+
+ if (interleave) {+ u_int32_t samplesPerGroup = maxLatency / sampleDuration;
+
+ rc = MP4AV_AudioInterleaveHinter(
+ mp4File,
+ mediaTrackId,
+ hintTrackId,
+ sampleDuration,
+ samplesPerGroup / samplesPerPacket, // stride
+ samplesPerPacket, // bundle
+ maxPayloadSize,
+ MP4AV_RfcIsmaConcatenator);
+
+ } else {+ rc = MP4AV_AudioConsecutiveHinter(
+ mp4File,
+ mediaTrackId,
+ hintTrackId,
+ sampleDuration,
+ 2, // perPacketHeaderSize
+ 2, // perSampleHeaderSize
+ maxLatency / sampleDuration, // maxSamplesPerPacket
+ maxPayloadSize,
+ MP4GetSampleSize,
+ MP4AV_RfcIsmaConcatenator,
+ MP4AV_RfcIsmaFragmenter);
+ }
+
+ if (!rc) {+ MP4DeleteTrack(mp4File, hintTrackId);
+ return false;
+ }
+
+ return true;
+}
+
--- a/plugins/in_mp4/aac2mp4.c
+++ /dev/null
@@ -1,80 +1,0 @@
-/*
-** FAAD - Freeware Advanced Audio Decoder
-** Copyright (C) 2002 M. Bakker
-**
-** This program is free software; you can redistribute it and/or modify
-** it under the terms of the GNU General Public License as published by
-** the Free Software Foundation; either version 2 of the License, or
-** (at your option) any later version.
-**
-** This program is distributed in the hope that it will be useful,
-** but WITHOUT ANY WARRANTY; without even the implied warranty of
-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-** GNU General Public License for more details.
-**
-** You should have received a copy of the GNU General Public License
-** along with this program; if not, write to the Free Software
-** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-**
-** $Id: aac2mp4.c,v 1.2 2002/09/03 21:22:53 menno Exp $
-**/
-
-#include <mpeg4ip.h>
-#include <mp4.h>
-#include "mp4av.h"
-
-#include "aac2mp4.h"
-
-int covert_aac_to_mp4(char *inputFileName, char *mp4FileName)
-{- int Mp4TimeScale = 90000;
- int allMpeg4Streams = 0;
- MP4FileHandle mp4File;
- FILE* inFile;
- char *type;
- MP4TrackId createdTrackId = MP4_INVALID_TRACK_ID;
-
- mp4File = MP4Create(mp4FileName, 0, 0, 0);
- if (mp4File)
- {- MP4SetTimeScale(mp4File, Mp4TimeScale);
- } else {- return 1;
- }
-
- inFile = fopen(inputFileName, "rb");
-
- if (inFile == NULL)
- {- MP4Close(mp4File);
- return 2;
- }
-
- createdTrackId = AacCreator(mp4File, inFile);
-
- if (createdTrackId == MP4_INVALID_TRACK_ID)
- {- fclose(inFile);
- MP4Close(mp4File);
- return 3;
- }
-
- type = MP4GetTrackType(mp4File, createdTrackId);
-
- if (!strcmp(type, MP4_AUDIO_TRACK_TYPE))
- {- allMpeg4Streams &=
- (MP4GetTrackAudioType(mp4File, createdTrackId)
- == MP4_MPEG4_AUDIO_TYPE);
- }
-
- if (inFile)
- {- fclose(inFile);
- }
-
- MP4Close(mp4File);
- MP4MakeIsmaCompliant(mp4FileName, 0, allMpeg4Streams);
-
- return 0;
-}
\ No newline at end of file
--- /dev/null
+++ b/plugins/in_mp4/aac2mp4.cpp
@@ -1,0 +1,313 @@
+/*
+** FAAD - Freeware Advanced Audio Decoder
+** Copyright (C) 2002 M. Bakker
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** $Id: aac2mp4.cpp,v 1.1 2002/10/05 15:20:20 menno Exp $
+**/
+
+#include <mpeg4ip.h>
+#include <mp4.h>
+#include <mp4av.h>
+
+#include "aac2mp4.h"
+
+int covert_aac_to_mp4(char *inputFileName, char *mp4FileName)
+{+ int Mp4TimeScale = 90000;
+ int allMpeg4Streams = 0;
+ MP4FileHandle mp4File;
+ FILE* inFile;
+ const char *type;
+ MP4TrackId createdTrackId = MP4_INVALID_TRACK_ID;
+
+ mp4File = MP4Create(mp4FileName, 0, 0, 0);
+ if (mp4File)
+ {+ MP4SetTimeScale(mp4File, Mp4TimeScale);
+ } else {+ return 1;
+ }
+
+ inFile = fopen(inputFileName, "rb");
+
+ if (inFile == NULL)
+ {+ MP4Close(mp4File);
+ return 2;
+ }
+
+ createdTrackId = AacCreator(mp4File, inFile);
+
+ if (createdTrackId == MP4_INVALID_TRACK_ID)
+ {+ fclose(inFile);
+ MP4Close(mp4File);
+ return 3;
+ }
+
+ type = MP4GetTrackType(mp4File, createdTrackId);
+
+ if (!strcmp(type, MP4_AUDIO_TRACK_TYPE))
+ {+ allMpeg4Streams &=
+ (MP4GetTrackAudioType(mp4File, createdTrackId)
+ == MP4_MPEG4_AUDIO_TYPE);
+ }
+
+ if (inFile)
+ {+ fclose(inFile);
+ }
+
+ MP4Close(mp4File);
+ MP4MakeIsmaCompliant(mp4FileName, 0, allMpeg4Streams);
+
+ return 0;
+}
+
+#define ADTS_HEADER_MAX_SIZE 10 /* bytes */
+
+static u_int8_t firstHeader[ADTS_HEADER_MAX_SIZE];
+
+/*
+ * hdr must point to at least ADTS_HEADER_MAX_SIZE bytes of memory
+ */
+static bool LoadNextAdtsHeader(FILE* inFile, u_int8_t* hdr)
+{+ u_int state = 0;
+ u_int dropped = 0;
+ u_int hdrByteSize = ADTS_HEADER_MAX_SIZE;
+
+ while (1) {+ /* read a byte */
+ u_int8_t b;
+
+ if (fread(&b, 1, 1, inFile) == 0) {+ return false;
+ }
+
+ /* header is complete, return it */
+ if (state == hdrByteSize - 1) {+ hdr[state] = b;
+ if (dropped > 0) {+ fprintf(stderr, "Warning: dropped %u input bytes\n", dropped);
+ }
+ return true;
+ }
+
+ /* collect requisite number of bytes, no constraints on data */
+ if (state >= 2) {+ hdr[state++] = b;
+ } else {+ /* have first byte, check if we have 1111X00X */
+ if (state == 1) {+ if ((b & 0xF6) == 0xF0) {+ hdr[state] = b;
+ state = 2;
+ /* compute desired header size */
+ hdrByteSize = MP4AV_AdtsGetHeaderByteSize(hdr);
+ } else {+ state = 0;
+ }
+ }
+ /* initial state, looking for 11111111 */
+ if (state == 0) {+ if (b == 0xFF) {+ hdr[state] = b;
+ state = 1;
+ } else {+ /* else drop it */
+ dropped++;
+ }
+ }
+ }
+ }
+}
+
+/*
+ * Load the next frame from the file
+ * into the supplied buffer, which better be large enough!
+ *
+ * Note: Frames are padded to byte boundaries
+ */
+static bool LoadNextAacFrame(FILE* inFile, u_int8_t* pBuf, u_int32_t* pBufSize, bool stripAdts)
+{+ u_int16_t frameSize;
+ u_int16_t hdrBitSize, hdrByteSize;
+ u_int8_t hdrBuf[ADTS_HEADER_MAX_SIZE];
+
+ /* get the next AAC frame header, more or less */
+ if (!LoadNextAdtsHeader(inFile, hdrBuf)) {+ return false;
+ }
+
+ /* get frame size from header */
+ frameSize = MP4AV_AdtsGetFrameSize(hdrBuf);
+
+ /* get header size in bits and bytes from header */
+ hdrBitSize = MP4AV_AdtsGetHeaderBitSize(hdrBuf);
+ hdrByteSize = MP4AV_AdtsGetHeaderByteSize(hdrBuf);
+
+ /* adjust the frame size to what remains to be read */
+ frameSize -= hdrByteSize;
+
+ if (stripAdts) {+ if ((hdrBitSize % 8) == 0) {+ /* header is byte aligned, i.e. MPEG-2 ADTS */
+ /* read the frame data into the buffer */
+ if (fread(pBuf, 1, frameSize, inFile) != frameSize) {+ return false;
+ }
+ (*pBufSize) = frameSize;
+ } else {+ /* header is not byte aligned, i.e. MPEG-4 ADTS */
+ int i;
+ u_int8_t newByte;
+ int upShift = hdrBitSize % 8;
+ int downShift = 8 - upShift;
+
+ pBuf[0] = hdrBuf[hdrBitSize / 8] << upShift;
+
+ for (i = 0; i < frameSize; i++) {+ if (fread(&newByte, 1, 1, inFile) != 1) {+ return false;
+ }
+ pBuf[i] |= (newByte >> downShift);
+ pBuf[i+1] = (newByte << upShift);
+ }
+ (*pBufSize) = frameSize + 1;
+ }
+ } else { /* don't strip ADTS headers */+ memcpy(pBuf, hdrBuf, hdrByteSize);
+ if (fread(&pBuf[hdrByteSize], 1, frameSize, inFile) != frameSize) {+ return false;
+ }
+ }
+
+ return true;
+}
+
+static bool GetFirstHeader(FILE* inFile)
+{+ /* read file until we find an audio frame */
+ fpos_t curPos;
+
+ /* already read first header */
+ if (firstHeader[0] == 0xff) {+ return true;
+ }
+
+ /* remember where we are */
+ fgetpos(inFile, &curPos);
+
+ /* go back to start of file */
+ rewind(inFile);
+
+ if (!LoadNextAdtsHeader(inFile, firstHeader)) {+ return false;
+ }
+
+ /* reposition the file to where we were */
+ fsetpos(inFile, &curPos);
+
+ return true;
+}
+
+MP4TrackId AacCreator(MP4FileHandle mp4File, FILE* inFile)
+{+ // collect all the necessary meta information
+ u_int32_t samplesPerSecond;
+ u_int8_t mpegVersion;
+ u_int8_t profile;
+ u_int8_t channelConfig;
+
+ if (!GetFirstHeader(inFile)) {+ return MP4_INVALID_TRACK_ID;
+ }
+
+ samplesPerSecond = MP4AV_AdtsGetSamplingRate(firstHeader);
+ mpegVersion = MP4AV_AdtsGetVersion(firstHeader);
+ profile = MP4AV_AdtsGetProfile(firstHeader);
+ channelConfig = MP4AV_AdtsGetChannels(firstHeader);
+
+ u_int8_t audioType = MP4_INVALID_AUDIO_TYPE;
+ switch (mpegVersion) {+ case 0:
+ audioType = MP4_MPEG4_AUDIO_TYPE;
+ break;
+ case 1:
+ switch (profile) {+ case 0:
+ audioType = MP4_MPEG2_AAC_MAIN_AUDIO_TYPE;
+ break;
+ case 1:
+ audioType = MP4_MPEG2_AAC_LC_AUDIO_TYPE;
+ break;
+ case 2:
+ audioType = MP4_MPEG2_AAC_SSR_AUDIO_TYPE;
+ break;
+ case 3:
+ return MP4_INVALID_TRACK_ID;
+ }
+ break;
+ }
+
+ // add the new audio track
+ MP4TrackId trackId =
+ MP4AddAudioTrack(mp4File,
+ samplesPerSecond, 1024, audioType);
+
+ if (trackId == MP4_INVALID_TRACK_ID) {+ return MP4_INVALID_TRACK_ID;
+ }
+
+ if (MP4GetNumberOfTracks(mp4File, MP4_AUDIO_TRACK_TYPE) == 1) {+ MP4SetAudioProfileLevel(mp4File, 0x0F);
+ }
+
+ u_int8_t* pConfig = NULL;
+ u_int32_t configLength = 0;
+
+ MP4AV_AacGetConfiguration(
+ &pConfig,
+ &configLength,
+ profile,
+ samplesPerSecond,
+ channelConfig);
+
+ if (!MP4SetTrackESConfiguration(mp4File, trackId,
+ pConfig, configLength)) {+ MP4DeleteTrack(mp4File, trackId);
+ return MP4_INVALID_TRACK_ID;
+ }
+
+ // parse the ADTS frames, and write the MP4 samples
+ u_int8_t sampleBuffer[8 * 1024];
+ u_int32_t sampleSize = sizeof(sampleBuffer);
+ MP4SampleId sampleId = 1;
+
+ while (LoadNextAacFrame(inFile, sampleBuffer, &sampleSize, true)) {+ if (!MP4WriteSample(mp4File, trackId, sampleBuffer, sampleSize)) {+ MP4DeleteTrack(mp4File, trackId);
+ return MP4_INVALID_TRACK_ID;
+ }
+ sampleId++;
+ sampleSize = sizeof(sampleBuffer);
+ }
+
+ return trackId;
+}
--- a/plugins/in_mp4/aactrack.cpp
+++ /dev/null
@@ -1,265 +1,0 @@
-/*
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (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.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is MPEG4IP.
- *
- * The Initial Developer of the Original Code is Cisco Systems Inc.
- * Portions created by Cisco Systems Inc. are
- * Copyright (C) Cisco Systems Inc. 2000, 2001. All Rights Reserved.
- *
- * Contributor(s):
- * Dave Mackie [email protected]
- */
-
-/*
- * Notes:
- * - file formatted with tabstops == 4 spaces
- */
-
-#include <mpeg4ip.h>
-#include <mp4.h>
-#include "mp4av.h"
-
-#include "aac2mp4.h"
-
-#define ADTS_HEADER_MAX_SIZE 10 /* bytes */
-
-static u_int8_t firstHeader[ADTS_HEADER_MAX_SIZE];
-
-/*
- * hdr must point to at least ADTS_HEADER_MAX_SIZE bytes of memory
- */
-static bool LoadNextAdtsHeader(FILE* inFile, u_int8_t* hdr)
-{- u_int state = 0;
- u_int dropped = 0;
- u_int hdrByteSize = ADTS_HEADER_MAX_SIZE;
-
- while (1) {- /* read a byte */
- u_int8_t b;
-
- if (fread(&b, 1, 1, inFile) == 0) {- return false;
- }
-
- /* header is complete, return it */
- if (state == hdrByteSize - 1) {- hdr[state] = b;
- if (dropped > 0) {- fprintf(stderr, "Warning: dropped %u input bytes\n", dropped);
- }
- return true;
- }
-
- /* collect requisite number of bytes, no constraints on data */
- if (state >= 2) {- hdr[state++] = b;
- } else {- /* have first byte, check if we have 1111X00X */
- if (state == 1) {- if ((b & 0xF6) == 0xF0) {- hdr[state] = b;
- state = 2;
- /* compute desired header size */
- hdrByteSize = MP4AV_AdtsGetHeaderByteSize(hdr);
- } else {- state = 0;
- }
- }
- /* initial state, looking for 11111111 */
- if (state == 0) {- if (b == 0xFF) {- hdr[state] = b;
- state = 1;
- } else {- /* else drop it */
- dropped++;
- }
- }
- }
- }
-}
-
-/*
- * Load the next frame from the file
- * into the supplied buffer, which better be large enough!
- *
- * Note: Frames are padded to byte boundaries
- */
-static bool LoadNextAacFrame(FILE* inFile, u_int8_t* pBuf, u_int32_t* pBufSize, bool stripAdts)
-{- u_int16_t frameSize;
- u_int16_t hdrBitSize, hdrByteSize;
- u_int8_t hdrBuf[ADTS_HEADER_MAX_SIZE];
-
- /* get the next AAC frame header, more or less */
- if (!LoadNextAdtsHeader(inFile, hdrBuf)) {- return false;
- }
-
- /* get frame size from header */
- frameSize = MP4AV_AdtsGetFrameSize(hdrBuf);
-
- /* get header size in bits and bytes from header */
- hdrBitSize = MP4AV_AdtsGetHeaderBitSize(hdrBuf);
- hdrByteSize = MP4AV_AdtsGetHeaderByteSize(hdrBuf);
-
- /* adjust the frame size to what remains to be read */
- frameSize -= hdrByteSize;
-
- if (stripAdts) {- if ((hdrBitSize % 8) == 0) {- /* header is byte aligned, i.e. MPEG-2 ADTS */
- /* read the frame data into the buffer */
- if (fread(pBuf, 1, frameSize, inFile) != frameSize) {- return false;
- }
- (*pBufSize) = frameSize;
- } else {- /* header is not byte aligned, i.e. MPEG-4 ADTS */
- int i;
- u_int8_t newByte;
- int upShift = hdrBitSize % 8;
- int downShift = 8 - upShift;
-
- pBuf[0] = hdrBuf[hdrBitSize / 8] << upShift;
-
- for (i = 0; i < frameSize; i++) {- if (fread(&newByte, 1, 1, inFile) != 1) {- return false;
- }
- pBuf[i] |= (newByte >> downShift);
- pBuf[i+1] = (newByte << upShift);
- }
- (*pBufSize) = frameSize + 1;
- }
- } else { /* don't strip ADTS headers */- memcpy(pBuf, hdrBuf, hdrByteSize);
- if (fread(&pBuf[hdrByteSize], 1, frameSize, inFile) != frameSize) {- return false;
- }
- }
-
- return true;
-}
-
-static bool GetFirstHeader(FILE* inFile)
-{- /* read file until we find an audio frame */
- fpos_t curPos;
-
- /* already read first header */
- if (firstHeader[0] == 0xff) {- return true;
- }
-
- /* remember where we are */
- fgetpos(inFile, &curPos);
-
- /* go back to start of file */
- rewind(inFile);
-
- if (!LoadNextAdtsHeader(inFile, firstHeader)) {- return false;
- }
-
- /* reposition the file to where we were */
- fsetpos(inFile, &curPos);
-
- return true;
-}
-
-MP4TrackId AacCreator(MP4FileHandle mp4File, FILE* inFile)
-{- // collect all the necessary meta information
- u_int32_t samplesPerSecond;
- u_int8_t mpegVersion;
- u_int8_t profile;
- u_int8_t channelConfig;
-
- if (!GetFirstHeader(inFile)) {- return MP4_INVALID_TRACK_ID;
- }
-
- samplesPerSecond = MP4AV_AdtsGetSamplingRate(firstHeader);
- mpegVersion = MP4AV_AdtsGetVersion(firstHeader);
- profile = MP4AV_AdtsGetProfile(firstHeader);
- channelConfig = MP4AV_AdtsGetChannels(firstHeader);
-
- u_int8_t audioType = MP4_INVALID_AUDIO_TYPE;
- switch (mpegVersion) {- case 0:
- audioType = MP4_MPEG4_AUDIO_TYPE;
- break;
- case 1:
- switch (profile) {- case 0:
- audioType = MP4_MPEG2_AAC_MAIN_AUDIO_TYPE;
- break;
- case 1:
- audioType = MP4_MPEG2_AAC_LC_AUDIO_TYPE;
- break;
- case 2:
- audioType = MP4_MPEG2_AAC_SSR_AUDIO_TYPE;
- break;
- case 3:
- return MP4_INVALID_TRACK_ID;
- }
- break;
- }
-
- // add the new audio track
- MP4TrackId trackId =
- MP4AddAudioTrack(mp4File,
- samplesPerSecond, 1024, audioType);
-
- if (trackId == MP4_INVALID_TRACK_ID) {- return MP4_INVALID_TRACK_ID;
- }
-
- if (MP4GetNumberOfTracks(mp4File, MP4_AUDIO_TRACK_TYPE) == 1) {- MP4SetAudioProfileLevel(mp4File, 0x0F);
- }
-
- u_int8_t* pConfig = NULL;
- u_int32_t configLength = 0;
-
- MP4AV_AacGetConfiguration(
- &pConfig,
- &configLength,
- profile,
- samplesPerSecond,
- channelConfig);
-
- if (!MP4SetTrackESConfiguration(mp4File, trackId,
- pConfig, configLength)) {- MP4DeleteTrack(mp4File, trackId);
- return MP4_INVALID_TRACK_ID;
- }
-
- // parse the ADTS frames, and write the MP4 samples
- u_int8_t sampleBuffer[8 * 1024];
- u_int32_t sampleSize = sizeof(sampleBuffer);
- MP4SampleId sampleId = 1;
-
- while (LoadNextAacFrame(inFile, sampleBuffer, &sampleSize, true)) {- if (!MP4WriteSample(mp4File, trackId, sampleBuffer, sampleSize)) {- MP4DeleteTrack(mp4File, trackId);
- return MP4_INVALID_TRACK_ID;
- }
- sampleId++;
- sampleSize = sizeof(sampleBuffer);
- }
-
- return trackId;
-}
-
--- a/plugins/in_mp4/in_mp4.dsp
+++ b/plugins/in_mp4/in_mp4.dsp
@@ -43,7 +43,7 @@
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
-# ADD CPP /nologo /W3 /GX /O2 /I "..\..\include" /I "..\..\common\mp4v2" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\..\include" /I "..\..\common\mp4v2" /I "..\..\common\mp4av" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x413 /d "NDEBUG"
@@ -69,7 +69,7 @@
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /GZ /c
-# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\..\include" /I "..\..\common\mp4v2" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\..\include" /I "..\..\common\mp4v2" /I "..\..\common\mp4av" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x413 /d "_DEBUG"
@@ -92,7 +92,7 @@
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
-SOURCE=.\aac2mp4.c
+SOURCE=.\aac2mp4.cpp
# End Source File
# Begin Source File
@@ -100,31 +100,11 @@
# End Source File
# Begin Source File
-SOURCE=.\aactrack.cpp
-# End Source File
-# Begin Source File
-
SOURCE=.\config.c
# End Source File
# Begin Source File
SOURCE=.\in_mp4.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\mbs.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\mp4av_aac.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\mp4av_adts.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\mp4av_audio.cpp
# End Source File
# Begin Source File
--- a/plugins/in_mp4/in_mp4.dsw
+++ b/plugins/in_mp4/in_mp4.dsw
@@ -33,6 +33,18 @@
###############################################################################
+Project: "libmp4av_st"=..\..\common\mp4av\libmp4av_st.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
Project: "libmp4v2_st"=..\..\common\mp4v2\libmp4v2_st60.dsp - Package Owner=<4>
Package=<5>
--- a/plugins/in_mp4/in_mp4.sln
+++ b/plugins/in_mp4/in_mp4.sln
@@ -5,6 +5,8 @@
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libmp4v2_st", "..\..\common\mp4v2\libmp4v2_st60.vcproj", "{2398BB2F-FFF9-490B-B4CC-863F2D21AE46}"EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libmp4av_st", "..\..\common\mp4av\libmp4av_st.vcproj", "{8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}"+EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
ConfigName.0 = Debug
@@ -11,8 +13,9 @@
ConfigName.1 = Release
EndGlobalSection
GlobalSection(ProjectDependencies) = postSolution
- {2D8F479D-A591-4502-9456-398425D5F834}.0 = {2398BB2F-FFF9-490B-B4CC-863F2D21AE46}- {2D8F479D-A591-4502-9456-398425D5F834}.1 = {82CAD808-21AF-40A6-92EC-AE01AA67B413}+ {2D8F479D-A591-4502-9456-398425D5F834}.0 = {82CAD808-21AF-40A6-92EC-AE01AA67B413}+ {2D8F479D-A591-4502-9456-398425D5F834}.1 = {8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}+ {2D8F479D-A591-4502-9456-398425D5F834}.2 = {2398BB2F-FFF9-490B-B4CC-863F2D21AE46}EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{2D8F479D-A591-4502-9456-398425D5F834}.Debug.ActiveCfg = Debug|Win32@@ -27,6 +30,10 @@
{2398BB2F-FFF9-490B-B4CC-863F2D21AE46}.Debug.Build.0 = Debug|Win32 {2398BB2F-FFF9-490B-B4CC-863F2D21AE46}.Release.ActiveCfg = Release|Win32 {2398BB2F-FFF9-490B-B4CC-863F2D21AE46}.Release.Build.0 = Release|Win32+ {8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}.Debug.ActiveCfg = Debug|Win32+ {8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}.Debug.Build.0 = Debug|Win32+ {8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}.Release.ActiveCfg = Release|Win32+ {8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}.Release.Build.0 = Release|Win32EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
--- a/plugins/in_mp4/in_mp4.vcproj
+++ b/plugins/in_mp4/in_mp4.vcproj
@@ -20,7 +20,7 @@
<Tool
Name="VCCLCompilerTool"
Optimization="0"
- AdditionalIncludeDirectories="..\..\include,..\..\common\mp4v2"
+ AdditionalIncludeDirectories="..\..\include,..\..\common\mp4v2,..\..\common\mp4av"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS"
BasicRuntimeChecks="3"
RuntimeLibrary="5"
@@ -82,7 +82,7 @@
EnableIntrinsicFunctions="TRUE"
FavorSizeOrSpeed="1"
OptimizeForProcessor="2"
- AdditionalIncludeDirectories="..\..\include,..\..\common\mp4v2"
+ AdditionalIncludeDirectories="..\..\include,..\..\common\mp4v2,..\..\common\mp4av"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS"
StringPooling="TRUE"
RuntimeLibrary="4"
@@ -135,31 +135,16 @@
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
- RelativePath="aac2mp4.c">
+ RelativePath="aac2mp4.cpp">
</File>
<File
RelativePath="aacinfo.c">
</File>
<File
- RelativePath="aactrack.cpp">
- </File>
- <File
RelativePath=".\config.c">
</File>
<File
RelativePath=".\in_mp4.c">
- </File>
- <File
- RelativePath="mbs.cpp">
- </File>
- <File
- RelativePath="mp4av_aac.cpp">
- </File>
- <File
- RelativePath="mp4av_adts.cpp">
- </File>
- <File
- RelativePath="mp4av_audio.cpp">
</File>
<File
RelativePath=".\utils.c">
--- a/plugins/in_mp4/mbs.cpp
+++ /dev/null
@@ -1,93 +1,0 @@
-/*
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (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.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is MPEG4IP.
- *
- * The Initial Developer of the Original Code is Cisco Systems Inc.
- * Portions created by Cisco Systems Inc. are
- * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
- *
- * Contributor(s):
- * Dave Mackie [email protected]
- */
-
-#include "mp4av_common.h"
-
-void CMemoryBitstream::AllocBytes(u_int32_t numBytes)
-{- m_pBuf = (u_int8_t*)calloc(numBytes, 1);
- if (!m_pBuf) {- throw ENOMEM;
- }
- m_bitPos = 0;
- m_numBits = numBytes << 3;
-}
-
-void CMemoryBitstream::SetBytes(u_int8_t* pBytes, u_int32_t numBytes)
-{- m_pBuf = pBytes;
- m_bitPos = 0;
- m_numBits = numBytes << 3;
-}
-
-void CMemoryBitstream::PutBytes(u_int8_t* pBytes, u_int32_t numBytes)
-{- u_int32_t numBits = numBytes << 3;
-
- if (numBits + m_bitPos > m_numBits) {- throw EIO;
- }
-
- if ((m_bitPos & 7) == 0) {- memcpy(&m_pBuf[m_bitPos >> 3], pBytes, numBytes);
- m_bitPos += numBits;
- } else {- for (u_int32_t i = 0; i < numBytes; i++) {- PutBits(pBytes[i], 8);
- }
- }
-}
-
-void CMemoryBitstream::PutBits(u_int32_t bits, u_int32_t numBits)
-{- if (numBits + m_bitPos > m_numBits) {- throw EIO;
- }
- if (numBits > 32) {- throw EIO;
- }
-
- for (int8_t i = numBits - 1; i >= 0; i--) {- m_pBuf[m_bitPos >> 3] |= ((bits >> i) & 1) << (7 - (m_bitPos & 7));
- m_bitPos++;
- }
-}
-
-u_int32_t CMemoryBitstream::GetBits(u_int32_t numBits)
-{- if (numBits + m_bitPos > m_numBits) {- throw EIO;
- }
- if (numBits > 32) {- throw EIO;
- }
-
- u_int32_t bits = 0;
-
- for (u_int8_t i = 0; i < numBits; i++) {- bits <<= 1;
- bits |= (m_pBuf[m_bitPos >> 3] >> (7 - (m_bitPos & 7))) & 1;
- m_bitPos++;
- }
-
- return bits;
-}
-
--- a/plugins/in_mp4/mp4av.h
+++ /dev/null
@@ -1,42 +1,0 @@
-/*
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (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.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is MPEG4IP.
- *
- * The Initial Developer of the Original Code is Cisco Systems Inc.
- * Portions created by Cisco Systems Inc. are
- * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
- *
- * Contributor(s):
- * Dave Mackie [email protected]
- */
-
-#ifndef __MP4AV_INCLUDED__
-#define __MP4AV_INCLUDED__
-
-#include <mp4.h>
-
-#ifdef __cplusplus
-/* exploit C++ ability of default values for function parameters */
-#define DEFAULT_PARM(x) =x
-#else
-#define DEFAULT_PARM(x)
-#endif
-
-/* MP4AV library API */
-#include "mp4av_aac.h"
-#include "mp4av_adts.h"
-#include "mp4av_audio.h"
-
-#undef DEFAULT_PARM
-
-#endif /* __MP4AV_INCLUDED__ */
-
--- a/plugins/in_mp4/mp4av_aac.cpp
+++ /dev/null
@@ -1,133 +1,0 @@
-/*
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (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.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is MPEG4IP.
- *
- * The Initial Developer of the Original Code is Cisco Systems Inc.
- * Portions created by Cisco Systems Inc. are
- * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
- *
- * Contributor(s):
- * Dave Mackie [email protected]
- */
-
-/*
- * Notes:
- * - file formatted with tabstops == 4 spaces
- */
-
-#include "mp4av_common.h"
-
-/*
- * AAC Config in ES:
- *
- * AudioObjectType 5 bits
- * samplingFrequencyIndex 4 bits
- * if (samplingFrequencyIndex == 0xF)
- * samplingFrequency 24 bits
- * channelConfiguration 4 bits
- * GA_SpecificConfig
- * FrameLengthFlag 1 bit 1024 or 960
- * DependsOnCoreCoder 1 bit (always 0)
- * ExtensionFlag 1 bit (always 0)
- */
-
-extern "C" u_int8_t MP4AV_AacConfigGetSamplingRateIndex(u_int8_t* pConfig)
-{- return ((pConfig[0] << 1) | (pConfig[1] >> 7)) & 0xF;
-}
-
-extern "C" u_int32_t MP4AV_AacConfigGetSamplingRate(u_int8_t* pConfig)
-{- u_int8_t index =
- MP4AV_AacConfigGetSamplingRateIndex(pConfig);
-
- if (index == 0xF) {- return (pConfig[1] & 0x7F) << 17
- | pConfig[2] << 9
- | pConfig[3] << 1
- | (pConfig[4] >> 7);
- }
- return AdtsSamplingRates[index];
-}
-
-extern "C" u_int16_t MP4AV_AacConfigGetSamplingWindow(u_int8_t* pConfig)
-{- u_int8_t adjust = 0;
-
- if (MP4AV_AacConfigGetSamplingRateIndex(pConfig) == 0xF) {- adjust = 3;
- }
-
- if ((pConfig[1 + adjust] >> 2) & 0x1) {- return 960;
- }
- return 1024;
-}
-
-extern "C" u_int8_t MP4AV_AacConfigGetChannels(u_int8_t* pConfig)
-{- u_int8_t adjust = 0;
-
- if (MP4AV_AacConfigGetSamplingRateIndex(pConfig) == 0xF) {- adjust = 3;
- }
- return (pConfig[1 + adjust] >> 3) & 0xF;
-}
-
-extern "C" bool MP4AV_AacGetConfigurationFromAdts(
- u_int8_t** ppConfig,
- u_int32_t* pConfigLength,
- u_int8_t* pHdr)
-{- return MP4AV_AacGetConfiguration(
- ppConfig,
- pConfigLength,
- MP4AV_AdtsGetProfile(pHdr),
- MP4AV_AdtsGetSamplingRate(pHdr),
- MP4AV_AdtsGetChannels(pHdr));
-}
-
-extern "C" bool MP4AV_AacGetConfiguration(
- u_int8_t** ppConfig,
- u_int32_t* pConfigLength,
- u_int8_t profile,
- u_int32_t samplingRate,
- u_int8_t channels)
-{- /* create the appropriate decoder config */
-
- u_int8_t* pConfig = (u_int8_t*)malloc(2);
-
- if (pConfig == NULL) {- return false;
- }
-
- u_int8_t samplingRateIndex =
- MP4AV_AdtsFindSamplingRateIndex(samplingRate);
-
- pConfig[0] =
- ((profile + 1) << 3) | ((samplingRateIndex & 0xe) >> 1);
- pConfig[1] =
- ((samplingRateIndex & 0x1) << 7) | (channels << 3);
-
- /* LATER this option is not currently used in MPEG4IP
- if (samplesPerFrame == 960) {- pConfig[1] |= (1 << 2);
- }
- */
-
- *ppConfig = pConfig;
- *pConfigLength = 2;
-
- return true;
-}
-
--- a/plugins/in_mp4/mp4av_aac.h
+++ /dev/null
@@ -1,61 +1,0 @@
-/*
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (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.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is MPEG4IP.
- *
- * The Initial Developer of the Original Code is Cisco Systems Inc.
- * Portions created by Cisco Systems Inc. are
- * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
- *
- * Contributor(s):
- * Dave Mackie [email protected]
- */
-
-#ifndef __MP4AV_AAC_INCLUDED__
-#define __MP4AV_AAC_INCLUDED__
-
-#define MP4AV_AAC_MAIN_PROFILE 0
-#define MP4AV_AAC_LC_PROFILE 1
-#define MP4AV_AAC_SSR_PROFILE 2
-#define MP4AV_AAC_LTP_PROFILE 3
-
-#ifdef __cplusplus
-extern "C" {-#endif
-
-u_int8_t MP4AV_AacConfigGetSamplingRateIndex(
- u_int8_t* pConfig);
-
-u_int32_t MP4AV_AacConfigGetSamplingRate(
- u_int8_t* pConfig);
-
-u_int16_t MP4AV_AacConfigGetSamplingWindow(
- u_int8_t* pConfig);
-
-u_int8_t MP4AV_AacConfigGetChannels(
- u_int8_t* pConfig);
-
-bool MP4AV_AacGetConfigurationFromAdts(
- u_int8_t** ppConfig,
- u_int32_t* pConfigLength,
- u_int8_t* pAdtsHdr);
-
-bool MP4AV_AacGetConfiguration(
- u_int8_t** ppConfig,
- u_int32_t* pConfigLength,
- u_int8_t profile,
- u_int32_t samplingRate,
- u_int8_t channels);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* __MP4AV_AAC_INCLUDED__ */
--- a/plugins/in_mp4/mp4av_adts.cpp
+++ /dev/null
@@ -1,271 +1,0 @@
-/*
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (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.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is MPEG4IP.
- *
- * The Initial Developer of the Original Code is Cisco Systems Inc.
- * Portions created by Cisco Systems Inc. are
- * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
- *
- * Contributor(s):
- * Dave Mackie [email protected]
- */
-
-/*
- * Notes:
- * - file formatted with tabstops == 4 spaces
- */
-
-#include "mp4av_common.h"
-
-/*
- * ADTS Header:
- * MPEG-2 version 56 bits (byte aligned)
- * MPEG-4 version 58 bits (not byte aligned)
- *
- * syncword 12 bits
- * id 1 bit
- * layer 2 bits
- * protection_absent 1 bit
- * profile 2 bits
- * sampling_frequency_index 4 bits
- * private 1 bit
- * channel_configuraton 3 bits
- * original 1 bit
- * home 1 bit
- * emphasis 2 bits
- * copyright_id 1 bit
- * copyright_id_start 1 bit
- * aac_frame_length 13 bits
- * adts_buffer_fullness 11 bits
- * num_raw_data_blocks 2 bits
- *
- * if (protection_absent == 0)
- * crc_check 16 bits
- */
-
-u_int32_t AdtsSamplingRates[NUM_ADTS_SAMPLING_RATES] = {- 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
- 16000, 12000, 11025, 8000, 7350, 0, 0, 0
-};
-
-/*
- * compute ADTS frame size
- */
-extern "C" u_int16_t MP4AV_AdtsGetFrameSize(u_int8_t* pHdr)
-{- /* extract the necessary fields from the header */
- u_int8_t isMpeg4 = !(pHdr[1] & 0x08);
- u_int16_t frameLength;
-
- if (isMpeg4) {- frameLength = (((u_int16_t)pHdr[4]) << 5) | (pHdr[5] >> 3);
- } else { /* MPEG-2 */- frameLength = (((u_int16_t)(pHdr[3] & 0x3)) << 11)
- | (((u_int16_t)pHdr[4]) << 3) | (pHdr[5] >> 5);
- }
- return frameLength;
-}
-
-/*
- * Compute length of ADTS header in bits
- */
-extern "C" u_int16_t MP4AV_AdtsGetHeaderBitSize(u_int8_t* pHdr)
-{- u_int8_t isMpeg4 = !(pHdr[1] & 0x08);
- u_int8_t hasCrc = !(pHdr[1] & 0x01);
- u_int16_t hdrSize;
-
- if (isMpeg4) {- hdrSize = 58;
- } else {- hdrSize = 56;
- }
- if (hasCrc) {- hdrSize += 16;
- }
- return hdrSize;
-}
-
-extern "C" u_int16_t MP4AV_AdtsGetHeaderByteSize(u_int8_t* pHdr)
-{- return (MP4AV_AdtsGetHeaderBitSize(pHdr) + 7) / 8;
-}
-
-extern "C" u_int8_t MP4AV_AdtsGetVersion(u_int8_t* pHdr)
-{- return (pHdr[1] & 0x08) >> 3;
-}
-
-extern "C" u_int8_t MP4AV_AdtsGetProfile(u_int8_t* pHdr)
-{- return (pHdr[2] & 0xc0) >> 6;
-}
-
-extern "C" u_int8_t MP4AV_AdtsGetSamplingRateIndex(u_int8_t* pHdr)
-{- return (pHdr[2] & 0x3c) >> 2;
-}
-
-extern "C" u_int8_t MP4AV_AdtsFindSamplingRateIndex(u_int32_t samplingRate)
-{- for (u_int8_t i = 0; i < NUM_ADTS_SAMPLING_RATES; i++) {- if (samplingRate == AdtsSamplingRates[i]) {- return i;
- }
- }
- return NUM_ADTS_SAMPLING_RATES - 1;
-}
-
-extern "C" u_int32_t MP4AV_AdtsGetSamplingRate(u_int8_t* pHdr)
-{- return AdtsSamplingRates[MP4AV_AdtsGetSamplingRateIndex(pHdr)];
-}
-
-extern "C" u_int8_t MP4AV_AdtsGetChannels(u_int8_t* pHdr)
-{- return ((pHdr[2] & 0x1) << 2) | ((pHdr[3] & 0xc0) >> 6);
-}
-
-extern "C" bool MP4AV_AdtsMakeFrameFromMp4Sample(
- MP4FileHandle mp4File,
- MP4TrackId trackId,
- MP4SampleId sampleId,
- u_int8_t** ppAdtsData,
- u_int32_t* pAdtsDataLength)
-{- static MP4FileHandle lastMp4File = MP4_INVALID_FILE_HANDLE;
- static MP4TrackId lastMp4TrackId = MP4_INVALID_TRACK_ID;
- static bool isMpeg2;
- static u_int8_t profile;
- static u_int32_t samplingFrequency;
- static u_int8_t channels;
-
- if (mp4File != lastMp4File || trackId != lastMp4TrackId) {-
- // changed cached file and track info
-
- lastMp4File = mp4File;
- lastMp4TrackId = trackId;
-
- u_int8_t audioType = MP4GetTrackAudioType(mp4File, trackId);
-
- if (MP4_IS_MPEG2_AAC_AUDIO_TYPE(audioType)) {- isMpeg2 = true;
- profile = audioType - MP4_MPEG2_AAC_MAIN_AUDIO_TYPE;
- } else if (audioType == MP4_MPEG4_AUDIO_TYPE) {- isMpeg2 = false;
- profile = MP4GetTrackAudioMpeg4Type(mp4File, trackId) - 1;
- } else {- lastMp4File = MP4_INVALID_FILE_HANDLE;
- lastMp4TrackId = MP4_INVALID_TRACK_ID;
- return false;
- }
-
- u_int8_t* pConfig = NULL;
- u_int32_t configLength;
-
- MP4GetTrackESConfiguration(
- mp4File,
- trackId,
- &pConfig,
- &configLength);
-
- if (pConfig == NULL || configLength < 2) {- lastMp4File = MP4_INVALID_FILE_HANDLE;
- lastMp4TrackId = MP4_INVALID_TRACK_ID;
- return false;
- }
-
- samplingFrequency = MP4AV_AacConfigGetSamplingRate(pConfig);
-
- channels = MP4AV_AacConfigGetChannels(pConfig);
-
- }
-
- bool rc;
- u_int8_t* pSample = NULL;
- u_int32_t sampleSize = 0;
-
- rc = MP4ReadSample(
- mp4File,
- trackId,
- sampleId,
- &pSample,
- &sampleSize);
-
- if (!rc) {- return false;
- }
-
- rc = MP4AV_AdtsMakeFrame(
- pSample,
- sampleSize,
- isMpeg2,
- profile,
- samplingFrequency,
- channels,
- ppAdtsData,
- pAdtsDataLength);
-
- free(pSample);
-
- return rc;
-}
-
-extern "C" bool MP4AV_AdtsMakeFrame(
- u_int8_t* pData,
- u_int16_t dataLength,
- bool isMpeg2,
- u_int8_t profile,
- u_int32_t samplingFrequency,
- u_int8_t channels,
- u_int8_t** ppAdtsData,
- u_int32_t* pAdtsDataLength)
-{- *pAdtsDataLength = (isMpeg2 ? 7 : 8) + dataLength;
-
- CMemoryBitstream adts;
-
- try {- adts.AllocBytes(*pAdtsDataLength);
- *ppAdtsData = adts.GetBuffer();
-
- // build adts header
- adts.PutBits(0xFFF, 12); // syncword
- adts.PutBits(isMpeg2, 1); // id
- adts.PutBits(0, 2); // layer
- adts.PutBits(1, 1); // protection_absent
- adts.PutBits(profile, 2); // profile
- adts.PutBits(
- MP4AV_AdtsFindSamplingRateIndex(samplingFrequency),
- 4); // sampling_frequency_index
- adts.PutBits(0, 1); // private
- adts.PutBits(channels, 3); // channel_configuration
- adts.PutBits(0, 1); // original
- adts.PutBits(0, 1); // home
- adts.PutBits(0, 2); // emphasis
- adts.PutBits(0, 1); // copyright_id
- adts.PutBits(0, 1); // copyright_id_start
- adts.PutBits(*pAdtsDataLength, 13); // aac_frame_length
- adts.PutBits(0x7FF, 11); // adts_buffer_fullness
- adts.PutBits(1, 2); // num_raw_data_blocks
-
- // copy audio frame data
- adts.PutBytes(pData, dataLength);
- }
- catch (int e) {- return false;
- }
-
- return true;
-}
-
--- a/plugins/in_mp4/mp4av_adts.h
+++ /dev/null
@@ -1,86 +1,0 @@
-/*
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (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.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is MPEG4IP.
- *
- * The Initial Developer of the Original Code is Cisco Systems Inc.
- * Portions created by Cisco Systems Inc. are
- * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
- *
- * Contributor(s):
- * Dave Mackie [email protected]
- */
-
-#ifndef __MP4AV_ADTS_INCLUDED__
-#define __MP4AV_ADTS_INCLUDED__
-
-#ifdef __cplusplus
-extern "C" {-#endif
-
-#define NUM_ADTS_SAMPLING_RATES 16
-
-extern u_int32_t AdtsSamplingRates[NUM_ADTS_SAMPLING_RATES];
-
-bool MP4AV_AdtsGetNextFrame(
- u_int8_t* pSrc,
- u_int32_t srcLength,
- u_int8_t** ppFrame,
- u_int32_t* pFrameSize);
-
-u_int16_t MP4AV_AdtsGetFrameSize(
- u_int8_t* pHdr);
-
-u_int16_t MP4AV_AdtsGetHeaderBitSize(
- u_int8_t* pHdr);
-
-u_int16_t MP4AV_AdtsGetHeaderByteSize(
- u_int8_t* pHdr);
-
-u_int8_t MP4AV_AdtsGetVersion(
- u_int8_t* pHdr);
-
-u_int8_t MP4AV_AdtsGetProfile(
- u_int8_t* pHdr);
-
-u_int8_t MP4AV_AdtsGetSamplingRateIndex(
- u_int8_t* pHdr);
-
-u_int8_t MP4AV_AdtsFindSamplingRateIndex(
- u_int32_t samplingRate);
-
-u_int32_t MP4AV_AdtsGetSamplingRate(
- u_int8_t* pHdr);
-
-u_int8_t MP4AV_AdtsGetChannels(
- u_int8_t* pHdr);
-
-bool MP4AV_AdtsMakeFrame(
- u_int8_t* pData,
- u_int16_t dataLength,
- bool isMpeg2,
- u_int8_t profile,
- u_int32_t samplingFrequency,
- u_int8_t channels,
- u_int8_t** ppAdtsData,
- u_int32_t* pAdtsDataLength);
-
-bool MP4AV_AdtsMakeFrameFromMp4Sample(
- MP4FileHandle mp4File,
- MP4TrackId trackId,
- MP4SampleId sampleId,
- u_int8_t** ppAdtsData,
- u_int32_t* pAdtsDataLength);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* __MP4AV_ADTS_INCLUDED__ */
--- a/plugins/in_mp4/mp4av_audio.cpp
+++ /dev/null
@@ -1,166 +1,0 @@
-/*
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (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.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is MPEG4IP.
- *
- * The Initial Developer of the Original Code is Cisco Systems Inc.
- * Portions created by Cisco Systems Inc. are
- * Copyright (C) Cisco Systems Inc. 2000-2002. All Rights Reserved.
- *
- * Contributor(s):
- * Dave Mackie [email protected]
- */
-
-/*
- * Notes:
- * - file formatted with tabstops == 4 spaces
- */
-
-#include "mp4av_common.h"
-
-extern "C" u_int8_t MP4AV_AudioGetChannels(
- MP4FileHandle mp4File,
- MP4TrackId audioTrackId)
-{- u_int8_t audioType =
- MP4GetTrackAudioType(mp4File, audioTrackId);
-
- if (audioType == MP4_INVALID_AUDIO_TYPE) {- return 0;
- }
-
- if (MP4_IS_MP3_AUDIO_TYPE(audioType)) {- return 0;
- } else if (MP4_IS_AAC_AUDIO_TYPE(audioType)) {- u_int8_t* pAacConfig = NULL;
- u_int32_t aacConfigLength;
-
- MP4GetTrackESConfiguration(
- mp4File,
- audioTrackId,
- &pAacConfig,
- &aacConfigLength);
-
- if (pAacConfig == NULL || aacConfigLength < 2) {- return 0;
- }
-
- u_int8_t channels =
- MP4AV_AacConfigGetChannels(pAacConfig);
-
- free(pAacConfig);
-
- return channels;
-
- } else if (audioType == MP4_PCM16_AUDIO_TYPE) {- u_int32_t samplesPerFrame =
- MP4GetSampleSize(mp4File, audioTrackId, 1) / 2;
-
- MP4Duration frameDuration =
- MP4GetSampleDuration(mp4File, audioTrackId, 1);
-
- if (frameDuration == 0) {- return 0;
- }
-
- // assumes track time scale == sampling rate
- return samplesPerFrame / frameDuration;
- }
-
- return 0;
-}
-
-extern "C" u_int32_t MP4AV_AudioGetSamplingRate(
- MP4FileHandle mp4File,
- MP4TrackId audioTrackId)
-{- u_int8_t audioType =
- MP4GetTrackAudioType(mp4File, audioTrackId);
-
- if (audioType == MP4_INVALID_AUDIO_TYPE) {- return 0;
- }
-
- if (MP4_IS_MP3_AUDIO_TYPE(audioType)) {- return 0;
- } else if (MP4_IS_AAC_AUDIO_TYPE(audioType)) {- u_int8_t* pAacConfig = NULL;
- u_int32_t aacConfigLength;
-
- MP4GetTrackESConfiguration(
- mp4File,
- audioTrackId,
- &pAacConfig,
- &aacConfigLength);
-
- if (pAacConfig == NULL || aacConfigLength < 2) {- return 0;
- }
-
- u_int32_t samplingRate =
- MP4AV_AacConfigGetSamplingRate(pAacConfig);
-
- free(pAacConfig);
-
- return samplingRate;
-
- } else if (audioType == MP4_PCM16_AUDIO_TYPE) {- return MP4GetTrackTimeScale(mp4File, audioTrackId);
- }
-
- return 0;
-}
-
-extern "C" u_int16_t MP4AV_AudioGetSamplingWindow(
- MP4FileHandle mp4File,
- MP4TrackId audioTrackId)
-{- u_int8_t audioType =
- MP4GetTrackAudioType(mp4File, audioTrackId);
-
- if (audioType == MP4_INVALID_AUDIO_TYPE) {- return 0;
- }
-
- if (MP4_IS_MP3_AUDIO_TYPE(audioType)) {- return 0;
- } else if (MP4_IS_AAC_AUDIO_TYPE(audioType)) {- u_int8_t* pAacConfig = NULL;
- u_int32_t aacConfigLength;
-
- MP4GetTrackESConfiguration(
- mp4File,
- audioTrackId,
- &pAacConfig,
- &aacConfigLength);
-
- if (pAacConfig == NULL || aacConfigLength < 2) {- return 0;
- }
-
- u_int32_t samplingWindow =
- MP4AV_AacConfigGetSamplingWindow(pAacConfig);
-
- free(pAacConfig);
-
- return samplingWindow;
-
- } else if (audioType == MP4_PCM16_AUDIO_TYPE) {- MP4Duration frameDuration =
- MP4GetSampleDuration(mp4File, audioTrackId, 1);
-
- // assumes track time scale == sampling rate
- // and constant frame size was used
- return frameDuration;
- }
-
- return 0;
-}
--- a/plugins/in_mp4/mp4av_audio.h
+++ /dev/null
@@ -1,45 +1,0 @@
-/*
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (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.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is MPEG4IP.
- *
- * The Initial Developer of the Original Code is Cisco Systems Inc.
- * Portions created by Cisco Systems Inc. are
- * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
- *
- * Contributor(s):
- * Dave Mackie [email protected]
- */
-
-#ifndef __MP4AV_AUDIO_INCLUDED__
-#define __MP4AV_AUDIO_INCLUDED__
-
-// Audio Track Utitlites
-#ifdef __cplusplus
-extern "C" {-#endif
-
-u_int8_t MP4AV_AudioGetChannels(
- MP4FileHandle mp4File,
- MP4TrackId audioTrackId);
-
-u_int32_t MP4AV_AudioGetSamplingRate(
- MP4FileHandle mp4File,
- MP4TrackId audioTrackId);
-
-u_int16_t MP4AV_AudioGetSamplingWindow(
- MP4FileHandle mp4File,
- MP4TrackId audioTrackId);
-#ifdef __cplusplus
-}
-#endif
-#endif /* __MP4AV_AUDIO_INCLUDED__ */
-
--- a/plugins/in_mp4/mp4av_common.h
+++ /dev/null
@@ -1,32 +1,0 @@
-/*
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (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.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is MPEG4IP.
- *
- * The Initial Developer of the Original Code is Cisco Systems Inc.
- * Portions created by Cisco Systems Inc. are
- * Copyright (C) Cisco Systems Inc. 2001-2002. All Rights Reserved.
- *
- * Contributor(s):
- * Dave Mackie [email protected]
- */
-
-#ifndef __MP4AV_COMMON_INCLUDED__
-#define __MP4AV_COMMON_INCLUDED__
-
-// the external interface
-#include "mp4av.h"
-
-// the internal interfaces
-#include "mbs.h"
-
-#endif /* __MP4AV_COMMON_INCLUDED__ */
-