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 "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 232 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),

[acolwell GONE FROM CHROMIUM, 2013/08/28 20:44:47]

nit:It looks like you didn't remove this from the .h.

[vignesh, 2013/08/29 21:37:31]

Done.

       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()) {
+    skip_samples_ = opus_header.skip_samples;

[acolwell GONE FROM CHROMIUM, 2013/08/28 20:44:47]

Why do we special case this?

[vignesh, 2013/08/29 21:37:31]

In case of some old opus files, the container value might not exist. We can
still play those files by making use of the value from the codec private header.

+  } else {
+    // WebM container stores codec delay in nanoseconds. Convert it to samples.
+    skip_samples_ = config.codec_delay() * config.samples_per_second() /

[acolwell GONE FROM CHROMIUM, 2013/08/28 20:44:47]

nit: This looks like it could potentially overflow. At a minimum you should
return false if skip_samples_ becomes negative.

[vignesh, 2013/08/29 21:37:31]

Done.

+                    1000000000;
+    if (skip_samples_ != opus_header.skip_samples) {

[acolwell GONE FROM CHROMIUM, 2013/08/28 20:44:47]

Shouldn't the codec_delay() header always match the skip_samples field?

[vignesh, 2013/08/29 21:37:31]

As of now, both the fields should match. But some tool might eventually screw it
up. So I thought we could be more permissive and somehow try to play the file.
But after a second thought, seems like being strict in this case makes sense. So
i'll make the change accordingly.

+      DVLOG(1) << "Codec Delay in container does not match the value in Opus "
+               << "header. Using the value in container.";

[acolwell GONE FROM CHROMIUM, 2013/08/28 20:44:47]

nit: return false here if the expectation that these should always match.

[vignesh, 2013/08/29 21:37:31]

Done.

+    }
+  }
 
   uint8 channel_mapping[kMaxVorbisChannels];
   memcpy(&channel_mapping,
          kDefaultOpusChannelLayout,
          kMaxChannelsWithDefaultLayout);
 
   if (channel_count > kMaxChannelsWithDefaultLayout) {
     RemapOpusChannelLayout(opus_header.stream_map,
                            channel_count,
                            channel_mapping);
@@ skipping 27 matching lines @@
 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_,

[Tom Finegan, 2013/08/28 01:35:35]

I thought you were going to handle S16 and F32 on a per platform basis-- did you
change your mind and decide to use S16 unconditionally?

[vignesh, 2013/08/28 17:17:15]

I did not change my mind. I will be doing that change in a subsequent CL.

                                                 input->data(),
                                                 input->data_size(),
                                                 &output_buffer_[0],
                                                 kMaxOpusOutputPacketSizeSamples,
                                                 0);
   if (samples_decoded < 0) {
     LOG(ERROR) << "opus_multistream_decode failed for"
                << " timestamp: " << input->timestamp().InMicroseconds()
                << " us, duration: " << input->duration().InMicroseconds()
                << " us, packet size: " << input->data_size() << " bytes with"
                << " status: " << opus_strerror(samples_decoded);
     return false;
   }
 
   uint8* decoded_audio_data = reinterpret_cast<uint8*>(&output_buffer_[0]);
   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() > 0) {
+      int discard_padding = input->discard_padding() * samples_per_second_ /
+                            1000000000;

[acolwell GONE FROM CHROMIUM, 2013/08/28 20:44:47]

nit: This may need overflow protection as well.

[vignesh, 2013/08/29 21:37:31]

Done.

+      output_buffer->get()->TrimEnd(std::min(samples_decoded, discard_padding));
+      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