Convert media constants to constexpr.

media/filters/ffmpeg_demuxer.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/filters/ffmpeg_demuxer.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 51 matching lines @@
   return base::Time();
 }
 
 static base::TimeDelta FramesToTimeDelta(int frames, double sample_rate) {
   return base::TimeDelta::FromMicroseconds(
       frames * base::Time::kMicrosecondsPerSecond / sample_rate);
 }
 
 static base::TimeDelta ExtractStartTime(AVStream* stream,
                                         base::TimeDelta start_time_estimate) {
-  DCHECK(start_time_estimate != kNoTimestamp());
+  DCHECK(start_time_estimate != kNoTimestamp);
   if (stream->start_time == static_cast<int64_t>(AV_NOPTS_VALUE)) {
-    return start_time_estimate == kInfiniteDuration() ? kNoTimestamp()
-                                                      : start_time_estimate;
+    return start_time_estimate == kInfiniteDuration ? kNoTimestamp
+                                                    : start_time_estimate;
   }
 
   // First try the lower of the estimate and the |start_time| value.
   base::TimeDelta start_time =
       std::min(ConvertFromTimeBase(stream->time_base, stream->start_time),
                start_time_estimate);
 
   // Next see if the first buffered pts value is usable.
   if (stream->pts_buffer[0] != static_cast<int64_t>(AV_NOPTS_VALUE)) {
     const base::TimeDelta buffered_pts =
@@ skipping 101 matching lines @@
     return context->codec_descriptor->name;
   const AVCodecDescriptor* codec_descriptor =
       avcodec_descriptor_get(context->codec_id);
   // If the codec name can't be determined, return none for tracking.
   return codec_descriptor ? codec_descriptor->name : kCodecNone;
 }
 
 static void SetTimeProperty(MediaLogEvent* event,
                             const std::string& key,
                             base::TimeDelta value) {
-  if (value == kInfiniteDuration())
+  if (value == kInfiniteDuration)
     event->params.SetString(key, "kInfiniteDuration");
-  else if (value == kNoTimestamp())
+  else if (value == kNoTimestamp)
     event->params.SetString(key, "kNoTimestamp");
   else
     event->params.SetDouble(key, value.InSecondsF());
 }
 
 std::unique_ptr<FFmpegDemuxerStream> FFmpegDemuxerStream::Create(
     FFmpegDemuxer* demuxer,
     AVStream* stream,
     const scoped_refptr<MediaLog>& media_log) {
   if (!demuxer || !stream)
@@ skipping 52 matching lines @@
     std::unique_ptr<AudioDecoderConfig> audio_config,
     std::unique_ptr<VideoDecoderConfig> video_config)
     : demuxer_(demuxer),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       stream_(stream),
       audio_config_(audio_config.release()),
       video_config_(video_config.release()),
       type_(UNKNOWN),
       liveness_(LIVENESS_UNKNOWN),
       end_of_stream_(false),
-      last_packet_timestamp_(kNoTimestamp()),
-      last_packet_duration_(kNoTimestamp()),
+      last_packet_timestamp_(kNoTimestamp),
+      last_packet_duration_(kNoTimestamp),
       video_rotation_(VIDEO_ROTATION_0),
       is_enabled_(true),
       waiting_for_keyframe_(false),
       fixup_negative_timestamps_(false) {
   DCHECK(demuxer_);
 
   bool is_encrypted = false;
   int rotation = 0;
   AVDictionaryEntry* rotation_entry = NULL;
 
@@ skipping 149 matching lines @@
     const uint32_t* skip_samples_ptr =
         reinterpret_cast<const uint32_t*>(av_packet_get_side_data(
             packet.get(), AV_PKT_DATA_SKIP_SAMPLES, &skip_samples_size));
     const int kSkipSamplesValidSize = 10;
     const int kSkipEndSamplesOffset = 1;
     if (skip_samples_size >= kSkipSamplesValidSize) {
       // Because FFmpeg rolls codec delay and skip samples into one we can only
       // allow front discard padding on the first buffer.  Otherwise the discard
       // helper can't figure out which data to discard.  See AudioDiscardHelper.
       int discard_front_samples = base::ByteSwapToLE32(*skip_samples_ptr);
-      if (last_packet_timestamp_ != kNoTimestamp() && discard_front_samples) {
+      if (last_packet_timestamp_ != kNoTimestamp && discard_front_samples) {
         DLOG(ERROR) << "Skip samples are only allowed for the first packet.";
         discard_front_samples = 0;
       }
 
       const int discard_end_samples =
           base::ByteSwapToLE32(*(skip_samples_ptr + kSkipEndSamplesOffset));
       const int samples_per_second =
           audio_decoder_config().samples_per_second();
       buffer->set_discard_padding(std::make_pair(
           FramesToTimeDelta(discard_front_samples, samples_per_second),
           FramesToTimeDelta(discard_end_samples, samples_per_second)));
     }
 
     if (decrypt_config)
       buffer->set_decrypt_config(std::move(decrypt_config));
   }
 
   if (packet->duration >= 0) {
     buffer->set_duration(
         ConvertStreamTimestamp(stream_->time_base, packet->duration));
   } else {
     // TODO(wolenetz): Remove when FFmpeg stops returning negative durations.
     // https://crbug.com/394418
     DVLOG(1) << "FFmpeg returned a buffer with a negative duration! "
              << packet->duration;
-    buffer->set_duration(kNoTimestamp());
+    buffer->set_duration(kNoTimestamp);
   }
 
-  // Note: If pts is AV_NOPTS_VALUE, stream_timestamp will be kNoTimestamp().
+  // Note: If pts is AV_NOPTS_VALUE, stream_timestamp will be kNoTimestamp.
   const base::TimeDelta stream_timestamp =
       ConvertStreamTimestamp(stream_->time_base, packet->pts);
 
-  if (stream_timestamp != kNoTimestamp()) {
+  if (stream_timestamp != kNoTimestamp) {
     const bool is_audio = type() == AUDIO;
 
     // If this file has negative timestamps don't rebase any other stream types
     // against the negative starting time.
     base::TimeDelta start_time = demuxer_->start_time();
     if (fixup_negative_timestamps_ && !is_audio &&
         start_time < base::TimeDelta()) {
       start_time = base::TimeDelta();
     }
 
     // Don't rebase timestamps for positive start times, the HTML Media Spec
     // details this in section "4.8.10.6 Offsets into the media resource." We
     // will still need to rebase timestamps before seeking with FFmpeg though.
     if (start_time > base::TimeDelta())
       start_time = base::TimeDelta();
 
     buffer->set_timestamp(stream_timestamp - start_time);
 
     // If enabled, and no codec delay is present, mark audio packets with
     // negative timestamps for post-decode discard.
     if (fixup_negative_timestamps_ && is_audio &&
         stream_timestamp < base::TimeDelta() &&
-        buffer->duration() != kNoTimestamp()) {
+        buffer->duration() != kNoTimestamp) {
       if (!stream_->codec->delay) {
         DCHECK_EQ(buffer->discard_padding().first, base::TimeDelta());
 
         if (stream_timestamp + buffer->duration() < base::TimeDelta()) {
           DCHECK_EQ(buffer->discard_padding().second, base::TimeDelta());
 
           // Discard the entire packet if it's entirely before zero.
           buffer->set_discard_padding(
-              std::make_pair(kInfiniteDuration(), base::TimeDelta()));
+              std::make_pair(kInfiniteDuration, base::TimeDelta()));
         } else {
           // Only discard part of the frame if it overlaps zero.
           buffer->set_discard_padding(std::make_pair(
               -stream_timestamp, buffer->discard_padding().second));
         }
       } else {
         // Verify that codec delay would cover discard and that we don't need to
         // mark the packet for post decode discard.  Since timestamps may be in
         // milliseconds and codec delay in nanosecond precision, round up to the
         // nearest millisecond.  See enable_negative_timestamp_fixups().
         DCHECK_LE(-std::ceil(FramesToTimeDelta(
                                  audio_decoder_config().codec_delay(),
                                  audio_decoder_config().samples_per_second())
                                  .InMillisecondsF()),
                   stream_timestamp.InMillisecondsF());
       }
     }
   } else {
     // If this happens on the first packet, decoders will throw an error.
-    buffer->set_timestamp(kNoTimestamp());
+    buffer->set_timestamp(kNoTimestamp);
   }
 
-  if (last_packet_timestamp_ != kNoTimestamp()) {
+  if (last_packet_timestamp_ != kNoTimestamp) {
     // FFmpeg doesn't support chained ogg correctly.  Instead of guaranteeing
     // continuity across links in the chain it uses the timestamp information
     // from each link directly.  Doing so can lead to timestamps which appear to
     // go backwards in time.
     //
     // If the new link starts with a negative timestamp or a timestamp less than
     // the original (positive) |start_time|, we will get a negative timestamp
-    // here.  It's also possible FFmpeg returns kNoTimestamp() here if it's not
+    // here.  It's also possible FFmpeg returns kNoTimestamp here if it's not
     // able to work out a timestamp using the previous link and the next.
     //
     // Fixing chained ogg is non-trivial, so for now just reuse the last good
     // timestamp.  The decoder will rewrite the timestamps to be sample accurate
     // later.  See http://crbug.com/396864.
     if (fixup_negative_timestamps_ &&
-        (buffer->timestamp() == kNoTimestamp() ||
+        (buffer->timestamp() == kNoTimestamp ||
          buffer->timestamp() < last_packet_timestamp_)) {
       buffer->set_timestamp(last_packet_timestamp_ +
-                            (last_packet_duration_ != kNoTimestamp()
+                            (last_packet_duration_ != kNoTimestamp
                                  ? last_packet_duration_
                                  : base::TimeDelta::FromMicroseconds(1)));
     }
 
     // The demuxer should always output positive timestamps.
     DCHECK(buffer->timestamp() >= base::TimeDelta());
-    DCHECK(buffer->timestamp() != kNoTimestamp());
+    DCHECK(buffer->timestamp() != kNoTimestamp);
 
     if (last_packet_timestamp_ < buffer->timestamp()) {
       buffered_ranges_.Add(last_packet_timestamp_, buffer->timestamp());
       demuxer_->NotifyBufferingChanged();
     }
   }
 
   if (packet.get()->flags & AV_PKT_FLAG_KEY)
     buffer->set_is_key_frame(true);
 
@@ skipping 14 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(read_cb_.is_null()) << "There should be no pending read";
 
   // H264 and AAC require that we resend the header after flush.
   // Reset bitstream for converter to do so.
   // This is related to chromium issue 140371 (http://crbug.com/140371).
   ResetBitstreamConverter();
 
   buffer_queue_.Clear();
   end_of_stream_ = false;
-  last_packet_timestamp_ = kNoTimestamp();
-  last_packet_duration_ = kNoTimestamp();
+  last_packet_timestamp_ = kNoTimestamp;
+  last_packet_duration_ = kNoTimestamp;
 }
 
 void FFmpegDemuxerStream::Stop() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   buffer_queue_.Clear();
   if (!read_cb_.is_null()) {
     base::ResetAndReturn(&read_cb_).Run(
         DemuxerStream::kOk, DecoderBuffer::CreateEOSBuffer());
   }
   demuxer_ = NULL;
@@ skipping 191 matching lines @@
   const AVDictionaryEntry* entry =
       av_dict_get(stream_->metadata, key, NULL, 0);
   return (entry == NULL || entry->value == NULL) ? "" : entry->value;
 }
 
 // static
 base::TimeDelta FFmpegDemuxerStream::ConvertStreamTimestamp(
     const AVRational& time_base,
     int64_t timestamp) {
   if (timestamp == static_cast<int64_t>(AV_NOPTS_VALUE))
-    return kNoTimestamp();
+    return kNoTimestamp;
 
   return ConvertFromTimeBase(time_base, timestamp);
 }
 
 //
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     DataSource* data_source,
     const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
     const MediaTracksUpdatedCB& media_tracks_updated_cb,
     const scoped_refptr<MediaLog>& media_log)
     : host_(NULL),
       task_runner_(task_runner),
       blocking_thread_("FFmpegDemuxer"),
       pending_read_(false),
       pending_seek_(false),
       data_source_(data_source),
       media_log_(media_log),
       bitrate_(0),
-      start_time_(kNoTimestamp()),
-      preferred_stream_for_seeking_(-1, kNoTimestamp()),
-      fallback_stream_for_seeking_(-1, kNoTimestamp()),
+      start_time_(kNoTimestamp),
+      preferred_stream_for_seeking_(-1, kNoTimestamp),
+      fallback_stream_for_seeking_(-1, kNoTimestamp),
       text_enabled_(false),
       duration_known_(false),
       encrypted_media_init_data_cb_(encrypted_media_init_data_cb),
       media_tracks_updated_cb_(media_tracks_updated_cb),
       weak_factory_(this) {
   DCHECK(task_runner_.get());
   DCHECK(data_source_);
   DCHECK(!media_tracks_updated_cb_.is_null());
 }
 
@@ skipping 104 matching lines @@
 
   // Choose the seeking stream based on whether it contains the seek time, if no
   // match can be found prefer the preferred stream.
   //
   // TODO(dalecurtis): Currently FFmpeg does not ensure that all streams in a
   // given container will demux all packets after the seek point.  Instead it
   // only guarantees that all packets after the file position of the seek will
   // be demuxed.  It's an open question whether FFmpeg should fix this:
   // http://lists.ffmpeg.org/pipermail/ffmpeg-devel/2014-June/159212.html
   // Tracked by http://crbug.com/387996.
-  DCHECK(preferred_stream_for_seeking_.second != kNoTimestamp());
+  DCHECK(preferred_stream_for_seeking_.second != kNoTimestamp);
   const int stream_index =
       seek_time < preferred_stream_for_seeking_.second &&
               seek_time >= fallback_stream_for_seeking_.second
           ? fallback_stream_for_seeking_.first
           : preferred_stream_for_seeking_.first;
   DCHECK_NE(stream_index, -1);
 
   const AVStream* seeking_stream =
       glue_->format_context()->streams[stream_index];
 
@@ skipping 107 matching lines @@
   int bitrate = 0;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     AVCodecContext* codec_context = format_context->streams[i]->codec;
     bitrate += codec_context->bit_rate;
   }
   if (bitrate > 0)
     return bitrate;
 
   // See if we can approximate the bitrate as long as we have a filesize and
   // valid duration.
-  if (duration.InMicroseconds() <= 0 ||
-      duration == kInfiniteDuration() ||
+  if (duration.InMicroseconds() <= 0 || duration == kInfiniteDuration ||
       filesize_in_bytes == 0) {
     return 0;
   }
 
   // Do math in floating point as we'd overflow an int64_t if the filesize was
   // larger than ~1073GB.
   double bytes = filesize_in_bytes;
   double duration_us = duration.InMicroseconds();
   return bytes * 8000000.0 / duration_us;
 }
@@ skipping 48 matching lines @@
   AVFormatContext* format_context = glue_->format_context();
   streams_.resize(format_context->nb_streams);
 
   // Estimate the start time for each stream by looking through the packets
   // buffered during avformat_find_stream_info().  These values will be
   // considered later when determining the actual stream start time.
   //
   // These packets haven't been completely processed yet, so only look through
   // these values if the AVFormatContext has a valid start time.
   //
-  // If no estimate is found, the stream entry will be kInfiniteDuration().
+  // If no estimate is found, the stream entry will be kInfiniteDuration.
   std::vector<base::TimeDelta> start_time_estimates(format_context->nb_streams,
-                                                    kInfiniteDuration());
+                                                    kInfiniteDuration);
   const AVFormatInternal* internal = format_context->internal;
   if (internal && internal->packet_buffer &&
       format_context->start_time != static_cast<int64_t>(AV_NOPTS_VALUE)) {
     struct AVPacketList* packet_buffer = internal->packet_buffer;
     while (packet_buffer != internal->packet_buffer_end) {
       DCHECK_LT(static_cast<size_t>(packet_buffer->pkt.stream_index),
                 start_time_estimates.size());
       const AVStream* stream =
           format_context->streams[packet_buffer->pkt.stream_index];
       if (packet_buffer->pkt.pts != static_cast<int64_t>(AV_NOPTS_VALUE)) {
         const base::TimeDelta packet_pts =
             ConvertFromTimeBase(stream->time_base, packet_buffer->pkt.pts);
         if (packet_pts < start_time_estimates[stream->index])
           start_time_estimates[stream->index] = packet_pts;
       }
       packet_buffer = packet_buffer->next;
     }
   }
 
   std::unique_ptr<MediaTracks> media_tracks(new MediaTracks());
   AVStream* audio_stream = NULL;
   AudioDecoderConfig audio_config;
   AVStream* video_stream = NULL;
   VideoDecoderConfig video_config;
 
   DCHECK(track_id_to_demux_stream_map_.empty());
 
   // If available, |start_time_| will be set to the lowest stream start time.
