media: Opus support for WebM in Media Source

media/filters/opus_audio_decoder.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/filters/opus_audio_decoder.h"
 
+#include <cmath>
+
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/sys_byteorder.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/buffers.h"
@@ skipping 226 matching lines @@
 OpusAudioDecoder::OpusAudioDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop)
     : message_loop_(message_loop),
       weak_factory_(this),
       demuxer_stream_(NULL),
       opus_decoder_(NULL),
       bits_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
       samples_per_second_(0),
       last_input_timestamp_(kNoTimestamp()),
-      output_bytes_to_drop_(0),
       skip_samples_(0) {
 }
 
 void OpusAudioDecoder::Initialize(
     DemuxerStream* stream,
     const PipelineStatusCB& status_cb,
     const StatisticsCB& statistics_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   PipelineStatusCB initialize_cb = BindToCurrentLoop(status_cb);
 
@@ skipping 186 matching lines @@
   // Allocate the output buffer if necessary.
   if (!output_buffer_)
     output_buffer_.reset(new int16[kMaxOpusOutputPacketSizeSamples]);
 
   // Parse the Opus header.
   OpusHeader opus_header;
   ParseOpusHeader(config.extra_data(), config.extra_data_size(),
                   config,
                   &opus_header);
 
-  skip_samples_ = opus_header.skip_samples;
-
-  if (skip_samples_ > 0)
-    output_bytes_to_drop_ = skip_samples_ * config.bytes_per_frame();
+  if (!config.codec_delay().InMicroseconds()) {

[acolwell GONE FROM CHROMIUM, 2013/09/03 20:14:01]

Shouldn't this return false to trigger a decode error since it indicates that
there is a delay, but it isn't signalled in the header? It seems like allowing
this would mask invalid content.

[vignesh, 2013/09/03 22:43:03]

Agreed. Done.

But doing this stricter check will fail to play files through the regular media
pipeline (<video> tag) since the ffmpeg demuxer isn't capable of parsing the new
container values (yet!). So i will disable the Basic_Opus_playback pipeline
integration test for now. I will be fixing the ffmpeg demuxer soon and will
enable the test after i do that.

[acolwell GONE FROM CHROMIUM, 2013/09/03 23:53:43]

Hmm. I don't want people who have been experimenting with the existing FFmpeg
code path to file "Opus no worky" bugs when this lands. How about leaving this
in with a TODO to remove it as soon as 
you fix the FFmpeg code path. If there isn't a bug already for that work, please
file one and put the crbug URL in the comment. Also reenable the test please. :)

+    skip_samples_ = opus_header.skip_samples;
+  } else {
+    // Convert from seconds to samples.
+    skip_samples_ = std::ceil(config.codec_delay().InMicroseconds() *
+                              config.samples_per_second() /
+                              static_cast<double>(1000000));

[acolwell GONE FROM CHROMIUM, 2013/09/03 20:14:01]

nit: 1000000.0 should remove the need for a static_cast here.

[vignesh, 2013/09/03 22:43:03]

Done.

+    if (skip_samples_ < 0) {
+      DVLOG(1) << "Invalid file. Incorrect value for codec delay.";
+      return false;
+    }
+    if (skip_samples_ != opus_header.skip_samples) {
+      DVLOG(1) << "Invalid file. Codec Delay in container does not match the "
+               << "value in Opus header.";
+      return false;
+    }
+  }
 
   uint8 channel_mapping[kMaxVorbisChannels];
   memcpy(&channel_mapping,
          kDefaultOpusChannelLayout,
          kMaxChannelsWithDefaultLayout);
 
   if (channel_count > kMaxChannelsWithDefaultLayout) {
     RemapOpusChannelLayout(opus_header.stream_map,
                            channel_count,
                            channel_mapping);
   }
 
   // Init Opus.
   int status = OPUS_INVALID_STATE;
   opus_decoder_ = opus_multistream_decoder_create(config.samples_per_second(),
                                                   channel_count,
                                                   opus_header.num_streams,
                                                   opus_header.num_coupled,
                                                   channel_mapping,
                                                   &status);
   if (!opus_decoder_ || status != OPUS_OK) {
     LOG(ERROR) << "opus_multistream_decoder_create failed status="
                << opus_strerror(status);
     return false;
   }
 
