Convert media constants to constexpr.

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 <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 34 matching lines @@
     const std::string& audio_encryption_key_id,
     const std::string& video_encryption_key_id,
     const AudioCodec audio_codec,
     const scoped_refptr<MediaLog>& media_log)
     : 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),
-      cluster_start_time_(kNoTimestamp()),
+      cluster_start_time_(kNoTimestamp),
       audio_(audio_track_num, false, audio_default_duration, media_log),
       video_(video_track_num, true, video_default_duration, media_log),
       ready_buffer_upper_bound_(kNoDecodeTimestamp()),
       media_log_(media_log) {
   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, kNoTimestamp(), media_log_)));
+        it->first, Track(it->first, false, kNoTimestamp, media_log_)));
   }
 }
 
 WebMClusterParser::~WebMClusterParser() {}
 
 void WebMClusterParser::Reset() {
   last_block_timecode_ = -1;
   cluster_timecode_ = -1;
-  cluster_start_time_ = kNoTimestamp();
+  cluster_start_time_ = kNoTimestamp;
   cluster_ended_ = false;
   parser_.Reset();
   audio_.Reset();
   video_.Reset();
   ResetTextTracks();
   ready_buffer_upper_bound_ = kNoDecodeTimestamp();
 }
 
 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;
   }
 
   cluster_ended_ = parser_.IsParsingComplete();
   if (cluster_ended_) {
     // If there were no buffers in this cluster, set the cluster start time to
     // be the |cluster_timecode_|.
-    if (cluster_start_time_ == kNoTimestamp()) {
+    if (cluster_start_time_ == kNoTimestamp) {
       // If the cluster did not even have a |cluster_timecode_|, signal parse
       // error.
       if (cluster_timecode_ < 0)
         return -1;
 
       cluster_start_time_ = base::TimeDelta::FromMicroseconds(
           cluster_timecode_ * timecode_multiplier_);
     }
 
     // Reset the parser if we're done parsing so that
@@ skipping 51 matching lines @@
   // TODO(chcunningham): Consider parsing "Signal Byte" for encrypted streams
   // to return duration for any unencrypted blocks.
 
   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();
+  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(DEBUG, media_log_, num_duration_errors_,
                       kMaxDurationErrorLogs)
         << "Invalid zero-byte Opus packet; demuxed block duration may be "
            "imprecise.";
-    return kNoTimestamp();
+    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(DEBUG, media_log_, num_duration_errors_,
                           kMaxDurationErrorLogs)
             << "Second byte missing from 'Code 3' Opus packet; demuxed block "
                "duration may be imprecise.";
-        return kNoTimestamp();
+        return kNoTimestamp;
       }
 
       frame_count = data[1] & kFrameCountMask;
 
       if (frame_count == 0) {
         LIMITED_MEDIA_LOG(DEBUG, media_log_, num_duration_errors_,
                           kMaxDurationErrorLogs)
             << "Illegal 'Code 3' Opus packet with frame count zero; demuxed "
                "block duration may be imprecise.";
-        return kNoTimestamp();
+        return kNoTimestamp;
       }
 
       break;
     default:
       LIMITED_MEDIA_LOG(DEBUG, media_log_, num_duration_errors_,
                         kMaxDurationErrorLogs)
           << "Unexpected Opus frame count type: " << frame_count_type << "; "
           << "demuxed block duration may be imprecise.";
-      return kNoTimestamp();
+      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(DEBUG, media_log_, num_duration_errors_,
                       kMaxDurationErrorLogs)
         << "Warning, demuxed Opus packet with encoded duration: "
         << duration.InMilliseconds() << "ms. Should be no greater than "
         << kPacketDurationMax.InMilliseconds() << "ms.";
   }
 
   return duration;
 }
 
 WebMParserClient* WebMClusterParser::OnListStart(int id) {
   if (id == kWebMIdCluster) {
     cluster_timecode_ = -1;
-    cluster_start_time_ = kNoTimestamp();
+    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;
     reference_block_set_ = false;
   } else if (id == kWebMIdBlockAdditions) {
     block_add_id_ = -1;
     block_additional_data_.reset();
@@ skipping 185 matching lines @@
 
   if (last_block_timecode_ != -1 && timecode < last_block_timecode_) {
     MEDIA_LOG(ERROR, media_log_)
         << "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();
+  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;
@@ skipping 56 matching lines @@
     // applicable. See https://crbug.com/341581.
     buffer = StreamParserBuffer::CopyFrom(
         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())
+  if (cluster_start_time_ == kNoTimestamp)
     cluster_start_time_ = timestamp;
 
-  base::TimeDelta block_duration_time_delta = kNoTimestamp();
+  base::TimeDelta block_duration_time_delta = kNoTimestamp;
   if (block_duration >= 0) {
     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());
+  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()) {
+    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(DEBUG, media_log_, num_duration_errors_,
                           kMaxDurationErrorLogs)
             << "BlockDuration (" << block_duration_time_delta.InMilliseconds()
             << "ms) differs significantly from encoded duration ("
             << encoded_duration.InMilliseconds() << "ms).";
       }
     }
-  } else if (block_duration_time_delta != kNoTimestamp()) {
+  } 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)));
   }
 
   return track->AddBuffer(buffer);
 }
 
 WebMClusterParser::Track::Track(int track_num,
                                 bool is_video,
                                 base::TimeDelta default_duration,
                                 const scoped_refptr<MediaLog>& media_log)
     : track_num_(track_num),
       is_video_(is_video),
       default_duration_(default_duration),