-  start_time_ = kInfiniteDuration();
+  start_time_ = kInfiniteDuration;
 
   base::TimeDelta max_duration;
   int detected_audio_track_count = 0;
   int detected_video_track_count = 0;
   int detected_text_track_count = 0;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     AVStream* stream = format_context->streams[i];
     const AVCodecContext* codec_context = stream->codec;
     const AVMediaType codec_type = codec_context->codec_type;
 
@@ skipping 116 matching lines @@
       media_track->set_id(base::UintToString(track_id));
       DCHECK(track_id_to_demux_stream_map_.find(media_track->id()) ==
              track_id_to_demux_stream_map_.end());
       track_id_to_demux_stream_map_[media_track->id()] = streams_[i];
     }
 
     max_duration = std::max(max_duration, streams_[i]->duration());
 
     const base::TimeDelta start_time =
         ExtractStartTime(stream, start_time_estimates[i]);
-    const bool has_start_time = start_time != kNoTimestamp();
+    const bool has_start_time = start_time != kNoTimestamp;
 
     // Always prefer the video stream for seeking.  If none exists, we'll swap
     // the fallback stream with the preferred stream below.
     if (codec_type == AVMEDIA_TYPE_VIDEO) {
       preferred_stream_for_seeking_ =
           StreamSeekInfo(i, has_start_time ? start_time : base::TimeDelta());
     }
 
     if (!has_start_time)
       continue;