-  // TODO(tomfinegan): Handle audio delay once the matroska spec is updated
-  // to represent the value.
-
   bits_per_channel_ = config.bits_per_channel();
   channel_layout_ = config.channel_layout();
   samples_per_second_ = config.samples_per_second();
   output_timestamp_helper_.reset(
       new AudioTimestampHelper(config.samples_per_second()));
   return true;
 }
 
 void OpusAudioDecoder::CloseDecoder() {
   if (opus_decoder_) {
     opus_multistream_decoder_destroy(opus_decoder_);
     opus_decoder_ = NULL;
   }
 }
 
 void OpusAudioDecoder::ResetTimestampState() {
   output_timestamp_helper_->SetBaseTimestamp(kNoTimestamp());
   last_input_timestamp_ = kNoTimestamp();
-  output_bytes_to_drop_ = 0;
+  skip_samples_ = 0;
 }
 
 bool OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& input,
                               scoped_refptr<AudioBuffer>* output_buffer) {
   int samples_decoded = opus_multistream_decode(opus_decoder_,
                                                 input->data(),
                                                 input->data_size(),
                                                 &output_buffer_[0],
                                                 kMaxOpusOutputPacketSizeSamples,
                                                 0);
@@ skipping 10 matching lines @@
   int decoded_audio_size = samples_decoded *
       demuxer_stream_->audio_decoder_config().bytes_per_frame();
   DCHECK_LE(decoded_audio_size, kMaxOpusOutputPacketSizeBytes);
 
   if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
       !input->end_of_stream()) {
     DCHECK(input->timestamp() != kNoTimestamp());
     output_timestamp_helper_->SetBaseTimestamp(input->timestamp());
   }
 
-  if (decoded_audio_size > 0 && output_bytes_to_drop_ > 0) {
-    int dropped_size = std::min(decoded_audio_size, output_bytes_to_drop_);
-    DCHECK_EQ(dropped_size % kBytesPerChannel, 0);
-    decoded_audio_data += dropped_size;
-    decoded_audio_size -= dropped_size;
-    output_bytes_to_drop_ -= dropped_size;
-    samples_decoded = decoded_audio_size /
-                      demuxer_stream_->audio_decoder_config().bytes_per_frame();
-  }
-
   if (decoded_audio_size > 0) {
     // Copy the audio samples into an output buffer.
     uint8* data[] = { decoded_audio_data };
     *output_buffer = AudioBuffer::CopyFrom(
         kSampleFormatS16,
         ChannelLayoutToChannelCount(channel_layout_),
         samples_decoded,
         data,
         output_timestamp_helper_->GetTimestamp(),
         output_timestamp_helper_->GetFrameDuration(samples_decoded));
     output_timestamp_helper_->AddFrames(samples_decoded);
+    if (skip_samples_ > 0) {
+      int dropped_size = std::min(samples_decoded, skip_samples_);
+      output_buffer->get()->TrimStart(dropped_size);
+      skip_samples_ -= dropped_size;
+      samples_decoded -= dropped_size;
+    }
+    if (input->discard_padding().InMicroseconds() > 0) {
+      int discard_padding = std::ceil(
+                                input->discard_padding().InMicroseconds() *
+                                samples_per_second_ /
+                                static_cast<double>(1000000));

[acolwell GONE FROM CHROMIUM, 2013/09/03 20:14:01]

ditto

[vignesh, 2013/09/03 22:43:03]

Done.

+      if (discard_padding < 0) {
+        DVLOG(1) << "Invalid file. Incorrect discard padding value.";
+        return false;
+      }
+      output_buffer->get()->TrimEnd(std::min(samples_decoded, discard_padding));

[acolwell GONE FROM CHROMIUM, 2013/09/03 20:14:01]

An error should probably be triggered if the discard_padding in the file is
actually larger than the number of samples in the coded frame.

[vignesh, 2013/09/03 22:43:03]

Done.

+      samples_decoded -= discard_padding;
+    }
   }
 
+  decoded_audio_size =
+      samples_decoded *
+      demuxer_stream_->audio_decoder_config().bytes_per_frame();
   // Decoding finished successfully, update statistics.
   PipelineStatistics statistics;
   statistics.audio_bytes_decoded = decoded_audio_size;
   statistics_cb_.Run(statistics);
 
   return true;
 }
 
 }  // namespace media