Re-add AC3/EAC3 audio demuxing support

media/ffmpeg/ffmpeg_common.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/ffmpeg/ffmpeg_common.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_util.h"
+#include "media/media_features.h"
 
 namespace media {
 
 // Why FF_INPUT_BUFFER_PADDING_SIZE? FFmpeg assumes all input buffers are
 // padded. Check here to ensure FFmpeg only receives data padded to its
 // specifications.
 static_assert(DecoderBuffer::kPaddingSize >= FF_INPUT_BUFFER_PADDING_SIZE,
               "DecoderBuffer padding size does not fit ffmpeg requirement");
 
 // Alignment requirement by FFmpeg for input and output buffers. This need to
@@ skipping 33 matching lines @@
 int64_t ConvertToTimeBase(const AVRational& time_base,
                           const base::TimeDelta& timestamp) {
   return av_rescale_q(timestamp.InMicroseconds(), kMicrosBase, time_base);
 }
 
 // Converts an FFmpeg audio codec ID into its corresponding supported codec id.
 static AudioCodec CodecIDToAudioCodec(AVCodecID codec_id) {
   switch (codec_id) {
     case AV_CODEC_ID_AAC:
       return kCodecAAC;
+#if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
+    case AV_CODEC_ID_AC3:
+      return kCodecAC3;
+    case AV_CODEC_ID_EAC3:
+      return kCodecEAC3;
+#endif
     case AV_CODEC_ID_MP3:
       return kCodecMP3;
     case AV_CODEC_ID_VORBIS:
       return kCodecVorbis;
     case AV_CODEC_ID_PCM_U8:
     case AV_CODEC_ID_PCM_S16LE:
     case AV_CODEC_ID_PCM_S24LE:
     case AV_CODEC_ID_PCM_S32LE:
     case AV_CODEC_ID_PCM_F32LE:
       return kCodecPCM;
@@ skipping 222 matching lines @@
 
   AudioCodec codec = CodecIDToAudioCodec(codec_context->codec_id);
 
   SampleFormat sample_format = AVSampleFormatToSampleFormat(
       codec_context->sample_fmt, codec_context->codec_id);
 
   ChannelLayout channel_layout = ChannelLayoutToChromeChannelLayout(
       codec_context->channel_layout, codec_context->channels);
 
   int sample_rate = codec_context->sample_rate;
-  if (codec == kCodecOpus) {
-    // |codec_context->sample_fmt| is not set by FFmpeg because Opus decoding is
-    // not enabled in FFmpeg.  It doesn't matter what value is set here, so long
-    // as it's valid, the true sample format is selected inside the decoder.
-    sample_format = kSampleFormatF32;
+  switch (codec) {
+    case kCodecOpus:
+      // |codec_context->sample_fmt| is not set by FFmpeg because Opus decoding
+      // is not enabled in FFmpeg.  It doesn't matter what value is set here, so
+      // long as it's valid, the true sample format is selected inside the
+      // decoder.
+      sample_format = kSampleFormatF32;
 
-    // Always use 48kHz for OPUS.  Technically we should match to the highest
-    // supported hardware sample rate among [8, 12, 16, 24, 48] kHz, but we
-    // don't know the hardware sample rate at this point and those rates are
-    // rarely used for output.  See the "Input Sample Rate" section of the spec:
-    // http://tools.ietf.org/html/draft-terriberry-oggopus-01#page-11
-    sample_rate = 48000;
+      // Always use 48kHz for OPUS.  Technically we should match to the highest
+      // supported hardware sample rate among [8, 12, 16, 24, 48] kHz, but we
+      // don't know the hardware sample rate at this point and those rates are
+      // rarely used for output.  See the "Input Sample Rate" section of the
+      // spec: http://tools.ietf.org/html/draft-terriberry-oggopus-01#page-11
+      sample_rate = 48000;
+      break;
+
+    // For AC3/EAC3 we enable only demuxing, but not decoding, so FFmpeg does
+    // not fill |sample_fmt|.
+    case kCodecAC3:
+    case kCodecEAC3:
+#if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
+      // The spec for AC3/EAC3 audio is ETSI TS 102 366. According to sections
+      // F.3.1 and F.5.1 in that spec the sample_format for AC3/EAC3 must be 16.
+      sample_format = kSampleFormatS16;
+#else
+      NOTREACHED();
+#endif
+      break;
+
+    default:
+      break;
   }
 
   base::TimeDelta seek_preroll;
   if (codec_context->seek_preroll > 0) {
     seek_preroll = base::TimeDelta::FromMicroseconds(
         codec_context->seek_preroll * 1000000.0 / codec_context->sample_rate);
   }
 
   // AVStream occasionally has invalid extra data. See http://crbug.com/517163
   if ((codec_context->extradata_size == 0) !=
@@ skipping 12 matching lines @@
   }
   config->Initialize(codec,
                      sample_format,
                      channel_layout,
                      sample_rate,
                      extra_data,
                      is_encrypted,
                      seek_preroll,
                      codec_context->delay);
 
-  if (codec != kCodecOpus) {
-    DCHECK_EQ(av_get_bytes_per_sample(codec_context->sample_fmt) * 8,
-              config->bits_per_channel());
+  // Verify that AudioConfig.bits_per_channel was calculated correctly for
+  // codecs that have |sample_fmt| set by FFmpeg.
+  switch (codec) {
+    case kCodecOpus:
+#if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
+    case kCodecAC3:
+    case kCodecEAC3:
+#endif
+      break;
+    default:
+      DCHECK_EQ(av_get_bytes_per_sample(codec_context->sample_fmt) * 8,
+                config->bits_per_channel());
+      break;
   }
 
   return true;
 }
 
 bool AVStreamToAudioDecoderConfig(const AVStream* stream,
                                   AudioDecoderConfig* config) {
   bool is_encrypted = false;
   AVDictionaryEntry* key =
       av_dict_get(stream->metadata, "enc_key_id", nullptr, 0);
@@ skipping 321 matching lines @@
 }
 
 int32_t HashCodecName(const char* codec_name) {
   // Use the first 32-bits from the SHA1 hash as the identifier.
   int32_t hash;
   memcpy(&hash, base::SHA1HashString(codec_name).substr(0, 4).c_str(), 4);
   return hash;
 }
 
 }  // namespace media