@@ skipping 23 matching lines @@
 
   if (format_context->duration != static_cast<int64_t>(AV_NOPTS_VALUE)) {
     // If there is a duration value in the container use that to find the
     // maximum between it and the duration from A/V streams.
     const AVRational av_time_base = {1, AV_TIME_BASE};
     max_duration =
         std::max(max_duration,
                  ConvertFromTimeBase(av_time_base, format_context->duration));
   } else {
     // The duration is unknown, in which case this is likely a live stream.
-    max_duration = kInfiniteDuration();
+    max_duration = kInfiniteDuration;
   }
 
   // FFmpeg represents audio data marked as before the beginning of stream as
   // having negative timestamps.  This data must be discarded after it has been
   // decoded, not before since it is used to warmup the decoder.  There are
   // currently two known cases for this: vorbis in ogg and opus in ogg and webm.
   //
   // For API clarity, it was decided that the rest of the media pipeline should
   // not be exposed to negative timestamps.  Which means we need to rebase these
   // negative timestamps and mark them for discard post decoding.
@@ skipping 17 matching lines @@
     // because it has a lower starting time.
     if (fallback_stream_for_seeking_.first == audio_stream->index &&
         fallback_stream_for_seeking_.second < base::TimeDelta()) {
       fallback_stream_for_seeking_.second = base::TimeDelta();
     }
   }
 
   // If no start time could be determined, default to zero and prefer the video
   // stream over the audio stream for seeking.  E.g., The WAV demuxer does not
   // put timestamps on its frames.
