Use passthrough decoder for (E)AC3 formats

media/filters/android/media_codec_audio_decoder.cc

 // Copyright 2016 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/filters/android/media_codec_audio_decoder.h"
 
+#include <cmath>
+
 #include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/android/media_codec_bridge_impl.h"
+#include "media/base/android/media_codec_util.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/timestamp_constants.h"
+#include "media/formats/ac3/ac3_util.h"
 
 namespace media {
 
 MediaCodecAudioDecoder::MediaCodecAudioDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(task_runner),
       state_(STATE_UNINITIALIZED),
+      is_passthrough_(false),
+      sample_format_(kSampleFormatS16),
       channel_count_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
       sample_rate_(0),
       media_drm_bridge_cdm_context_(nullptr),
       cdm_registration_id_(0),
       pool_(new AudioBufferMemoryPool()),
       weak_factory_(this) {
   DVLOG(1) << __func__;
 }
 
@@ skipping 25 matching lines @@
                                         const OutputCB& output_cb) {
   DVLOG(1) << __func__ << ": " << config.AsHumanReadableString();
   DCHECK_NE(state_, STATE_WAITING_FOR_MEDIA_CRYPTO);
 
   // Initialization and reinitialization should not be called during pending
   // decode.
   DCHECK(input_queue_.empty());
   ClearInputQueue(DecodeStatus::ABORTED);
 
   InitCB bound_init_cb = BindToCurrentLoop(init_cb);
+  is_passthrough_ = MediaCodecUtil::IsPassthroughAudioFormat(config.codec());
+  sample_format_ = kSampleFormatS16;
+
+  if (config.codec() == kCodecAC3)
+    sample_format_ = kSampleFormatAc3;
+  else if (config.codec() == kCodecEAC3)
+    sample_format_ = kSampleFormatEac3;
 
   if (state_ == STATE_ERROR) {
     DVLOG(1) << "Decoder is in error state.";
     bound_init_cb.Run(false);
     return;
   }
 
   // We can support only the codecs that MediaCodecBridge can decode.
   // TODO(xhwang): Get this list from MediaCodecBridge or just rely on
   // attempting to create one to determine whether the codec is supported.
-  const bool is_codec_supported = config.codec() == kCodecVorbis ||
-                                  config.codec() == kCodecAAC ||
-                                  config.codec() == kCodecOpus;
+  const bool is_codec_supported =
+      config.codec() == kCodecVorbis || config.codec() == kCodecAAC ||
+      config.codec() == kCodecOpus || is_passthrough_;
   if (!is_codec_supported) {
     DVLOG(1) << "Unsuported codec " << GetCodecName(config.codec());
     bound_init_cb.Run(false);
     return;
   }
 
   if (config.is_encrypted() && !cdm_context) {
     NOTREACHED() << "The stream is encrypted but there is no CDM context";
     bound_init_cb.Run(false);
     return;
@@ skipping 260 matching lines @@
   DCHECK_NE(out.size, 0U);
   DCHECK_NE(out.index, MediaCodecLoop::kInvalidBufferIndex);
   DCHECK(codec_loop_);
   MediaCodecBridge* media_codec = codec_loop_->GetCodec();
   DCHECK(media_codec);
 
   // For proper |frame_count| calculation we need to use the actual number
   // of channels which can be different from |config_| value.
   DCHECK_GT(channel_count_, 0);
 
-  // Android MediaCodec can only output 16bit PCM audio.
-  const int bytes_per_frame = sizeof(uint16_t) * channel_count_;
-  const size_t frame_count = out.size / bytes_per_frame;
+  size_t frame_count = 1;
+  scoped_refptr<AudioBuffer> audio_buffer;
 
-  // Create AudioOutput buffer based on current parameters.
-  scoped_refptr<AudioBuffer> audio_buffer = AudioBuffer::CreateBuffer(
-      kSampleFormatS16, channel_layout_, channel_count_, sample_rate_,
-      frame_count, pool_);
+  if (is_passthrough_) {
+    audio_buffer = AudioBuffer::CreateBitstreamBuffer(
+        sample_format_, channel_layout_, channel_count_, sample_rate_,
+        frame_count, out.size, pool_);
+
+    MediaCodecStatus status = media_codec->CopyFromOutputBuffer(
+        out.index, out.offset, audio_buffer->channel_data()[0], out.size);
+
+    if (status != MEDIA_CODEC_OK) {
+      media_codec->ReleaseOutputBuffer(out.index, false);
+      return false;
+    }
+
+    if (config_.codec() == kCodecAC3) {
+      frame_count = Ac3Util::ParseTotalAc3SampleCount(
+          audio_buffer->channel_data()[0], out.size);
+    } else if (config_.codec() == kCodecEAC3) {
+      frame_count = Ac3Util::ParseTotalEac3SampleCount(
+          audio_buffer->channel_data()[0], out.size);
+    } else {
+      NOTREACHED() << "Unsupported passthrough format.";
+    }
+
+    // Create AudioOutput buffer based on current parameters.
+    audio_buffer = AudioBuffer::CreateBitstreamBuffer(
+        sample_format_, channel_layout_, channel_count_, sample_rate_,
+        frame_count, out.size, pool_);
+  } else {
+    // Android MediaCodec can only output 16bit PCM audio.
+    const int bytes_per_frame = sizeof(uint16_t) * channel_count_;
+    frame_count = out.size / bytes_per_frame;
+
+    // Create AudioOutput buffer based on current parameters.
+    audio_buffer = AudioBuffer::CreateBuffer(sample_format_, channel_layout_,
+                                             channel_count_, sample_rate_,
+                                             frame_count, pool_);
+  }
 
   // Copy data into AudioBuffer.
   CHECK_LE(out.size, audio_buffer->data_size());
 
   MediaCodecStatus status = media_codec->CopyFromOutputBuffer(
       out.index, out.offset, audio_buffer->channel_data()[0], out.size);
 
   // Release MediaCodec output buffer.
   media_codec->ReleaseOutputBuffer(out.index, false);
 
@@ skipping 88 matching lines @@
     RETURN_STRING(STATE_READY);
     RETURN_STRING(STATE_ERROR);
   }
   NOTREACHED() << "Unknown state " << state;
   return nullptr;
 }
 
 #undef RETURN_STRING
 
 }  // namespace media