MSE: Parse WebM TrackEntry DefaultDuration field

media/formats/webm/webm_tracks_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_tracks_parser.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "media/base/buffers.h"
@@ skipping 11 matching lines @@
 
   if (codec_id == kWebMCodecDescriptions)
     return kTextDescriptions;
 
   if (codec_id == kWebMCodecMetadata)
     return kTextMetadata;
 
   return kTextNone;
 }
 
+static base::TimeDelta PrecisionCappedDefaultDuration(
+    const double timecode_scale_in_us, const int64 duration_in_ns) {
+  if (duration_in_ns <= 0)
+    return kNoTimestamp();
+
+  double mult = duration_in_ns / 1000.0;

[acolwell GONE FROM CHROMIUM, 2014/03/26 22:25:32]

nit: Do you really need the double here? Any fraction part from this division
will just get smaller on the following line and totally eliminated on the line
after that.

[wolenetz, 2014/03/27 01:21:43]

Say we have default webm timecode scale_in_us of 1000.0, and a common
duration_in_ns corresponding to 29.97 fps = 33366700. Capped precision of this
default duration should then be 33ms. Let's work through the proposed
calculation:
int64 mult = 33366700 / 1000; (= 33366)
// mult is not less than 1000, so we don't return kNoTimestamp();
But, we return a default duration TimeDelta that has too much precision
(33.366ms, not 33ms).

So I think using int64 and dropping the std::floor() is ok, but we need the
division + multiplication to enforce the precision cap.

+  mult /= timecode_scale_in_us;
+  mult = std::floor(mult);
+  if (mult == 0.0)

[acolwell GONE FROM CHROMIUM, 2014/03/26 22:25:32]

nit: if you don't do line 38 can't this just become mul < timecode_scale_in_us
and then you don't need the multiply below?

[wolenetz, 2014/03/27 01:21:43]

I don't think so. See previous comment's reply.

+    return kNoTimestamp();
+
+  mult *= timecode_scale_in_us;
+  return base::TimeDelta::FromMicroseconds(mult);
+}
+
 WebMTracksParser::WebMTracksParser(const LogCB& log_cb, bool ignore_text_tracks)
     : track_type_(-1),
       track_num_(-1),
       track_uid_(-1),
       seek_preroll_(-1),
       codec_delay_(-1),
+      default_duration_(-1),
       audio_track_num_(-1),
+      audio_default_duration_(-1),
       video_track_num_(-1),
+      video_default_duration_(-1),
       ignore_text_tracks_(ignore_text_tracks),
       log_cb_(log_cb),
       audio_client_(log_cb),
       video_client_(log_cb) {
 }
 
 WebMTracksParser::~WebMTracksParser() {}
 
 int WebMTracksParser::Parse(const uint8* buf, int size) {
   track_type_ =-1;
   track_num_ = -1;
   track_uid_ = -1;
+  default_duration_ = -1;
   track_name_.clear();
   track_language_.clear();
   audio_track_num_ = -1;
+  audio_default_duration_ = -1;
   audio_decoder_config_ = AudioDecoderConfig();
   video_track_num_ = -1;
+  video_default_duration_ = -1;
   video_decoder_config_ = VideoDecoderConfig();
   text_tracks_.clear();
   ignored_tracks_.clear();
 
   WebMListParser parser(kWebMIdTracks, this);
   int result = parser.Parse(buf, size);
 
   if (result <= 0)
     return result;
 
   // For now we do all or nothing parsing.
   return parser.IsParsingComplete() ? result : 0;
 }
 