-  if (start_time_ == kInfiniteDuration()) {
+  if (start_time_ == kInfiniteDuration) {
     start_time_ = base::TimeDelta();
     preferred_stream_for_seeking_ = StreamSeekInfo(
         video_stream ? video_stream->index : audio_stream->index, start_time_);
   } else if (!video_stream) {
     // If no video stream exists, use the audio or text stream found above.
     preferred_stream_for_seeking_ = fallback_stream_for_seeking_;
   }
 
   // MPEG-4 B-frames cause grief for a simple container like AVI. Enable PTS
   // generation so we always get timestamps, see http://crbug.com/169570
   if (strcmp(format_context->iformat->name, "avi") == 0)
     format_context->flags |= AVFMT_FLAG_GENPTS;
 
   // For testing purposes, don't overwrite the timeline offset if set already.
   if (timeline_offset_.is_null())
     timeline_offset_ = ExtractTimelineOffset(format_context);
 
   // Since we're shifting the externally visible start time to zero, we need to
   // adjust the timeline offset to compensate.
   if (!timeline_offset_.is_null() && start_time_ < base::TimeDelta())
     timeline_offset_ += start_time_;
 
-  if (max_duration == kInfiniteDuration() && !timeline_offset_.is_null()) {
+  if (max_duration == kInfiniteDuration && !timeline_offset_.is_null()) {
     SetLiveness(DemuxerStream::LIVENESS_LIVE);
-  } else if (max_duration != kInfiniteDuration()) {
+  } else if (max_duration != kInfiniteDuration) {
     SetLiveness(DemuxerStream::LIVENESS_RECORDED);
   } else {
     SetLiveness(DemuxerStream::LIVENESS_UNKNOWN);
   }
 
   // Good to go: set the duration and bitrate and notify we're done
   // initializing.
   host_->SetDuration(max_duration);
-  duration_known_ = (max_duration != kInfiniteDuration());
+  duration_known_ = (max_duration != kInfiniteDuration);
 
   int64_t filesize_in_bytes = 0;
   url_protocol_->GetSize(&filesize_in_bytes);
   bitrate_ = CalculateBitrate(format_context, max_duration, filesize_in_bytes);
   if (bitrate_ > 0)
     data_source_->SetBitrate(bitrate_);
 
   // Use a single MediaLogEvent to batch all parameter updates at once; this
   // prevents throttling of events due to the large number of updates here.
   std::unique_ptr<MediaLogEvent> metadata_event =
@@ skipping 153 matching lines @@
     if (!duration_known_) {
       base::TimeDelta max_duration;
 
       for (StreamVector::iterator iter = streams_.begin();
            iter != streams_.end();
            ++iter) {
         if (!*iter)
           continue;
 
         base::TimeDelta duration = (*iter)->GetElapsedTime();
-        if (duration != kNoTimestamp() && duration > max_duration)
+        if (duration != kNoTimestamp && duration > max_duration)
           max_duration = duration;
       }
 
       if (max_duration > base::TimeDelta()) {
         host_->SetDuration(max_duration);
         duration_known_ = true;
       }
     }
     // If we have reached the end of stream, tell the downstream filters about
     // the event.
@@ skipping 77 matching lines @@
 
 void FFmpegDemuxer::SetLiveness(DemuxerStream::Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   for (auto* stream : streams_) {
     if (stream)
       stream->SetLiveness(liveness);
   }
 }
 
 }  // namespace media