Add support for accepting MPEG2 AAC-LC bitstreams.

media/mp4/mp4_stream_parser.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/mp4/mp4_stream_parser.h"
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_util.h"
 #include "media/mp4/box_definitions.h"
 #include "media/mp4/box_reader.h"
 #include "media/mp4/es_descriptor.h"
 #include "media/mp4/rcheck.h"
 
 namespace media {
 namespace mp4 {
 
 // TODO(xhwang): Figure out the init data type appropriately once it's spec'ed.
 static const char kMp4InitDataType[] = "video/mp4";
 
-MP4StreamParser::MP4StreamParser(bool has_sbr)
+MP4StreamParser::MP4StreamParser(const std::set<int>& audio_object_types,
+                                 bool has_sbr)
     : state_(kWaitingForInit),
       moof_head_(0),
       mdat_tail_(0),
       has_audio_(false),
       has_video_(false),
       audio_track_id_(0),
       video_track_id_(0),
+      audio_object_types_(audio_object_types),
       has_sbr_(has_sbr),
       is_audio_track_encrypted_(false),
       is_video_track_encrypted_(false) {
 }
 
 MP4StreamParser::~MP4StreamParser() {}
 
 void MP4StreamParser::Init(const InitCB& init_cb,
                            const NewConfigCB& config_cb,
                            const NewBuffersCB& audio_cb,
@@ skipping 151 matching lines @@
       const AudioSampleEntry& entry = samp_descr.audio_entries[desc_idx];
       const AAC& aac = entry.esds.aac;
 
       if (!(entry.format == FOURCC_MP4A ||
             (entry.format == FOURCC_ENCA &&
              entry.sinf.format.format == FOURCC_MP4A))) {
         MEDIA_LOG(log_cb_) << "Unsupported audio format 0x"
                            << std::hex << entry.format << " in stsd box.";
         return false;
       }
-      // Check if it is MPEG4 AAC defined in ISO 14496 Part 3.
-      if (entry.esds.object_type != kISO_14496_3) {
-        MEDIA_LOG(log_cb_) << "Unsupported audio object type 0x" << std::hex
-                           << static_cast<int>(entry.esds.object_type)
-                           << " in esds.";
+
+      int audio_type = entry.esds.object_type;
+      DVLOG(1) << "audio_type " << std::hex << audio_type;
+      if (audio_object_types_.find(audio_type) == audio_object_types_.end()) {
+        MEDIA_LOG(log_cb_) << "audio object type 0x" << std::hex << audio_type
+                           << " does not match what is specified in the"
+                           << " mimetype.";
         return false;
       }
 
+      // Check if it is MPEG4 AAC defined in ISO 14496 Part 3 or
+      // supported MPEG2 AAC varients.
+      if (audio_type != kISO_14496_3 && audio_type != kISO_13818_7_AAC_LC) {
+        MEDIA_LOG(log_cb_) << "Unsupported audio object type 0x" << std::hex
+                           << audio_type << " in esds.";
+        return false;
+      }
+
       SampleFormat sample_format;
       if (entry.samplesize == 8) {
         sample_format = kSampleFormatU8;
       } else if (entry.samplesize == 16) {
         sample_format = kSampleFormatS16;
       } else if (entry.samplesize == 32) {
         sample_format = kSampleFormatS32;
       } else {
         LOG(ERROR) << "Unsupported sample size.";
         return false;
@@ skipping 310 matching lines @@
   return !err;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 }  // namespace mp4
 }  // namespace media