Parsing of encoded duration for unencrypted opus streams.

media/formats/webm/webm_cluster_parser.cc

 // Copyright 2014 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/formats/webm/webm_cluster_parser.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/sys_byteorder.h"
 #include "media/base/buffers.h"
 #include "media/base/decrypt_config.h"
 #include "media/filters/webvtt_util.h"
 #include "media/formats/webm/webm_constants.h"
 #include "media/formats/webm/webm_crypto_helpers.h"
 #include "media/formats/webm/webm_webvtt_parser.h"
 
 namespace media {
 
+const uint16_t WebMClusterParser::kOpusFrameDurationsMu[] = {
+    10000, 20000, 40000, 60000, 10000, 20000, 40000, 60000, 10000, 20000, 40000,
+    60000, 10000, 20000, 10000, 20000, 2500,  5000,  10000, 20000, 2500,  5000,
+    10000, 20000, 2500,  5000,  10000, 20000, 2500,  5000,  10000, 20000};
+
+enum {
+  // Limits the number of MEDIA_LOG() calls in the path of reading encoded
+  // duration to avoid spamming for corrupted data.
+  kMaxDurationLogs = 10,
+};
+
 WebMClusterParser::WebMClusterParser(
     int64 timecode_scale,
     int audio_track_num,
     base::TimeDelta audio_default_duration,
     int video_track_num,
     base::TimeDelta video_default_duration,
     const WebMTracksParser::TextTracks& text_tracks,
     const std::set<int64>& ignored_tracks,
     const std::string& audio_encryption_key_id,
     const std::string& video_encryption_key_id,
+    const AudioCodec audio_codec,
     const LogCB& log_cb)
-    : timecode_multiplier_(timecode_scale / 1000.0),
+    : num_duration_errors_(0),
+      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),
+      audio_codec_(audio_codec),
       parser_(kWebMIdCluster, this),
       last_block_timecode_(-1),
       block_data_size_(-1),
       block_duration_(-1),
       block_add_id_(-1),
       block_additional_data_size_(0),
       discard_padding_(-1),
       cluster_timecode_(-1),
       cluster_start_time_(kNoTimestamp()),
       cluster_ended_(false),
@@ skipping 16 matching lines @@
   cluster_timecode_ = -1;
   cluster_start_time_ = kNoTimestamp();
   cluster_ended_ = false;
   parser_.Reset();
   audio_.Reset();
   video_.Reset();
   ResetTextTracks();
   ready_buffer_upper_bound_ = kNoDecodeTimestamp();
 }
 