-      estimated_next_frame_duration_(kNoTimestamp()),
+      estimated_next_frame_duration_(kNoTimestamp),
       media_log_(media_log) {
-  DCHECK(default_duration_ == kNoTimestamp() ||
+  DCHECK(default_duration_ == kNoTimestamp ||
          default_duration_ > base::TimeDelta());
 }
 
 WebMClusterParser::Track::Track(const Track& other) = default;
 
 WebMClusterParser::Track::~Track() {}
 
 DecodeTimestamp WebMClusterParser::Track::GetReadyUpperBound() {
   DCHECK(ready_buffers_.empty());
   if (last_added_buffer_missing_duration_.get())
@@ skipping 56 matching lines @@
              << last_added_buffer_missing_duration_->duration().InSecondsF()
              << " kf " << last_added_buffer_missing_duration_->is_key_frame()
              << " size " << last_added_buffer_missing_duration_->data_size();
     scoped_refptr<StreamParserBuffer> updated_buffer =
         last_added_buffer_missing_duration_;
     last_added_buffer_missing_duration_ = NULL;
     if (!QueueBuffer(updated_buffer))
       return false;
   }
 
-  if (buffer->duration() == kNoTimestamp()) {
+  if (buffer->duration() == kNoTimestamp) {
     last_added_buffer_missing_duration_ = buffer;
     DVLOG(2) << "AddBuffer() : holding back buffer that is missing duration";
     return true;
   }
 
   return QueueBuffer(buffer);
 }
 
 void WebMClusterParser::Track::ApplyDurationEstimateIfNeeded() {
   if (!last_added_buffer_missing_duration_.get())
@@ skipping 48 matching lines @@
   DCHECK(!last_added_buffer_missing_duration_.get());
 
   // WebMClusterParser::OnBlock() gives MEDIA_LOG and parse error on decreasing
   // block timecode detection within a cluster. Therefore, we should not see
   // those here.
   DecodeTimestamp previous_buffers_timestamp = buffers_.empty() ?
       DecodeTimestamp() : buffers_.back()->GetDecodeTimestamp();
   CHECK(previous_buffers_timestamp <= buffer->GetDecodeTimestamp());
 
   base::TimeDelta duration = buffer->duration();
-  if (duration < base::TimeDelta() || duration == kNoTimestamp()) {
+  if (duration < base::TimeDelta() || duration == kNoTimestamp) {
     MEDIA_LOG(ERROR, media_log_)
         << "Invalid buffer duration: " << duration.InSecondsF();
     return false;
   }
 
   // The estimated frame duration is the minimum (for audio) or the maximum
   // (for video) non-zero duration since the last initialization segment. The
   // minimum is used for audio to ensure frame durations aren't overestimated,
   // triggering unnecessary frame splicing. For video, splicing does not apply,
   // so maximum is used and overlap is simply resolved by showing the
   // later of the overlapping frames at its given PTS, effectively trimming down
   // the over-estimated duration of the previous frame.
   // TODO(chcunningham): Use max for audio and disable splicing whenever
   // estimated buffers are encountered.
   if (duration > base::TimeDelta()) {
     base::TimeDelta orig_duration_estimate = estimated_next_frame_duration_;
-    if (estimated_next_frame_duration_ == kNoTimestamp()) {
+    if (estimated_next_frame_duration_ == kNoTimestamp) {
       estimated_next_frame_duration_ = duration;
     } else if (is_video_) {
       estimated_next_frame_duration_ =
           std::max(duration, estimated_next_frame_duration_);
     } else {
       estimated_next_frame_duration_ =
           std::min(duration, estimated_next_frame_duration_);
     }
 
     if (orig_duration_estimate != estimated_next_frame_duration_) {
       DVLOG(3) << "Updated duration estimate:"
                << orig_duration_estimate
                << " -> "
                << estimated_next_frame_duration_
                << " at timestamp: "
                << buffer->GetDecodeTimestamp().InSecondsF();
     }
   }
 
   buffers_.push_back(buffer);
   return true;
 }
 
 base::TimeDelta WebMClusterParser::Track::GetDurationEstimate() {
   base::TimeDelta duration = estimated_next_frame_duration_;
-  if (duration != kNoTimestamp()) {
+  if (duration != kNoTimestamp) {
     DVLOG(3) << __FUNCTION__ << " : using estimated duration";
   } else {
     DVLOG(3) << __FUNCTION__ << " : using hardcoded default duration";
     if (is_video_) {
       duration = base::TimeDelta::FromMilliseconds(
           kDefaultVideoBufferDurationInMs);
     } else {
       duration = base::TimeDelta::FromMilliseconds(
           kDefaultAudioBufferDurationInMs);
     }
   }
 
   DCHECK(duration > base::TimeDelta());
-  DCHECK(duration != kNoTimestamp());
+  DCHECK(duration != kNoTimestamp);
   return duration;
 }
 
 void WebMClusterParser::ClearTextTrackReadyBuffers() {
   text_buffers_map_.clear();
   for (TextTrackMap::iterator it = text_track_map_.begin();
        it != text_track_map_.end();
        ++it) {
     it->second.ClearReadyBuffers();
   }
@@ skipping 43 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