Rename MediaSourceState -> SourceBufferState

media/filters/source_buffer_state.cc

 // Copyright 2016 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/media_source_state.h"
+#include "media/filters/source_buffer_state.h"
 
 #include <set>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/media_switches.h"
 #include "media/base/media_track.h"
 #include "media/base/media_tracks.h"
 #include "media/base/mime_util.h"
@@ skipping 36 matching lines @@
     }
     bytestream_ids.insert(track_id);
   }
   return true;
 }
 
 }  // namespace
 
 // List of time ranges for each SourceBuffer.
 // static
-Ranges<TimeDelta> MediaSourceState::ComputeRangesIntersection(
+Ranges<TimeDelta> SourceBufferState::ComputeRangesIntersection(
     const RangesList& active_ranges,
     bool ended) {
   // TODO(servolk): Perhaps this can be removed in favor of blink implementation
   // (MediaSource::buffered)? Currently this is only used on Android and for
   // updating DemuxerHost's buffered ranges during AppendData() as well as
   // SourceBuffer.buffered property implementation.
   // Implementation of HTMLMediaElement.buffered algorithm in MSE spec.
   // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#dom-htmlmediaelement.buffered
 
   // Step 1: If activeSourceBuffers.length equals 0 then return an empty
@@ skipping 35 matching lines @@
     // Step 5.3: Let new intersection ranges equal the intersection between
     // the intersection ranges and the source ranges.
     // Step 5.4: Replace the ranges in intersection ranges with the new
     // intersection ranges.
     intersection_ranges = intersection_ranges.IntersectionWith(source_ranges);
   }
 
   return intersection_ranges;
 }
 
-MediaSourceState::MediaSourceState(
+SourceBufferState::SourceBufferState(
     std::unique_ptr<StreamParser> stream_parser,
     std::unique_ptr<FrameProcessor> frame_processor,
     const CreateDemuxerStreamCB& create_demuxer_stream_cb,
     const scoped_refptr<MediaLog>& media_log)
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       timestamp_offset_during_append_(NULL),
       parsing_media_segment_(false),
       stream_parser_(stream_parser.release()),
       frame_processor_(frame_processor.release()),
       media_log_(media_log),
       state_(UNINITIALIZED),
       auto_update_timestamp_offset_(false) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(frame_processor_);
 }
 
