Convert media constants to constexpr.

media/base/audio_splicer.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/base/audio_splicer.h"
 
 #include <stdint.h>
 #include <cstdlib>
 #include <deque>
 #include <utility>
@@ skipping 106 matching lines @@
 };
 
 AudioStreamSanitizer::AudioStreamSanitizer(
     int samples_per_second,
     const scoped_refptr<MediaLog>& media_log)
     : output_timestamp_helper_(samples_per_second), media_log_(media_log) {}
 
 AudioStreamSanitizer::~AudioStreamSanitizer() {}
 
 void AudioStreamSanitizer::Reset() {
-  ResetTimestampState(0, kNoTimestamp());
+  ResetTimestampState(0, kNoTimestamp);
 }
 
 void AudioStreamSanitizer::ResetTimestampState(int64_t frame_count,
                                                base::TimeDelta base_timestamp) {
   output_buffers_.clear();
   received_end_of_stream_ = false;
   output_timestamp_helper_.SetBaseTimestamp(base_timestamp);
   if (frame_count > 0)
     output_timestamp_helper_.AddFrames(frame_count);
 }
 
 bool AudioStreamSanitizer::AddInput(const scoped_refptr<AudioBuffer>& input) {
   DCHECK(!received_end_of_stream_ || input->end_of_stream());
 
   if (input->end_of_stream()) {
     output_buffers_.push_back(input);
     received_end_of_stream_ = true;
     return true;
   }
 
-  DCHECK(input->timestamp() != kNoTimestamp());
+  DCHECK(input->timestamp() != kNoTimestamp);
   DCHECK(input->duration() > base::TimeDelta());
   DCHECK_GT(input->frame_count(), 0);
 
-  if (output_timestamp_helper_.base_timestamp() == kNoTimestamp())
+  if (output_timestamp_helper_.base_timestamp() == kNoTimestamp)
     output_timestamp_helper_.SetBaseTimestamp(input->timestamp());
 
   if (output_timestamp_helper_.base_timestamp() > input->timestamp()) {
     MEDIA_LOG(ERROR, media_log_)
         << "Audio splicing failed: unexpected timestamp sequence. base "
            "timestamp="
         << output_timestamp_helper_.base_timestamp().InMicroseconds()
         << "us, input timestamp=" << input->timestamp().InMicroseconds()
         << "us";
     return false;
@@ skipping 107 matching lines @@
     if (!output->AddInput(GetNextBuffer()))
       return false;
   }
   return true;
 }
 
 AudioSplicer::AudioSplicer(int samples_per_second,
                            const scoped_refptr<MediaLog>& media_log)
     : max_crossfade_duration_(
           base::TimeDelta::FromMilliseconds(kCrossfadeDurationInMilliseconds)),
-      splice_timestamp_(kNoTimestamp()),
-      max_splice_end_timestamp_(kNoTimestamp()),
+      splice_timestamp_(kNoTimestamp),
+      max_splice_end_timestamp_(kNoTimestamp),
       output_sanitizer_(
           new AudioStreamSanitizer(samples_per_second, media_log)),
       pre_splice_sanitizer_(
           new AudioStreamSanitizer(samples_per_second, media_log)),
       post_splice_sanitizer_(
           new AudioStreamSanitizer(samples_per_second, media_log)),
