MSE: Replace crossfade splicing overlap trimming.

media/filters/chunk_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/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
@@ skipping 13 matching lines @@
 #include "media/base/video_codecs.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/frame_processor.h"
 #include "media/filters/stream_parser_factory.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 ChunkDemuxerStream::ChunkDemuxerStream(Type type,
-                                       bool splice_frames_enabled,
                                        MediaTrack::Id media_track_id)
     : type_(type),
       liveness_(DemuxerStream::LIVENESS_UNKNOWN),
       media_track_id_(media_track_id),
       state_(UNINITIALIZED),
-      splice_frames_enabled_(splice_frames_enabled),
       partial_append_window_trimming_enabled_(false),
       is_enabled_(true) {}
 
 void ChunkDemuxerStream::StartReturningData() {
   DVLOG(1) << "ChunkDemuxerStream::StartReturningData()";
   base::AutoLock auto_lock(lock_);
   DCHECK(read_cb_.is_null());
   ChangeState_Locked(RETURNING_DATA_FOR_READS);
 }
 
@@ skipping 129 matching lines @@
 
 bool ChunkDemuxerStream::UpdateAudioConfig(
     const AudioDecoderConfig& config,
     const scoped_refptr<MediaLog>& media_log) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, AUDIO);
   base::AutoLock auto_lock(lock_);
   if (!stream_) {
     DCHECK_EQ(state_, UNINITIALIZED);
 
-    // On platforms which support splice frames, enable splice frames and
-    // partial append window support for most codecs (notably: not opus).
-    const bool codec_supported = config.codec() == kCodecMP3 ||
-                                 config.codec() == kCodecAAC ||
-                                 config.codec() == kCodecVorbis;
-    splice_frames_enabled_ = splice_frames_enabled_ && codec_supported;
-    partial_append_window_trimming_enabled_ =
-        splice_frames_enabled_ && codec_supported;
+    // Enable partial append window support for most audio codecs (notably: not
+    // opus).
+    partial_append_window_trimming_enabled_ = config.codec() == kCodecMP3 ||
+                                              config.codec() == kCodecAAC ||
+                                              config.codec() == kCodecVorbis;
 
-    stream_.reset(
-        new SourceBufferStream(config, media_log, splice_frames_enabled_));
+    stream_.reset(new SourceBufferStream(config, media_log));
     return true;
   }
 
   return stream_->UpdateAudioConfig(config);
 }
 
 bool ChunkDemuxerStream::UpdateVideoConfig(
     const VideoDecoderConfig& config,
     const scoped_refptr<MediaLog>& media_log) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, VIDEO);
   base::AutoLock auto_lock(lock_);
 
   if (!stream_) {
     DCHECK_EQ(state_, UNINITIALIZED);
-    stream_.reset(
-        new SourceBufferStream(config, media_log, splice_frames_enabled_));
+    stream_.reset(new SourceBufferStream(config, media_log));
     return true;
   }
 
   return stream_->UpdateVideoConfig(config);
 }
 
 void ChunkDemuxerStream::UpdateTextConfig(
     const TextTrackConfig& config,
     const scoped_refptr<MediaLog>& media_log) {
   DCHECK_EQ(type_, TEXT);
   base::AutoLock auto_lock(lock_);
   DCHECK(!stream_);
   DCHECK_EQ(state_, UNINITIALIZED);
-  stream_.reset(
-      new SourceBufferStream(config, media_log, splice_frames_enabled_));
+  stream_.reset(new SourceBufferStream(config, media_log));
 }
 
 void ChunkDemuxerStream::MarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
   stream_->MarkEndOfStream();
 }
 
 void ChunkDemuxerStream::UnmarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
   stream_->UnmarkEndOfStream();
@@ skipping 150 matching lines @@
       DVLOG(2) << __func__ << ": returning kOk with EOS buffer, type " << type_;
       break;
   }
 
   base::ResetAndReturn(&read_cb_).Run(status, buffer);
 }
 
 ChunkDemuxer::ChunkDemuxer(
     const base::Closure& open_cb,
     const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
-    const scoped_refptr<MediaLog>& media_log,
-    bool splice_frames_enabled)
+    const scoped_refptr<MediaLog>& media_log)
     : state_(WAITING_FOR_INIT),
       cancel_next_seek_(false),
       host_(NULL),
       open_cb_(open_cb),
       encrypted_media_init_data_cb_(encrypted_media_init_data_cb),
       enable_text_(false),
       media_log_(media_log),
       duration_(kNoTimestamp),
       user_specified_duration_(-1),
       liveness_(DemuxerStream::LIVENESS_UNKNOWN),
-      splice_frames_enabled_(splice_frames_enabled),
       detected_audio_track_count_(0),
       detected_video_track_count_(0),
       detected_text_track_count_(0) {
   DCHECK(!open_cb_.is_null());
   DCHECK(!encrypted_media_init_data_cb_.is_null());
 }
 
 std::string ChunkDemuxer::GetDisplayName() const {
   return "ChunkDemuxer";
 }
@@ skipping 763 matching lines @@
     case DemuxerStream::TEXT:
       owning_vector = &text_streams_;
       break;
 
     case DemuxerStream::UNKNOWN:
       NOTREACHED();
       return nullptr;
   }
 
   std::unique_ptr<ChunkDemuxerStream> stream =
-      base::MakeUnique<ChunkDemuxerStream>(type, splice_frames_enabled_,
-                                           media_track_id);
+      base::MakeUnique<ChunkDemuxerStream>(type, media_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] = stream.get();
   id_to_streams_map_[source_id].push_back(stream.get());
   owning_vector->push_back(std::move(stream));
   return owning_vector->back().get();
 }
 
 void ChunkDemuxer::OnNewTextTrack(ChunkDemuxerStream* text_stream,
                                   const TextTrackConfig& config) {
@@ skipping 101 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
        ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media