-int WebMClusterParser::Parse(const uint8* buf, int size) {
+int WebMClusterParser::Parse(const uint8_t* buf, int size) {
   audio_.ClearReadyBuffers();
   video_.ClearReadyBuffers();
   ClearTextTrackReadyBuffers();
   ready_buffer_upper_bound_ = kNoDecodeTimestamp();
 
   int result = parser_.Parse(buf, size);
 
   if (result < 0) {
     cluster_ended_ = false;
     return result;
@@ skipping 51 matching lines @@
        itr != text_track_map_.end();
        ++itr) {
     const BufferQueue& text_buffers = itr->second.ready_buffers();
     if (!text_buffers.empty())
       text_buffers_map_.insert(std::make_pair(itr->first, text_buffers));
   }
 
   return text_buffers_map_;
 }
 
+base::TimeDelta WebMClusterParser::TryGetEncodedAudioDuration(
+    const uint8_t* data,
+    int size) {
+  if (audio_codec_ == kCodecOpus) {
+    return ReadOpusDuration(data, size);
+  }
+
+  // TODO(wolenetz/chcunningham): Implement duration reading for Vorbis. See
+  // motivations in http://crbug.com/396634.
+
+  return kNoTimestamp();
+}
+
+base::TimeDelta WebMClusterParser::ReadOpusDuration(const uint8_t* data,
+                                                    int size) {
+  // Masks and constants for Opus packets. See
+  // https://tools.ietf.org/html/rfc6716#page-14
+  static const uint8_t kTocConfigMask = 0xf8;
+  static const uint8_t kTocFrameCountCodeMask = 0x03;
+  static const uint8_t kFrameCountMask = 0x3f;
+  static const base::TimeDelta kPacketDurationMax =
+      base::TimeDelta::FromMilliseconds(120);
+
+  if (size < 1) {
+    LIMITED_MEDIA_LOG(log_cb_, num_duration_errors_, kMaxDurationLogs)
+        << "Invalid zero-byte Opus packet; demuxed block duration may be "
+           "imprecise.";
+    return kNoTimestamp();
+  }
+
+  // Frame count type described by last 2 bits of Opus TOC byte.
+  int frame_count_type = data[0] & kTocFrameCountCodeMask;
+
+  int frame_count = 0;
+  switch (frame_count_type) {
+    case 0:
+      frame_count = 1;
+      break;
+    case 1:
+    case 2:
+      frame_count = 2;
+      break;
+    case 3:
+      // Type 3 indicates an arbitrary frame count described in the next byte.
+      if (size < 2) {
+        LIMITED_MEDIA_LOG(log_cb_, num_duration_errors_, kMaxDurationLogs)
+            << "Second byte missing from 'Code 3' Opus packet; demuxed block "
+               "duration may be imprecise.";
+        return kNoTimestamp();
+      }
+
+      frame_count = data[1] & kFrameCountMask;
+
+      if (frame_count == 0) {
+        LIMITED_MEDIA_LOG(log_cb_, num_duration_errors_, kMaxDurationLogs)
+            << "Illegal 'Code 3' opus packet with frame count zero; demuxed "

[wolenetz, 2015/02/06 19:48:01]

nit: s/opus/Opus/

[chcunningham, 2015/02/06 22:46:00]

Done.

+               "block duration may be imprecise.";
+        return kNoTimestamp();
+      }
+
+      break;
+    default:
+      LIMITED_MEDIA_LOG(log_cb_, num_duration_errors_, kMaxDurationLogs)
+          << "Unexpected Opus frame count type: " << frame_count_type << "; "
+          << "demuxed block duration may be imprecise.";
+      return kNoTimestamp();
+  }
+
+  int opusConfig = (data[0] & kTocConfigMask) >> 3;
+  CHECK_GE(opusConfig, 0);
+  CHECK_LT(opusConfig, static_cast<int>(arraysize(kOpusFrameDurationsMu)));
+
+  DCHECK_GT(frame_count, 0);
+  base::TimeDelta duration = base::TimeDelta::FromMicroseconds(
+      kOpusFrameDurationsMu[opusConfig] * frame_count);
+
+  if (duration > kPacketDurationMax) {
+    // Intentionally allowing packet to pass through for now. Decoder should
+    // either handle or fail gracefully. MEDIA_LOG as breadcrumbs in case
+    // things go sideways.
+    LIMITED_MEDIA_LOG(log_cb_, num_duration_errors_, kMaxDurationLogs)
+        << "Warning, demuxed Opus packet with encoded duration: " << duration
+        << ". Should be no greater than " << kPacketDurationMax;
+  }
+
+  return duration;
+}
+
 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;
@@ skipping 45 matching lines @@
       break;
     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,
+bool WebMClusterParser::ParseBlock(bool is_simple_block,
+                                   const uint8_t* buf,
+                                   int size,
+                                   const uint8_t* additional,
+                                   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;
+  const uint8_t* 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,
                  discard_padding);
 }
 