-      have_all_pre_splice_buffers_(false) {
-}
+      have_all_pre_splice_buffers_(false) {}
 
 AudioSplicer::~AudioSplicer() {}
 
 void AudioSplicer::Reset() {
   output_sanitizer_->Reset();
   pre_splice_sanitizer_->Reset();
   post_splice_sanitizer_->Reset();
   have_all_pre_splice_buffers_ = false;
   reset_splice_timestamps();
 }
 
 bool AudioSplicer::AddInput(const scoped_refptr<AudioBuffer>& input) {
   // If we're not processing a splice, add the input to the output queue.
-  if (splice_timestamp_ == kNoTimestamp()) {
+  if (splice_timestamp_ == kNoTimestamp) {
     DCHECK(!pre_splice_sanitizer_->HasNextBuffer());
     DCHECK(!post_splice_sanitizer_->HasNextBuffer());
     return output_sanitizer_->AddInput(input);
   }
 
   const AudioTimestampHelper& output_ts_helper =
       output_sanitizer_->timestamp_helper();
 
   if (!have_all_pre_splice_buffers_) {
     DCHECK(!input->end_of_stream());
@@ skipping 22 matching lines @@
     CHECK(splice_timestamp_ == input->timestamp());
 
   // At this point we have all the fade out preroll buffers from the decoder.
   // We now need to wait until we have enough data to perform the crossfade (or
   // we receive an end of stream).
   if (!post_splice_sanitizer_->AddInput(input))
     return false;
 
   // Ensure |output_sanitizer_| has a valid base timestamp so we can use it for
   // timestamp calculations.
-  if (output_ts_helper.base_timestamp() == kNoTimestamp()) {
+  if (output_ts_helper.base_timestamp() == kNoTimestamp) {
     output_sanitizer_->ResetTimestampState(
         0, pre_splice_sanitizer_->timestamp_helper().base_timestamp());
   }
 
   // If a splice frame was incorrectly marked due to poor demuxed timestamps, we
   // may not actually have a splice.  Here we check if any frames exist before
   // the splice.  In this case, just transfer all data to the output sanitizer.
   const int frames_before_splice =
-      output_ts_helper.base_timestamp() == kNoTimestamp()
+      output_ts_helper.base_timestamp() == kNoTimestamp
           ? 0
           : output_ts_helper.GetFramesToTarget(splice_timestamp_);
   if (frames_before_splice < 0 ||
       pre_splice_sanitizer_->GetFrameCount() <= frames_before_splice) {
     CHECK(pre_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
 
     // If the file contains incorrectly muxed timestamps, there may be huge gaps
     // between the demuxed and decoded timestamps.
     if (!post_splice_sanitizer_->DrainInto(output_sanitizer_.get()))
       return false;
@@ skipping 23 matching lines @@
 
 bool AudioSplicer::HasNextBuffer() const {
   return output_sanitizer_->HasNextBuffer();
 }
 
 scoped_refptr<AudioBuffer> AudioSplicer::GetNextBuffer() {
   return output_sanitizer_->GetNextBuffer();
 }
 
 void AudioSplicer::SetSpliceTimestamp(base::TimeDelta splice_timestamp) {
-  if (splice_timestamp == kNoTimestamp()) {
-    DCHECK(splice_timestamp_ != kNoTimestamp());
+  if (splice_timestamp == kNoTimestamp) {
+    DCHECK(splice_timestamp_ != kNoTimestamp);
     DCHECK(!have_all_pre_splice_buffers_);
     have_all_pre_splice_buffers_ = true;
     return;
   }
 
   if (splice_timestamp_ == splice_timestamp)
     return;
 
   // TODO(dalecurtis): We may need the concept of a future_splice_timestamp_ to
   // handle cases where another splice comes in before we've received 5ms of
   // data from the last one.  Leave this as a CHECK for now to figure out if
   // this case is possible.
-  CHECK(splice_timestamp_ == kNoTimestamp());
+  CHECK(splice_timestamp_ == kNoTimestamp);
   splice_timestamp_ = splice_timestamp;
   max_splice_end_timestamp_ = splice_timestamp_ + max_crossfade_duration_;
   pre_splice_sanitizer_->Reset();
   post_splice_sanitizer_->Reset();
   have_all_pre_splice_buffers_ = false;
 }
 
 std::unique_ptr<AudioBus> AudioSplicer::ExtractCrossfadeFromPreSplice(
     scoped_refptr<AudioBuffer>* crossfade_buffer) {
   DCHECK(crossfade_buffer);
@@ skipping 128 matching lines @@
     AccurateTrimStart(frames_to_trim, remainder, output_ts_helper);
     CHECK(output_sanitizer_->AddInput(remainder));
   }
 
   // Transfer all remaining buffers out and reset once empty.
   CHECK(post_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
   post_splice_sanitizer_->Reset();
 }
 
 }  // namespace media