+base::TimeDelta WebMTracksParser::GetAudioDefaultDuration(
+    const double timecode_scale_in_us) const {
+  return PrecisionCappedDefaultDuration(timecode_scale_in_us,
+                                        audio_default_duration_);
+}
+
+base::TimeDelta WebMTracksParser::GetVideoDefaultDuration(
+    const double timecode_scale_in_us) const {
+  return PrecisionCappedDefaultDuration(timecode_scale_in_us,
+                                        video_default_duration_);
+}
+
 WebMParserClient* WebMTracksParser::OnListStart(int id) {
   if (id == kWebMIdContentEncodings) {
     DCHECK(!track_content_encodings_client_.get());
     track_content_encodings_client_.reset(
         new WebMContentEncodingsClient(log_cb_));
     return track_content_encodings_client_->OnListStart(id);
   }
 
   if (id == kWebMIdTrackEntry) {
     track_type_ = -1;
     track_num_ = -1;
+    default_duration_ = -1;
     track_name_.clear();
     track_language_.clear();
     codec_id_ = "";
     codec_private_.clear();
     audio_client_.Reset();
     video_client_.Reset();
     return this;
   }
 
   if (id == kWebMIdAudio)
@@ skipping 66 matching lines @@
       // key id in the first ContentEncoding as the key id of the track.
       encryption_key_id = track_content_encodings_client_->
           content_encodings()[0]->encryption_key_id();
     }
 
     if (track_type_ == kWebMTrackTypeAudio) {
       if (audio_track_num_ == -1) {
         audio_track_num_ = track_num_;
         audio_encryption_key_id_ = encryption_key_id;
 
+        if (default_duration_ == 0) {
+          MEDIA_LOG(log_cb_) << "Illegal 0ns audio TrackEntry DefaultDuration";
+          return false;
+        }
+        audio_default_duration_ = default_duration_;
+
         DCHECK(!audio_decoder_config_.IsValidConfig());
         if (!audio_client_.InitializeConfig(
                 codec_id_, codec_private_, seek_preroll_, codec_delay_,
                 !audio_encryption_key_id_.empty(), &audio_decoder_config_)) {
           return false;
         }
       } else {
         MEDIA_LOG(log_cb_) << "Ignoring audio track " << track_num_;
         ignored_tracks_.insert(track_num_);
       }
     } else if (track_type_ == kWebMTrackTypeVideo) {
       if (video_track_num_ == -1) {
         video_track_num_ = track_num_;
         video_encryption_key_id_ = encryption_key_id;
 
+        if (default_duration_ == 0) {
+          MEDIA_LOG(log_cb_) << "Illegal 0ns video TrackEntry DefaultDuration";
+          return false;
+        }
+        video_default_duration_ = default_duration_;
+
         DCHECK(!video_decoder_config_.IsValidConfig());
         if (!video_client_.InitializeConfig(
                 codec_id_, codec_private_, !video_encryption_key_id_.empty(),
                 &video_decoder_config_)) {
           return false;
         }
       } else {
         MEDIA_LOG(log_cb_) << "Ignoring video track " << track_num_;
         ignored_tracks_.insert(track_num_);
       }
@@ skipping 10 matching lines @@
                                                    track_uid);
       }
     } else {
       MEDIA_LOG(log_cb_) << "Unexpected TrackType " << track_type_;
       return false;
     }
 
     track_type_ = -1;
     track_num_ = -1;
     track_uid_ = -1;
+    default_duration_ = -1;
     track_name_.clear();
     track_language_.clear();
     codec_id_ = "";
     codec_private_.clear();
     track_content_encodings_client_.reset();
 
     audio_client_.Reset();
     video_client_.Reset();
     return true;
   }
@@ skipping 13 matching lines @@
       break;
     case kWebMIdTrackUID:
       dst = &track_uid_;
       break;
     case kWebMIdSeekPreRoll:
       dst = &seek_preroll_;
       break;
     case kWebMIdCodecDelay:
       dst = &codec_delay_;
       break;
+    case kWebMIdDefaultDuration:
+      dst = &default_duration_;
+      break;
     default:
       return true;
   }
 
   if (*dst != -1) {
     MEDIA_LOG(log_cb_) << "Multiple values for id " << std::hex << id
                        << " specified";
     return false;
   }
 
@@ skipping 36 matching lines @@
 
   if (id == kWebMIdLanguage) {
     track_language_ = str;
     return true;
   }
 
   return true;
 }
 
 }  // namespace media