Support EAC3 (Dolby Digital Plus) codec

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"
@@ skipping 181 matching lines @@
 
       // It is not uncommon to find otherwise-valid files with incorrect sample
       // description indices, so we fail gracefully in that case.
       if (desc_idx >= samp_descr.audio_entries.size())
         desc_idx = 0;
       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))) {
+             entry.sinf.format.format == FOURCC_MP4A)
+#if defined(ENABLE_EAC3_PLAYBACK)

[acolwell GONE FROM CHROMIUM, 2013/04/30 18:43:43]

I think we should just drop the #if's in this file. audio_object_types_ won't
contain kEAC3 if this define isn't enabled because of the #if blocks in
stream_parser_factory. This should cause playback to fail if we happen to
encounter content w/ this object type. This code is pretty small so I don't
think we need to worry about bloat here.

[ycheo (away), 2013/05/01 00:05:46]

Done.

+             || entry.format == FOURCC_EAC3
+#endif
+          )) {
         MEDIA_LOG(log_cb_) << "Unsupported audio format 0x"
                            << std::hex << entry.format << " in stsd box.";
         return false;
       }
 
       int audio_type = entry.esds.object_type;
       DVLOG(1) << "audio_type " << std::hex << audio_type;
+#if defined(ENABLE_EAC3_PLAYBACK)
+      if (audio_type == kForbidden &&
+          audio_object_types_.find(kEAC3) != audio_object_types_.end()) {
+        audio_type = kEAC3;
+      }
+#endif
       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;
       }
 
+      AudioCodec codec = kUnknownAudioCodec;
       // 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) {
+      if (audio_type == kISO_14496_3 || audio_type == kISO_13818_7_AAC_LC) {
+        codec = kCodecAAC;
+#if defined(ENABLE_EAC3_PLAYBACK)
+      } else if (audio_type == kEAC3) {
+        codec = kCodecEAC3;
+#endif
+      } else {
         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;
       }
 
+      ChannelLayout channel_layout = aac.GetChannelLayout(has_sbr_);
+      if (channel_layout ==  CHANNEL_LAYOUT_UNSUPPORTED &&
+          entry.channelcount > 0) {

[acolwell GONE FROM CHROMIUM, 2013/04/30 18:19:02]

Should this logic be moved above where 'codec' is getting set? It seems a little
odd to query the aac object in the EAC3 case.

[ycheo (away), 2013/05/01 00:05:46]

Done.

+        channel_layout = GuessChannelLayout(entry.channelcount);
+      }
+
+      int sample_per_second = aac.GetOutputSamplesPerSecond(has_sbr_);
+      if (sample_per_second == 0 && entry.samplerate > 0)
+        sample_per_second = entry.samplerate;
+
       is_audio_track_encrypted_ = entry.sinf.info.track_encryption.is_encrypted;
       DVLOG(1) << "is_audio_track_encrypted_: " << is_audio_track_encrypted_;
-      audio_config.Initialize(kCodecAAC, sample_format,
-                              aac.GetChannelLayout(has_sbr_),
-                              aac.GetOutputSamplesPerSecond(has_sbr_),
+      audio_config.Initialize(codec, sample_format,
+                              channel_layout,
+                              sample_per_second,
                               NULL, 0, is_audio_track_encrypted_, false);
       has_audio_ = true;
       audio_track_id_ = track->header.track_id;
     }
     if (track->media.handler.type == kVideo && !video_config.IsValidConfig()) {
       RCHECK(!samp_descr.video_entries.empty());
       if (desc_idx >= samp_descr.video_entries.size())
         desc_idx = 0;
       const VideoSampleEntry& entry = samp_descr.video_entries[desc_idx];
 
@@ skipping 196 matching lines @@
   if (video) {
     if (!PrepareAVCBuffer(runs_->video_description().avcc,
                           &frame_buf, &subsamples)) {
       MEDIA_LOG(log_cb_) << "Failed to prepare AVC sample for decode";
       *err = true;
       return false;
     }
   }
 
   if (audio) {
-    if (!PrepareAACBuffer(runs_->audio_description().esds.aac,
+    if (runs_->audio_description().esds.object_type != kForbidden &&

[acolwell GONE FROM CHROMIUM, 2013/04/30 18:19:02]

nit: How about adding a isAAC() helper method to esds since that is really what
we want to check. It could be used here and above the line that sets codec =
kCodecAAC;

[ycheo (away), 2013/05/01 00:05:46]

Done.

+        !PrepareAACBuffer(runs_->audio_description().esds.aac,
                           &frame_buf, &subsamples)) {
       MEDIA_LOG(log_cb_) << "Failed to prepare AAC sample for decode";
       *err = true;
       return false;
     }
   }
 
   if (decrypt_config) {
     if (!subsamples.empty()) {
     // Create a new config with the updated subsamples.
@@ skipping 77 matching lines @@
   return !err;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 }  // namespace mp4
 }  // namespace media