media: Opus support for WebM in Media Source

media/webm/webm_cluster_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/webm/webm_cluster_parser.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/sys_byteorder.h"
@@ skipping 46 matching lines @@
     : timecode_multiplier_(timecode_scale / 1000.0),
       ignored_tracks_(ignored_tracks),
       audio_encryption_key_id_(audio_encryption_key_id),
       video_encryption_key_id_(video_encryption_key_id),
       parser_(kWebMIdCluster, this),
       last_block_timecode_(-1),
       block_data_size_(-1),
       block_duration_(-1),
       block_add_id_(-1),
       block_additional_data_size_(-1),
+      discard_padding_(-1),
       cluster_timecode_(-1),
       cluster_start_time_(kNoTimestamp()),
       cluster_ended_(false),
       audio_(audio_track_num, false),
       video_(video_track_num, true),
       log_cb_(log_cb) {
   for (WebMTracksParser::TextTracks::const_iterator it = text_tracks.begin();
        it != text_tracks.end();
        ++it) {
     text_track_map_.insert(std::make_pair(it->first, Track(it->first, false)));
@@ skipping 53 matching lines @@
 }
 
 WebMParserClient* WebMClusterParser::OnListStart(int id) {
   if (id == kWebMIdCluster) {
     cluster_timecode_ = -1;
     cluster_start_time_ = kNoTimestamp();
   } else if (id == kWebMIdBlockGroup) {
     block_data_.reset();
     block_data_size_ = -1;
     block_duration_ = -1;
+    discard_padding_ = -1;
+    discard_padding_set_ = false;
   } else if (id == kWebMIdBlockAdditions) {
     block_add_id_ = -1;
     block_additional_data_.reset();
     block_additional_data_size_ = -1;
   }
 
   return this;
 }
 
 bool WebMClusterParser::OnListEnd(int id) {
   if (id != kWebMIdBlockGroup)
     return true;
 
   // Make sure the BlockGroup actually had a Block.
   if (block_data_size_ == -1) {
     MEDIA_LOG(log_cb_) << "Block missing from BlockGroup.";
     return false;
   }
 
   bool result = ParseBlock(false, block_data_.get(), block_data_size_,
                            block_additional_data_.get(),
-                           block_additional_data_size_, block_duration_);
+                           block_additional_data_size_, block_duration_,
+                           discard_padding_);
   block_data_.reset();
   block_data_size_ = -1;
   block_duration_ = -1;
   block_add_id_ = -1;
   block_additional_data_.reset();
   block_additional_data_size_ = -1;
+  discard_padding_ = discard_padding_set_ ? discard_padding_ : 0;

[acolwell GONE FROM CHROMIUM, 2013/09/04 20:08:43]

nit: Sorry if I wasn't clear. I meant to place this in the call to ParseBlock().
I think the code this way will cause discard_padding to be set to -1 for formats
like Vorbis that may have block groups, but don't specify discard_padding.

The alternative is to always set_discard_padding_ = 0 everywhere in this file
that you set it to -1. Then discard_padding_set_ is only used to signal an error
if multiple DiscardPadding elements are encountered.

[vignesh, 2013/09/04 20:27:46]

Done.

+  discard_padding_set_ = false;
   return result;
 }
 
 bool WebMClusterParser::OnUInt(int id, int64 val) {
   int64* dst;
   switch (id) {
     case kWebMIdTimecode:
       dst = &cluster_timecode_;
       break;
     case kWebMIdBlockDuration:
       dst = &block_duration_;
       break;
     case kWebMIdBlockAddID:
       dst = &block_add_id_;
       break;
+    case kWebMIdDiscardPadding:
+      if (discard_padding_set_)
+        return false;
+      discard_padding_set_ = true;
+      discard_padding_ = val;
+      return true;
     default:
       return true;
   }
   if (*dst != -1)
     return false;
   *dst = val;
   return true;
 }
 
 bool WebMClusterParser::ParseBlock(bool is_simple_block, const uint8* buf,
                                    int size, const uint8* additional,
-                                   int additional_size, int duration) {
+                                   int additional_size, int duration,
+                                   int64 discard_padding) {
   if (size < 4)
     return false;
 
   // Return an error if the trackNum > 127. We just aren't
   // going to support large track numbers right now.
   if (!(buf[0] & 0x80)) {
     MEDIA_LOG(log_cb_) << "TrackNumber over 127 not supported";
     return false;
   }
 
   int track_num = buf[0] & 0x7f;
   int timecode = buf[1] << 8 | buf[2];
   int flags = buf[3] & 0xff;
   int lacing = (flags >> 1) & 0x3;
 
   if (lacing) {
     MEDIA_LOG(log_cb_) << "Lacing " << lacing << " is not supported yet.";
     return false;
   }
 
   // Sign extend negative timecode offsets.
   if (timecode & 0x8000)
     timecode |= ~0xffff;
 
   const uint8* frame_data = buf + 4;
   int frame_size = size - (frame_data - buf);
   return OnBlock(is_simple_block, track_num, timecode, duration, flags,
-                 frame_data, frame_size, additional, additional_size);
+                 frame_data, frame_size, additional, additional_size,
+                 discard_padding);
 }
 
 bool WebMClusterParser::OnBinary(int id, const uint8* data, int size) {
   switch (id) {
     case kWebMIdSimpleBlock:
-      return ParseBlock(true, data, size, NULL, -1, -1);
+      return ParseBlock(true, data, size, NULL, -1, -1, -1);
 
     case kWebMIdBlock:
       if (block_data_) {
         MEDIA_LOG(log_cb_) << "More than 1 Block in a BlockGroup is not "
                               "supported.";
         return false;
       }
       block_data_.reset(new uint8[size]);
       memcpy(block_data_.get(), data, size);
       block_data_size_ = size;
@@ skipping 24 matching lines @@
     default:
       return true;
   }
 }
 
 bool WebMClusterParser::OnBlock(bool is_simple_block, int track_num,
                                 int timecode,
                                 int  block_duration,
                                 int flags,
                                 const uint8* data, int size,
-                                const uint8* additional, int additional_size) {
+                                const uint8* additional, int additional_size,
+                                int64 discard_padding) {
   DCHECK_GE(size, 0);
   if (cluster_timecode_ == -1) {
     MEDIA_LOG(log_cb_) << "Got a block before cluster timecode.";
     return false;
   }
 
   // TODO(acolwell): Should relative negative timecode offsets be rejected?  Or
   // only when the absolute timecode is negative?  See http://crbug.com/271794
   if (timecode < 0) {
     MEDIA_LOG(log_cb_) << "Got a block with negative timecode offset "
@@ skipping 59 matching lines @@
 
   buffer->set_timestamp(timestamp);
   if (cluster_start_time_ == kNoTimestamp())
     cluster_start_time_ = timestamp;
 
   if (block_duration >= 0) {
     buffer->set_duration(base::TimeDelta::FromMicroseconds(
         block_duration * timecode_multiplier_));
   }
 
+  if (discard_padding != 0) {
+    buffer->set_discard_padding(base::TimeDelta::FromMicroseconds(
+                                    discard_padding / 1000));
+  }
+
   return track->AddBuffer(buffer);
 }
 
 WebMClusterParser::Track::Track(int track_num, bool is_video)
     : track_num_(track_num),
       is_video_(is_video) {
 }
 
 WebMClusterParser::Track::~Track() {}
 
@@ skipping 48 matching lines @@
 WebMClusterParser::FindTextTrack(int track_num) {
   const TextTrackMap::iterator it = text_track_map_.find(track_num);
 
   if (it == text_track_map_.end())
     return NULL;
 
   return &it->second;
 }
 
 }  // namespace media