Convert media constants to constexpr.

media/filters/frame_processor.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/filters/frame_processor.h"
 
 #include <stdint.h>
 
 #include <cstdlib>
 
@@ skipping 65 matching lines @@
   // Adds |frame| to the end of |processed_frames_|.
   void EnqueueProcessedFrame(const scoped_refptr<StreamParserBuffer>& frame);
 
   // Appends |processed_frames_|, if not empty, to |stream_| and clears
   // |processed_frames_|. Returns false if append failed, true otherwise.
   // |processed_frames_| is cleared in both cases.
   bool FlushProcessedFrames();
 
  private:
   // The decode timestamp of the last coded frame appended in the current coded
-  // frame group. Initially kNoTimestamp(), meaning "unset".
+  // frame group. Initially kNoTimestamp, meaning "unset".
   DecodeTimestamp last_decode_timestamp_;
 
   // The coded frame duration of the last coded frame appended in the current
-  // coded frame group. Initially kNoTimestamp(), meaning "unset".
+  // coded frame group. Initially kNoTimestamp, meaning "unset".
   base::TimeDelta last_frame_duration_;
 
   // The highest presentation timestamp encountered in a coded frame appended
-  // in the current coded frame group. Initially kNoTimestamp(), meaning
+  // in the current coded frame group. Initially kNoTimestamp, meaning
   // "unset".
   base::TimeDelta highest_presentation_timestamp_;
 
   // Keeps track of whether the track buffer is waiting for a random access
   // point coded frame. Initially set to true to indicate that a random access
   // point coded frame is needed before anything can be added to the track
   // buffer.
   bool needs_random_access_point_;
 
   // Pointer to the stream associated with this track. The stream is not owned
   // by |this|.
   ChunkDemuxerStream* const stream_;
 
   // Queue of processed frames that have not yet been appended to |stream_|.
   // EnqueueProcessedFrame() adds to this queue, and FlushProcessedFrames()
   // clears it.
   StreamParser::BufferQueue processed_frames_;
 
   DISALLOW_COPY_AND_ASSIGN(MseTrackBuffer);
 };
 
 MseTrackBuffer::MseTrackBuffer(ChunkDemuxerStream* stream)
     : last_decode_timestamp_(kNoDecodeTimestamp()),
