Move Liveness from DemuxerStreamProvider to DemuxerStream.

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 <string>
 
 #include "base/base64.h"
@@ skipping 75 matching lines @@
 
 //
 // FFmpegDemuxerStream
 //
 FFmpegDemuxerStream::FFmpegDemuxerStream(FFmpegDemuxer* demuxer,
                                          AVStream* stream)
     : demuxer_(demuxer),
       task_runner_(base::MessageLoopProxy::current()),
       stream_(stream),
       type_(UNKNOWN),
+      liveness_(LIVENESS_UNKNOWN),
       end_of_stream_(false),
       last_packet_timestamp_(kNoTimestamp()),
       last_packet_duration_(kNoTimestamp()),
       video_rotation_(VIDEO_ROTATION_0),
       fixup_negative_ogg_timestamps_(false) {
   DCHECK(demuxer_);
 
   bool is_encrypted = false;
   int rotation = 0;
   AVDictionaryEntry* rotation_entry = NULL;
@@ skipping 55 matching lines @@
     base::Base64Decode(base64_key_id, &enc_key_id);
     DCHECK(!enc_key_id.empty());
     if (enc_key_id.empty())
       return;
 
     encryption_key_id_.assign(enc_key_id);
     demuxer_->FireNeedKey(kWebMInitDataType, enc_key_id);
   }
 }
 
+FFmpegDemuxerStream::~FFmpegDemuxerStream() {
+  DCHECK(!demuxer_);
+  DCHECK(read_cb_.is_null());
+  DCHECK(buffer_queue_.IsEmpty());
+}
+
 void FFmpegDemuxerStream::EnqueuePacket(ScopedAVPacket packet) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!demuxer_ || end_of_stream_) {
     NOTREACHED() << "Attempted to enqueue packet on a stopped stream";
     return;
   }
 
 #if defined(USE_PROPRIETARY_CODECS)
   // Convert the packet if there is a bitstream filter.
@@ skipping 215 matching lines @@
   buffer_queue_.Clear();
   if (!read_cb_.is_null()) {
     base::ResetAndReturn(&read_cb_).Run(
         DemuxerStream::kOk, DecoderBuffer::CreateEOSBuffer());
   }
   demuxer_ = NULL;
   stream_ = NULL;
   end_of_stream_ = true;
 }
 
-DemuxerStream::Type FFmpegDemuxerStream::type() {
+DemuxerStream::Type FFmpegDemuxerStream::type() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return type_;
 }
 
+DemuxerStream::Liveness FFmpegDemuxerStream::liveness() const {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  return liveness_;
+}
+
 void FFmpegDemuxerStream::Read(const ReadCB& read_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK(read_cb_.is_null()) << "Overlapping reads are not supported";
   read_cb_ = BindToCurrentLoop(read_cb);
 
   // Don't accept any additional reads if we've been told to stop.
   // The |demuxer_| may have been destroyed in the pipeline thread.
   //
   // TODO(scherkus): it would be cleaner to reply with an error message.
   if (!demuxer_) {
@@ skipping 45 matching lines @@
 VideoDecoderConfig FFmpegDemuxerStream::video_decoder_config() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK_EQ(type_, VIDEO);
   return video_config_;
 }
 
 VideoRotation FFmpegDemuxerStream::video_rotation() {
   return video_rotation_;
 }
 
-FFmpegDemuxerStream::~FFmpegDemuxerStream() {
-  DCHECK(!demuxer_);
-  DCHECK(read_cb_.is_null());
-  DCHECK(buffer_queue_.IsEmpty());
+void FFmpegDemuxerStream::SetLiveness(Liveness liveness) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK_EQ(liveness_, LIVENESS_UNKNOWN);
+  liveness_ = liveness;
 }
 
 base::TimeDelta FFmpegDemuxerStream::GetElapsedTime() const {
   return ConvertStreamTimestamp(stream_->time_base, stream_->cur_dts);
 }
 
 Ranges<base::TimeDelta> FFmpegDemuxerStream::GetBufferedRanges() const {
   return buffered_ranges_;
 }
 
@@ skipping 74 matching lines @@
       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()),
-      liveness_(LIVENESS_UNKNOWN),
       text_enabled_(false),
       duration_known_(false),
       need_key_cb_(need_key_cb),
       weak_factory_(this) {
   DCHECK(task_runner_.get());
   DCHECK(data_source_);
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {}
 
@@ skipping 119 matching lines @@
       return *iter;
     }
   }
   return NULL;
 }
 
 base::TimeDelta FFmpegDemuxer::GetStartTime() const {
   return std::max(start_time_, base::TimeDelta());
 }
 
-Demuxer::Liveness FFmpegDemuxer::GetLiveness() const {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  return liveness_;
-}
-
 void FFmpegDemuxer::AddTextStreams() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   for (StreamVector::size_type idx = 0; idx < streams_.size(); ++idx) {
     FFmpegDemuxerStream* stream = streams_[idx];
     if (stream == NULL || stream->type() != DemuxerStream::TEXT)
       continue;
 
     TextKind kind = stream->GetTextKind();
     std::string title = stream->GetMetadata("title");
@@ skipping 252 matching lines @@
   // 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()) {
-    liveness_ = LIVENESS_LIVE;
+    SetLiveness(DemuxerStream::LIVENESS_LIVE);
   } else if (max_duration != kInfiniteDuration()) {
-    liveness_ = LIVENESS_RECORDED;
+    SetLiveness(DemuxerStream::LIVENESS_RECORDED);
   } else {
-    liveness_ = LIVENESS_UNKNOWN;
+    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());
 
   int64 filesize_in_bytes = 0;
   url_protocol_->GetSize(&filesize_in_bytes);
   bitrate_ = CalculateBitrate(format_context, max_duration, filesize_in_bytes);
@@ skipping 262 matching lines @@
     buffered = video->GetBufferedRanges();
   }
   for (size_t i = 0; i < buffered.size(); ++i)
     host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
 }
 
 void FFmpegDemuxer::OnDataSourceError() {
   host_->OnDemuxerError(PIPELINE_ERROR_READ);
 }
 
+void FFmpegDemuxer::SetLiveness(DemuxerStream::Liveness liveness) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  for (const auto& stream : streams_) {  // |stream| is a ref to a pointer.
+    if (stream)
+      stream->SetLiveness(liveness);
+  }
+}
+
 }  // namespace media