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 <list>
 #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),
       pending_source_init_done_count_(0),
       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 701 matching lines @@
   // processing, which happens when a new chunk of data is appended and the
   // lock_ must be held by ChunkDemuxer::AppendData.
   lock_.AssertAcquired();
 
   MediaTrack::Id media_track_id = GenerateMediaTrackId();
 
   switch (type) {
     case DemuxerStream::AUDIO:
       if (audio_)
         return NULL;
-      audio_.reset(new ChunkDemuxerStream(
-          DemuxerStream::AUDIO, splice_frames_enabled_, media_track_id));
+      audio_.reset(
+          new ChunkDemuxerStream(DemuxerStream::AUDIO, 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] = audio_.get();
       return audio_.get();
       break;
     case DemuxerStream::VIDEO:
       if (video_)
         return NULL;
-      video_.reset(new ChunkDemuxerStream(
-          DemuxerStream::VIDEO, splice_frames_enabled_, media_track_id));
+      video_.reset(
+          new ChunkDemuxerStream(DemuxerStream::VIDEO, 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] = video_.get();
       return video_.get();
       break;
     case DemuxerStream::TEXT: {
-      return new ChunkDemuxerStream(DemuxerStream::TEXT, splice_frames_enabled_,
-                                    media_track_id);
+      return new ChunkDemuxerStream(DemuxerStream::TEXT, media_track_id);
       break;
     }
     case DemuxerStream::UNKNOWN:
     case DemuxerStream::NUM_TYPES:
       NOTREACHED();
       return NULL;
   }
   NOTREACHED();
   return NULL;
 }
@@ skipping 104 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media