-      last_frame_duration_(kNoTimestamp()),
-      highest_presentation_timestamp_(kNoTimestamp()),
+      last_frame_duration_(kNoTimestamp),
+      highest_presentation_timestamp_(kNoTimestamp),
       needs_random_access_point_(true),
       stream_(stream) {
   DCHECK(stream_);
 }
 
 MseTrackBuffer::~MseTrackBuffer() {
   DVLOG(2) << __FUNCTION__ << "()";
 }
 
 void MseTrackBuffer::Reset() {
   DVLOG(2) << __FUNCTION__ << "()";
 
   last_decode_timestamp_ = kNoDecodeTimestamp();
-  last_frame_duration_ = kNoTimestamp();
-  highest_presentation_timestamp_ = kNoTimestamp();
+  last_frame_duration_ = kNoTimestamp;
+  highest_presentation_timestamp_ = kNoTimestamp;
   needs_random_access_point_ = true;
 }
 
 void MseTrackBuffer::SetHighestPresentationTimestampIfIncreased(
     base::TimeDelta timestamp) {
-  if (highest_presentation_timestamp_ == kNoTimestamp() ||
+  if (highest_presentation_timestamp_ == kNoTimestamp ||
       timestamp > highest_presentation_timestamp_) {
     highest_presentation_timestamp_ = timestamp;
   }
 }
 
 void MseTrackBuffer::EnqueueProcessedFrame(
     const scoped_refptr<StreamParserBuffer>& frame) {
   processed_frames_.push_back(frame);
 }
 
 bool MseTrackBuffer::FlushProcessedFrames() {
   if (processed_frames_.empty())
     return true;
 
   bool result = stream_->Append(processed_frames_);
   processed_frames_.clear();
 
   DVLOG_IF(3, !result) << __FUNCTION__
                        << "(): Failure appending processed frames to stream";
 
   return result;
 }
 
 FrameProcessor::FrameProcessor(const UpdateDurationCB& update_duration_cb,
                                const scoped_refptr<MediaLog>& media_log)
-    : group_start_timestamp_(kNoTimestamp()),
+    : group_start_timestamp_(kNoTimestamp),
       update_duration_cb_(update_duration_cb),
       media_log_(media_log) {
   DVLOG(2) << __FUNCTION__ << "()";
   DCHECK(!update_duration_cb.is_null());
 }
 
 FrameProcessor::~FrameProcessor() {
   DVLOG(2) << __FUNCTION__ << "()";
   STLDeleteValues(&track_buffers_);
 }
 
 void FrameProcessor::SetSequenceMode(bool sequence_mode) {
   DVLOG(2) << __FUNCTION__ << "(" << sequence_mode << ")";
   // Per June 9, 2016 MSE spec editor's draft:
   // https://rawgit.com/w3c/media-source/d8f901f22/
   //     index.html#widl-SourceBuffer-mode
   // Step 7: If the new mode equals "sequence", then set the group start
   // timestamp to the group end timestamp.
   if (sequence_mode) {
-    DCHECK(kNoTimestamp() != group_end_timestamp_);
+    DCHECK(kNoTimestamp != group_end_timestamp_);
     group_start_timestamp_ = group_end_timestamp_;
   } else if (sequence_mode_) {
     // We're switching from 'sequence' to 'segments' mode. Be safe and signal a
     // new coded frame group on the next frame emitted.
     coded_frame_group_last_dts_ = kNoDecodeTimestamp();
   }
 
   // Step 8: Update the attribute to new mode.
   sequence_mode_ = sequence_mode;
 }
@@ skipping 38 matching lines @@
   //    the duration change algorithm with new duration set to the maximum of
   //    the current duration and the group end timestamp.
   update_duration_cb_.Run(group_end_timestamp_);
 
   return true;
 }
 
 void FrameProcessor::SetGroupStartTimestampIfInSequenceMode(
     base::TimeDelta timestamp_offset) {
   DVLOG(2) << __FUNCTION__ << "(" << timestamp_offset.InSecondsF() << ")";
-  DCHECK(kNoTimestamp() != timestamp_offset);
+  DCHECK(kNoTimestamp != timestamp_offset);
   if (sequence_mode_)
     group_start_timestamp_ = timestamp_offset;
 
   // Changes to timestampOffset should invalidate the preroll buffer.
   audio_preroll_buffer_ = NULL;
 }
 
 bool FrameProcessor::AddTrack(StreamParser::TrackId id,
                               ChunkDemuxerStream* stream) {
   DVLOG(2) << __FUNCTION__ << "(): id=" << id;
@@ skipping 44 matching lines @@
   // sequence mode. Reset it here only if in segments mode. In sequence mode,
   // the current coded frame group may be continued across Reset() operations to
   // allow the stream to coaelesce what might otherwise be gaps in the buffered
   // ranges. See also the declaration for |coded_frame_group_last_dts_|.
   if (!sequence_mode_) {
     coded_frame_group_last_dts_ = kNoDecodeTimestamp();
     return;
   }
 
   // Sequence mode
-  DCHECK(kNoTimestamp() != group_end_timestamp_);
+  DCHECK(kNoTimestamp != group_end_timestamp_);
   group_start_timestamp_ = group_end_timestamp_;
 }
 
 void FrameProcessor::OnPossibleAudioConfigUpdate(
     const AudioDecoderConfig& config) {
   DCHECK(config.IsValidConfig());
 
   // Always clear the preroll buffer when a config update is received.
   audio_preroll_buffer_ = NULL;
 
@@ skipping 164 matching lines @@
 
     DVLOG(3) << __FUNCTION__ << ": Processing frame "
              << "Type=" << frame->type()
              << ", TrackID=" << frame->track_id()
              << ", PTS=" << presentation_timestamp.InSecondsF()
              << ", DTS=" << decode_timestamp.InSecondsF()
              << ", DUR=" << frame_duration.InSecondsF()
              << ", RAP=" << frame->is_key_frame();
 
     // Sanity check the timestamps.
-    if (presentation_timestamp == kNoTimestamp()) {
+    if (presentation_timestamp == kNoTimestamp) {
       MEDIA_LOG(ERROR, media_log_) << "Unknown PTS for " << frame->GetTypeName()
                                    << " frame";
       return false;
     }
     if (decode_timestamp == kNoDecodeTimestamp()) {
       MEDIA_LOG(ERROR, media_log_) << "Unknown DTS for " << frame->GetTypeName()
                                    << " frame";
       return false;
     }
     if (decode_timestamp.ToPresentationTime() > presentation_timestamp) {
       // TODO(wolenetz): Determine whether DTS>PTS should really be allowed. See
       // http://crbug.com/354518.
       LIMITED_MEDIA_LOG(DEBUG, media_log_, num_dts_beyond_pts_warnings_,
                         kMaxDtsBeyondPtsWarnings)
           << "Parsed " << frame->GetTypeName() << " frame has DTS "
           << decode_timestamp.InMicroseconds()
           << "us, which is after the frame's PTS "
           << presentation_timestamp.InMicroseconds() << "us";
       DVLOG(2) << __FUNCTION__ << ": WARNING: Frame DTS("
                << decode_timestamp.InSecondsF() << ") > PTS("
                << presentation_timestamp.InSecondsF()
                << "), frame type=" << frame->GetTypeName();
     }
 
     // All stream parsers must emit valid (non-negative) frame durations.
     // Note that duration of 0 can occur for at least WebM alt-ref frames.
-    if (frame_duration == kNoTimestamp()) {
+    if (frame_duration == kNoTimestamp) {
       MEDIA_LOG(ERROR, media_log_)
           << "Unknown duration for " << frame->GetTypeName() << " frame at PTS "
           << presentation_timestamp.InMicroseconds() << "us";
       return false;
     }
     if (frame_duration <  base::TimeDelta()) {
       MEDIA_LOG(ERROR, media_log_)
           << "Negative duration " << frame_duration.InMicroseconds()
           << "us for " << frame->GetTypeName() << " frame at PTS "
           << presentation_timestamp.InMicroseconds() << "us";
       return false;
     }
 
     // 3. If mode equals "sequence" and group start timestamp is set, then run
     //    the following steps:
-    if (sequence_mode_ && group_start_timestamp_ != kNoTimestamp()) {
+    if (sequence_mode_ && group_start_timestamp_ != kNoTimestamp) {
       // 3.1. Set timestampOffset equal to group start timestamp -
       //      presentation timestamp.
       *timestamp_offset = group_start_timestamp_ - presentation_timestamp;
 
       DVLOG(3) << __FUNCTION__ << ": updated timestampOffset is now "
                << timestamp_offset->InSecondsF();
 
       // 3.2. Set group end timestamp equal to group start timestamp.
       group_end_timestamp_ = group_start_timestamp_;
 
       // 3.3. Set the need random access point flag on all track buffers to
       //      true.
       SetAllTrackBuffersNeedRandomAccessPoint();
 
       // 3.4. Unset group start timestamp.
-      group_start_timestamp_ = kNoTimestamp();
+      group_start_timestamp_ = kNoTimestamp;
     }
 
     // 4. If timestampOffset is not 0, then run the following steps:
     if (!timestamp_offset->is_zero()) {
       // 4.1. Add timestampOffset to the presentation timestamp.
       // Note: |frame| PTS is only updated if it survives discontinuity
       // processing.
       presentation_timestamp += *timestamp_offset;
 
       // 4.2. Add timestampOffset to the decode timestamp.
@@ skipping 195 matching lines @@
     // Step 21 is currently handled differently. See MediaSourceState's
     // |auto_update_timestamp_offset_|.
     return true;
   }
 
   NOTREACHED();
   return false;
 }
 
 }  // namespace media