-bool WebMClusterParser::OnBinary(int id, const uint8* data, int size) {
+bool WebMClusterParser::OnBinary(int id, const uint8_t* data, int size) {
   switch (id) {
     case kWebMIdSimpleBlock:
       return ParseBlock(true, data, size, NULL, 0, -1, 0);
 
     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]);
+      block_data_.reset(new uint8_t[size]);
       memcpy(block_data_.get(), data, size);
       block_data_size_ = size;
       return true;
 
     case kWebMIdBlockAdditional: {
       uint64 block_add_id = base::HostToNet64(block_add_id_);
       if (block_additional_data_) {
         // TODO(vigneshv): Technically, more than 1 BlockAdditional is allowed
         // as per matroska spec. But for now we don't have a use case to
         // support parsing of such files. Take a look at this again when such a
         // case arises.
         MEDIA_LOG(log_cb_) << "More than 1 BlockAdditional in a BlockGroup is "
                               "not supported.";
         return false;
       }
       // First 8 bytes of side_data in DecoderBuffer is the BlockAddID
       // element's value in Big Endian format. This is done to mimic ffmpeg
       // demuxer's behavior.
       block_additional_data_size_ = size + sizeof(block_add_id);
-      block_additional_data_.reset(new uint8[block_additional_data_size_]);
+      block_additional_data_.reset(new uint8_t[block_additional_data_size_]);
       memcpy(block_additional_data_.get(), &block_add_id,
              sizeof(block_add_id));
       memcpy(block_additional_data_.get() + 8, data, size);
       return true;
     }
     case kWebMIdDiscardPadding: {
       if (discard_padding_set_ || size <= 0 || size > 8)
         return false;
       discard_padding_set_ = true;
 
       // Read in the big-endian integer.
       discard_padding_ = static_cast<int8>(data[0]);
       for (int i = 1; i < size; ++i)
         discard_padding_ = (discard_padding_ << 8) | data[i];
 
       return true;
     }
     default:
       return true;
   }
 }
 