-MediaSourceState::~MediaSourceState() {
+SourceBufferState::~SourceBufferState() {
   Shutdown();
 }
 
-void MediaSourceState::Init(
+void SourceBufferState::Init(
     const StreamParser::InitCB& init_cb,
     const std::string& expected_codecs,
     const StreamParser::EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
     const NewTextTrackCB& new_text_track_cb) {
   DCHECK_EQ(state_, UNINITIALIZED);
   new_text_track_cb_ = new_text_track_cb;
   init_cb_ = init_cb;
 
   std::vector<std::string> expected_codecs_parsed;
   ParseCodecString(expected_codecs, &expected_codecs_parsed, false);
 
   std::vector<AudioCodec> expected_acodecs;
   std::vector<VideoCodec> expected_vcodecs;
   for (const auto& codec_id : expected_codecs_parsed) {
     AudioCodec acodec = StringToAudioCodec(codec_id);
     if (acodec != kUnknownAudioCodec) {
       expected_audio_codecs_.push_back(acodec);
       continue;
     }
     VideoCodec vcodec = StringToVideoCodec(codec_id);
     if (vcodec != kUnknownVideoCodec) {
       expected_video_codecs_.push_back(vcodec);
       continue;
     }
     MEDIA_LOG(INFO, media_log_) << "Unrecognized media codec: " << codec_id;
   }
 
   state_ = PENDING_PARSER_CONFIG;
   stream_parser_->Init(
-      base::Bind(&MediaSourceState::OnSourceInitDone, base::Unretained(this)),
-      base::Bind(&MediaSourceState::OnNewConfigs, base::Unretained(this),
+      base::Bind(&SourceBufferState::OnSourceInitDone, base::Unretained(this)),
+      base::Bind(&SourceBufferState::OnNewConfigs, base::Unretained(this),
                  expected_codecs),
-      base::Bind(&MediaSourceState::OnNewBuffers, base::Unretained(this)),
+      base::Bind(&SourceBufferState::OnNewBuffers, base::Unretained(this)),
       new_text_track_cb_.is_null(), encrypted_media_init_data_cb,
-      base::Bind(&MediaSourceState::OnNewMediaSegment, base::Unretained(this)),
-      base::Bind(&MediaSourceState::OnEndOfMediaSegment,
+      base::Bind(&SourceBufferState::OnNewMediaSegment, base::Unretained(this)),
+      base::Bind(&SourceBufferState::OnEndOfMediaSegment,
                  base::Unretained(this)),
       media_log_);
 }
 
-void MediaSourceState::SetSequenceMode(bool sequence_mode) {
+void SourceBufferState::SetSequenceMode(bool sequence_mode) {
   DCHECK(!parsing_media_segment_);
 
   frame_processor_->SetSequenceMode(sequence_mode);
 }
 
-void MediaSourceState::SetGroupStartTimestampIfInSequenceMode(
+void SourceBufferState::SetGroupStartTimestampIfInSequenceMode(
     base::TimeDelta timestamp_offset) {
   DCHECK(!parsing_media_segment_);
 
   frame_processor_->SetGroupStartTimestampIfInSequenceMode(timestamp_offset);
 }
 
-void MediaSourceState::SetTracksWatcher(
+void SourceBufferState::SetTracksWatcher(
     const Demuxer::MediaTracksUpdatedCB& tracks_updated_cb) {
   DCHECK(init_segment_received_cb_.is_null());
   DCHECK(!tracks_updated_cb.is_null());
   init_segment_received_cb_ = tracks_updated_cb;
 }
 
-bool MediaSourceState::Append(const uint8_t* data,
-                              size_t length,
-                              TimeDelta append_window_start,
-                              TimeDelta append_window_end,
-                              TimeDelta* timestamp_offset) {
+bool SourceBufferState::Append(const uint8_t* data,
+                               size_t length,
+                               TimeDelta append_window_start,
+                               TimeDelta append_window_end,
+                               TimeDelta* timestamp_offset) {
   append_in_progress_ = true;
   DCHECK(timestamp_offset);
   DCHECK(!timestamp_offset_during_append_);
   append_window_start_during_append_ = append_window_start;
   append_window_end_during_append_ = append_window_end;
   timestamp_offset_during_append_ = timestamp_offset;
 
   // TODO(wolenetz/acolwell): Curry and pass a NewBuffersCB here bound with
   // append window and timestamp offset pointer. See http://crbug.com/351454.
   bool result = stream_parser_->Parse(data, length);
   if (!result) {
     MEDIA_LOG(ERROR, media_log_)
         << __func__ << ": stream parsing failed. Data size=" << length
         << " append_window_start=" << append_window_start.InSecondsF()
         << " append_window_end=" << append_window_end.InSecondsF();
   }
   timestamp_offset_during_append_ = NULL;
   append_in_progress_ = false;
   return result;
 }
 
-void MediaSourceState::ResetParserState(TimeDelta append_window_start,
-                                        TimeDelta append_window_end,
-                                        base::TimeDelta* timestamp_offset) {
+void SourceBufferState::ResetParserState(TimeDelta append_window_start,
+                                         TimeDelta append_window_end,
+                                         base::TimeDelta* timestamp_offset) {
   DCHECK(timestamp_offset);
   DCHECK(!timestamp_offset_during_append_);
   timestamp_offset_during_append_ = timestamp_offset;
   append_window_start_during_append_ = append_window_start;
   append_window_end_during_append_ = append_window_end;
 
   stream_parser_->Flush();
   timestamp_offset_during_append_ = NULL;
 
   frame_processor_->Reset();
   parsing_media_segment_ = false;
   media_segment_has_data_for_track_.clear();
 }
 
-void MediaSourceState::Remove(TimeDelta start,
-                              TimeDelta end,
-                              TimeDelta duration) {
+void SourceBufferState::Remove(TimeDelta start,
+                               TimeDelta end,
+                               TimeDelta duration) {
   for (const auto& it : audio_streams_) {
     it.second->Remove(start, end, duration);
   }
 
   for (const auto& it : video_streams_) {
     it.second->Remove(start, end, duration);
   }
 
   for (const auto& it : text_streams_) {
     it.second->Remove(start, end, duration);
   }
 }
 
-bool MediaSourceState::EvictCodedFrames(DecodeTimestamp media_time,
-                                        size_t newDataSize) {
+bool SourceBufferState::EvictCodedFrames(DecodeTimestamp media_time,
+                                         size_t newDataSize) {
   size_t total_buffered_size = 0;
   for (const auto& it : audio_streams_)
     total_buffered_size += it.second->GetBufferedSize();
   for (const auto& it : video_streams_)
     total_buffered_size += it.second->GetBufferedSize();
   for (const auto& it : text_streams_)
     total_buffered_size += it.second->GetBufferedSize();
 
   DVLOG(3) << __func__ << " media_time=" << media_time.InSecondsF()
            << " newDataSize=" << newDataSize
@@ skipping 28 matching lines @@
     uint64_t estimated_new_size = newDataSize * curr_size / total_buffered_size;
     DCHECK_LE(estimated_new_size, SIZE_MAX);
     success &= it.second->EvictCodedFrames(
         media_time, static_cast<size_t>(estimated_new_size));
   }
 
   DVLOG(3) << __func__ << " success=" << success;
   return success;
 }
 
-Ranges<TimeDelta> MediaSourceState::GetBufferedRanges(TimeDelta duration,
-                                                      bool ended) const {
+Ranges<TimeDelta> SourceBufferState::GetBufferedRanges(TimeDelta duration,
+                                                       bool ended) const {
   RangesList ranges_list;
   for (const auto& it : audio_streams_)
     ranges_list.push_back(it.second->GetBufferedRanges(duration));
 
   for (const auto& it : video_streams_)
     ranges_list.push_back(it.second->GetBufferedRanges(duration));
 
   for (const auto& it : text_streams_)
     ranges_list.push_back(it.second->GetBufferedRanges(duration));
 
   return ComputeRangesIntersection(ranges_list, ended);
 }
 
-TimeDelta MediaSourceState::GetHighestPresentationTimestamp() const {
+TimeDelta SourceBufferState::GetHighestPresentationTimestamp() const {
   TimeDelta max_pts;
 
   for (const auto& it : audio_streams_) {
     max_pts = std::max(max_pts, it.second->GetHighestPresentationTimestamp());
   }
 
   for (const auto& it : video_streams_) {
     max_pts = std::max(max_pts, it.second->GetHighestPresentationTimestamp());
   }
 
   for (const auto& it : text_streams_) {
     max_pts = std::max(max_pts, it.second->GetHighestPresentationTimestamp());
   }
 
   return max_pts;
 }
 
-TimeDelta MediaSourceState::GetMaxBufferedDuration() const {
+TimeDelta SourceBufferState::GetMaxBufferedDuration() const {
   TimeDelta max_duration;
 
   for (const auto& it : audio_streams_) {
     max_duration = std::max(max_duration, it.second->GetBufferedDuration());
   }
 
   for (const auto& it : video_streams_) {
     max_duration = std::max(max_duration, it.second->GetBufferedDuration());
   }
 
   for (const auto& it : text_streams_) {
     max_duration = std::max(max_duration, it.second->GetBufferedDuration());
   }
 
   return max_duration;
 }
 
-void MediaSourceState::StartReturningData() {
+void SourceBufferState::StartReturningData() {
   for (const auto& it : audio_streams_) {
     it.second->StartReturningData();
   }
 
   for (const auto& it : video_streams_) {
     it.second->StartReturningData();
   }
 
   for (const auto& it : text_streams_) {
     it.second->StartReturningData();
   }
 }
 
-void MediaSourceState::AbortReads() {
+void SourceBufferState::AbortReads() {
   for (const auto& it : audio_streams_) {
     it.second->AbortReads();
   }
 
   for (const auto& it : video_streams_) {
     it.second->AbortReads();
   }
 
   for (const auto& it : text_streams_) {
     it.second->AbortReads();
   }
 }
 
-void MediaSourceState::Seek(TimeDelta seek_time) {
+void SourceBufferState::Seek(TimeDelta seek_time) {
   for (const auto& it : audio_streams_) {
     it.second->Seek(seek_time);
   }
 
   for (const auto& it : video_streams_) {
     it.second->Seek(seek_time);
   }
 
   for (const auto& it : text_streams_) {
     it.second->Seek(seek_time);
   }
 }
 
-void MediaSourceState::CompletePendingReadIfPossible() {
+void SourceBufferState::CompletePendingReadIfPossible() {
   for (const auto& it : audio_streams_) {
     it.second->CompletePendingReadIfPossible();
   }
 
   for (const auto& it : video_streams_) {
     it.second->CompletePendingReadIfPossible();
   }
 
   for (const auto& it : text_streams_) {
     it.second->CompletePendingReadIfPossible();
   }
 }
 
-void MediaSourceState::OnSetDuration(TimeDelta duration) {
+void SourceBufferState::OnSetDuration(TimeDelta duration) {
   for (const auto& it : audio_streams_) {
     it.second->OnSetDuration(duration);
   }
 
   for (const auto& it : video_streams_) {
     it.second->OnSetDuration(duration);
   }
 
   for (const auto& it : text_streams_) {
     it.second->OnSetDuration(duration);
   }
 }
 
-void MediaSourceState::MarkEndOfStream() {
+void SourceBufferState::MarkEndOfStream() {
   for (const auto& it : audio_streams_) {
     it.second->MarkEndOfStream();
   }
 
   for (const auto& it : video_streams_) {
     it.second->MarkEndOfStream();
   }
 
   for (const auto& it : text_streams_) {
     it.second->MarkEndOfStream();
   }
 }
 
-void MediaSourceState::UnmarkEndOfStream() {
+void SourceBufferState::UnmarkEndOfStream() {
   for (const auto& it : audio_streams_) {
     it.second->UnmarkEndOfStream();
   }
 
   for (const auto& it : video_streams_) {
     it.second->UnmarkEndOfStream();
   }
 
   for (const auto& it : text_streams_) {
     it.second->UnmarkEndOfStream();
   }
 }
 
-void MediaSourceState::Shutdown() {
+void SourceBufferState::Shutdown() {
   for (const auto& it : audio_streams_) {
     it.second->Shutdown();
   }
 
   for (const auto& it : video_streams_) {
     it.second->Shutdown();
   }
 
   for (const auto& it : text_streams_) {
     it.second->Shutdown();
   }
 }
 
-void MediaSourceState::SetMemoryLimits(DemuxerStream::Type type,
-                                       size_t memory_limit) {
+void SourceBufferState::SetMemoryLimits(DemuxerStream::Type type,
+                                        size_t memory_limit) {
   switch (type) {
     case DemuxerStream::AUDIO:
       for (const auto& it : audio_streams_) {
         it.second->SetStreamMemoryLimit(memory_limit);
       }
       break;
     case DemuxerStream::VIDEO:
       for (const auto& it : video_streams_) {
         it.second->SetStreamMemoryLimit(memory_limit);
       }
       break;
     case DemuxerStream::TEXT:
       for (const auto& it : text_streams_) {
         it.second->SetStreamMemoryLimit(memory_limit);
       }
       break;
     case DemuxerStream::UNKNOWN:
     case DemuxerStream::NUM_TYPES:
       NOTREACHED();
       break;
   }
 }
 
-bool MediaSourceState::IsSeekWaitingForData() const {
+bool SourceBufferState::IsSeekWaitingForData() const {
   for (const auto& it : audio_streams_) {
     if (it.second->IsSeekWaitingForData())
       return true;
   }
 
   for (const auto& it : video_streams_) {
     if (it.second->IsSeekWaitingForData())
       return true;
   }
 
   // NOTE: We are intentionally not checking the text tracks
   // because text tracks are discontinuous and may not have data
   // for the seek position. This is ok and playback should not be
   // stalled because we don't have cues. If cues, with timestamps after
   // the seek time, eventually arrive they will be delivered properly
   // in response to ChunkDemuxerStream::Read() calls.
 
   return false;
 }
 
-bool MediaSourceState::OnNewConfigs(
+bool SourceBufferState::OnNewConfigs(
     std::string expected_codecs,
     std::unique_ptr<MediaTracks> tracks,
     const StreamParser::TextTrackConfigMap& text_configs) {
   DCHECK(tracks.get());
   DVLOG(1) << __func__ << " expected_codecs=" << expected_codecs
            << " tracks=" << tracks->tracks().size();
   DCHECK_GE(state_, PENDING_PARSER_CONFIG);
 
   // Check that there is no clashing bytestream track ids.
   if (!CheckBytestreamTrackIds(*tracks, text_configs)) {
@@ skipping 238 matching lines @@
   if (success) {
     if (state_ == PENDING_PARSER_CONFIG)
       state_ = PENDING_PARSER_INIT;
     DCHECK(!init_segment_received_cb_.is_null());
     init_segment_received_cb_.Run(std::move(tracks));
   }
 
   return success;
 }
 
-void MediaSourceState::SetStreamMemoryLimits() {
+void SourceBufferState::SetStreamMemoryLimits() {
   auto cmd_line = base::CommandLine::ForCurrentProcess();
 
   std::string audio_buf_limit_switch =
       cmd_line->GetSwitchValueASCII(switches::kMSEAudioBufferSizeLimit);
   unsigned audio_buf_size_limit = 0;
   if (base::StringToUint(audio_buf_limit_switch, &audio_buf_size_limit) &&
       audio_buf_size_limit > 0) {
     MEDIA_LOG(INFO, media_log_)
         << "Custom audio per-track SourceBuffer size limit="
         << audio_buf_size_limit;
     for (const auto& it : audio_streams_) {
       it.second->SetStreamMemoryLimit(audio_buf_size_limit);
     }
   }
 
   std::string video_buf_limit_switch =
       cmd_line->GetSwitchValueASCII(switches::kMSEVideoBufferSizeLimit);
   unsigned video_buf_size_limit = 0;
   if (base::StringToUint(video_buf_limit_switch, &video_buf_size_limit) &&
       video_buf_size_limit > 0) {
     MEDIA_LOG(INFO, media_log_)
         << "Custom video per-track SourceBuffer size limit="
         << video_buf_size_limit;
     for (const auto& it : video_streams_) {
       it.second->SetStreamMemoryLimit(video_buf_size_limit);
     }
   }
 }
 
-void MediaSourceState::OnNewMediaSegment() {
+void SourceBufferState::OnNewMediaSegment() {
   DVLOG(2) << "OnNewMediaSegment()";
   DCHECK_EQ(state_, PARSER_INITIALIZED);
   parsing_media_segment_ = true;
   media_segment_has_data_for_track_.clear();
 }
 
-void MediaSourceState::OnEndOfMediaSegment() {
+void SourceBufferState::OnEndOfMediaSegment() {
   DVLOG(2) << "OnEndOfMediaSegment()";
   DCHECK_EQ(state_, PARSER_INITIALIZED);
   parsing_media_segment_ = false;
 
   for (const auto& it : audio_streams_) {
     if (!media_segment_has_data_for_track_[it.first]) {
       LIMITED_MEDIA_LOG(DEBUG, media_log_, num_missing_track_logs_,
                         kMaxMissingTrackInSegmentLogs)
           << "Media segment did not contain any coded frames for track "
           << it.first << ", mismatching initialization segment. Therefore, MSE"
                          " coded frame processing may not interoperably detect"
                          " discontinuities in appended media.";
     }
   }
   for (const auto& it : video_streams_) {
     if (!media_segment_has_data_for_track_[it.first]) {
       LIMITED_MEDIA_LOG(DEBUG, media_log_, num_missing_track_logs_,
                         kMaxMissingTrackInSegmentLogs)
           << "Media segment did not contain any coded frames for track "
           << it.first << ", mismatching initialization segment. Therefore, MSE"
                          " coded frame processing may not interoperably detect"
                          " discontinuities in appended media.";
     }
   }
 }
 
-bool MediaSourceState::OnNewBuffers(
+bool SourceBufferState::OnNewBuffers(
     const StreamParser::BufferQueueMap& buffer_queue_map) {
   DVLOG(2) << __func__ << " buffer_queues=" << buffer_queue_map.size();
   DCHECK_EQ(state_, PARSER_INITIALIZED);
   DCHECK(timestamp_offset_during_append_);
   DCHECK(parsing_media_segment_);
 
   for (const auto& it : buffer_queue_map) {
     const StreamParser::BufferQueue& bufq = it.second;
     DCHECK(!bufq.empty());
     media_segment_has_data_for_track_[it.first] = true;
@@ skipping 27 matching lines @@
   }
 
   // Only update the timestamp offset if the frame processor hasn't already.
   if (auto_update_timestamp_offset_ &&
       timestamp_offset_before_processing == *timestamp_offset_during_append_) {
     *timestamp_offset_during_append_ = new_timestamp_offset;
   }
 
   return true;
 }
-void MediaSourceState::OnSourceInitDone(
+void SourceBufferState::OnSourceInitDone(
     const StreamParser::InitParameters& params) {
   DCHECK_EQ(state_, PENDING_PARSER_INIT);
   state_ = PARSER_INITIALIZED;
   auto_update_timestamp_offset_ = params.auto_update_timestamp_offset;
   base::ResetAndReturn(&init_cb_).Run(params);
 }
 
 }  // namespace media