-bool WebMClusterParser::OnBlock(bool is_simple_block, int track_num,
+bool WebMClusterParser::OnBlock(bool is_simple_block,
+                                int track_num,
                                 int timecode,
-                                int  block_duration,
+                                int block_duration,
                                 int flags,
-                                const uint8* data, int size,
-                                const uint8* additional, int additional_size,
+                                const uint8_t* data,
+                                int size,
+                                const uint8_t* 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 "
                        << timecode;
     return false;
   }
 
   if (last_block_timecode_ != -1 && timecode < last_block_timecode_) {
     MEDIA_LOG(log_cb_)
         << "Got a block with a timecode before the previous block.";
     return false;
   }
 
   Track* track = NULL;
   StreamParserBuffer::Type buffer_type = DemuxerStream::AUDIO;
   std::string encryption_key_id;
+  base::TimeDelta encoded_duration = kNoTimestamp();
   if (track_num == audio_.track_num()) {
     track = &audio_;
     encryption_key_id = audio_encryption_key_id_;
+    if (encryption_key_id.empty()) {
+      encoded_duration = TryGetEncodedAudioDuration(data, size);
+    }
   } else if (track_num == video_.track_num()) {
     track = &video_;
     encryption_key_id = video_encryption_key_id_;
     buffer_type = DemuxerStream::VIDEO;
   } else if (ignored_tracks_.find(track_num) != ignored_tracks_.end()) {
     return true;
   } else if (Track* const text_track = FindTextTrack(track_num)) {
     if (is_simple_block)  // BlockGroup is required for WebVTT cues
       return false;
     if (block_duration < 0)  // not specified
@@ skipping 20 matching lines @@
         is_simple_block ? (flags & 0x80) != 0 : track->IsKeyframe(data, size);
 
     // Every encrypted Block has a signal byte and IV prepended to it. Current
     // encrypted WebM request for comments specification is here
     // http://wiki.webmproject.org/encryption/webm-encryption-rfc
     scoped_ptr<DecryptConfig> decrypt_config;
     int data_offset = 0;
     if (!encryption_key_id.empty() &&
         !WebMCreateDecryptConfig(
              data, size,
-             reinterpret_cast<const uint8*>(encryption_key_id.data()),
+             reinterpret_cast<const uint8_t*>(encryption_key_id.data()),
              encryption_key_id.size(),
              &decrypt_config, &data_offset)) {
       return false;
     }
 
     // TODO(wolenetz/acolwell): Validate and use a common cross-parser TrackId
     // type with remapped bytestream track numbers and allow multiple tracks as
     // applicable. See https://crbug.com/341581.
     buffer = StreamParserBuffer::CopyFrom(
         data + data_offset, size - data_offset,
         additional, additional_size,
         is_keyframe, buffer_type, track_num);
 
     if (decrypt_config)
       buffer->set_decrypt_config(decrypt_config.Pass());
   } else {
     std::string id, settings, content;
     WebMWebVTTParser::Parse(data, size, &id, &settings, &content);
 
-    std::vector<uint8> side_data;
+    std::vector<uint8_t> side_data;
     MakeSideData(id.begin(), id.end(),
                  settings.begin(), settings.end(),
                  &side_data);
 
     // TODO(wolenetz/acolwell): Validate and use a common cross-parser TrackId
     // type with remapped bytestream track numbers and allow multiple tracks as
     // applicable. See https://crbug.com/341581.
     buffer = StreamParserBuffer::CopyFrom(
-        reinterpret_cast<const uint8*>(content.data()),
+        reinterpret_cast<const uint8_t*>(content.data()),
         content.length(),
         &side_data[0],
         side_data.size(),
         true, buffer_type, track_num);
   }
 
   buffer->set_timestamp(timestamp);
   if (cluster_start_time_ == kNoTimestamp())
     cluster_start_time_ = timestamp;
 
+  base::TimeDelta block_duration_time_delta = kNoTimestamp();
   if (block_duration >= 0) {
-    buffer->set_duration(base::TimeDelta::FromMicroseconds(
-        block_duration * timecode_multiplier_));
+    block_duration_time_delta = base::TimeDelta::FromMicroseconds(
+        block_duration * timecode_multiplier_);
+  }
+
+  // Prefer encoded duration over BlockGroup->BlockDuration or
+  // TrackEntry->DefaultDuration when available. This layering violation is a
+  // workaround for http://crbug.com/396634, decreasing the likelihood of
+  // fall-back to rough estimation techniques for Blocks that lack a
+  // BlockDuration at the end of a cluster. Cross cluster durations are not
+  // feasible given flexibility of cluster ordering and MSE APIs. Duration
+  // estimation may still apply in cases of encryption and codecs for which
+  // we do not extract encoded duration. Within a cluster, estimates are applied
+  // as Block Timecode deltas, or once the whole cluster is parsed in the case
+  // of the last Block in the cluster. See Track::AddBuffer and
+  // ApplyDurationEstimateIfNeeded().
+  if (encoded_duration != kNoTimestamp()) {
+    DCHECK(encoded_duration != kInfiniteDuration());
+    DCHECK(encoded_duration > base::TimeDelta());
+    buffer->set_duration(encoded_duration);
+
+    DVLOG(3) << __FUNCTION__ << " : "
+             << "Using encoded duration " << encoded_duration.InSecondsF();
+
+    if (block_duration_time_delta != kNoTimestamp()) {
+      base::TimeDelta duration_difference =
+          block_duration_time_delta - encoded_duration;
+
+      const auto kWarnDurationDiff =
+          base::TimeDelta::FromMicroseconds(timecode_multiplier_ * 2);
+      if (duration_difference.magnitude() > kWarnDurationDiff) {
+        LIMITED_MEDIA_LOG(log_cb_, num_duration_errors_, kMaxDurationLogs)
+            << "BlockDuration "
+            << "(" << block_duration_time_delta << ") "
+            << "differs significantly from encoded duration "
+            << "(" << encoded_duration << ").";
+      }
+    }
+  } else if (block_duration_time_delta != kNoTimestamp()) {
+    buffer->set_duration(block_duration_time_delta);
   } else {
     DCHECK_NE(buffer_type, DemuxerStream::TEXT);
     buffer->set_duration(track->default_duration());
   }
 
   if (discard_padding != 0) {
     buffer->set_discard_padding(std::make_pair(
         base::TimeDelta(),
         base::TimeDelta::FromMicroseconds(discard_padding / 1000)));
   }
@@ skipping 119 matching lines @@
   // reset here.
   ready_buffers_.clear();
 }
 
 void WebMClusterParser::Track::Reset() {
   ClearReadyBuffers();
   buffers_.clear();
   last_added_buffer_missing_duration_ = NULL;
 }
 
-bool WebMClusterParser::Track::IsKeyframe(const uint8* data, int size) const {
+bool WebMClusterParser::Track::IsKeyframe(const uint8_t* data, int size) const {
   // For now, assume that all blocks are keyframes for datatypes other than
   // video. This is a valid assumption for Vorbis, WebVTT, & Opus.
   if (!is_video_)
     return true;
 
   // Make sure the block is big enough for the minimal keyframe header size.
   if (size < 7)
     return false;
 
   // The LSb of the first byte must be a 0 for a keyframe.
@@ skipping 115 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