MediaCodecPlayer implementation (stage 5 - reconfiguration)

media/base/android/access_unit_queue.cc

 // Copyright 2015 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/base/android/access_unit_queue.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "media/base/demuxer_stream.h"
 
 namespace media {
 
 namespace {
 // Amount of history chunks we keep by default. The zero size means we do not
 // keep chunks before the current one and the history is limited by the size
 // of one chunk.
 const int kDefaultHistoryChunksAmount = 0;
 }
 
 AccessUnitQueue::AccessUnitQueue()
     : index_in_chunk_(0),
       history_chunks_amount_(kDefaultHistoryChunksAmount),
-      has_eos_(false) {
+      has_eos_(false),
+      emulate_config_changes_(false) {
   current_chunk_ = chunks_.end();
 }
 
 AccessUnitQueue::~AccessUnitQueue() {
   STLDeleteContainerPointers(chunks_.begin(), chunks_.end());
 }
 
 void AccessUnitQueue::PushBack(const DemuxerData& data) {
   // Media thread
   DCHECK(!data.access_units.empty());
@@ skipping 16 matching lines @@
       DCHECK(data.demuxer_configs.size() == 1);
     }
 
     if (unit.status == DemuxerStream::kAborted) {
       DVLOG(1) << "AccessUnitQueue::" << __FUNCTION__ << " kAborted";
     }
   }
 #endif
 
   // Create the next chunk and copy data to it.
-  DemuxerData* chunk = new DemuxerData(data);
+  // It might be split if we emulate config changes
+  std::vector<DemuxerData*> cloned_data = CloneData(data);
+  DCHECK(!cloned_data.empty());
 
   // EOS flag can only be in the last access unit.
-  bool has_eos = chunk->access_units.back().is_end_of_stream;
+  bool has_eos = cloned_data.back()->access_units.back().is_end_of_stream;
 
   // Append this chunk to the queue.
   base::AutoLock lock(lock_);
 
   // Ignore the input after we have received EOS.
   if (has_eos_) {
-    delete chunk;
+    for (DemuxerData* chunk : cloned_data)
+      delete chunk;
+
     return;
   }
 
-  bool was_empty = (current_chunk_ == chunks_.end());
+  for (DemuxerData* chunk : cloned_data) {
+    bool was_empty = (current_chunk_ == chunks_.end());
 
-  // The container |chunks_| will own the chunk.
-  chunks_.push_back(chunk);
+    // The container |chunks_| will own the chunk.
+    chunks_.push_back(chunk);
 
-  // Position the current chunk.
-  if (was_empty) {
-    current_chunk_ = --chunks_.end();
-    index_in_chunk_ = 0;
+    // Position the current chunk.
+    if (was_empty) {
+      current_chunk_ = --chunks_.end();
+      index_in_chunk_ = 0;
+    }
   }
 
   // We expect that the chunk containing EOS is the last chunk.
   DCHECK(!has_eos_);
   has_eos_ = has_eos;
 }
 
 void AccessUnitQueue::Advance() {
   // Decoder thread
   base::AutoLock lock(lock_);
@@ skipping 82 matching lines @@
     info.front_unit = &(*current_chunk_)->access_units[index_in_chunk_];
 
     if (info.front_unit->status == DemuxerStream::kConfigChanged) {
       DCHECK((*current_chunk_)->demuxer_configs.size() == 1);
       info.configs = &(*current_chunk_)->demuxer_configs[0];
     }
   }
   return info;
 }
 
+void AccessUnitQueue::EmulateConfigChanges(bool value) {
+  emulate_config_changes_ = value;
+}
+
+void AccessUnitQueue::SetLastConfigs(const DemuxerConfigs& configs) {
+  if (emulate_config_changes_)
+    last_configs_ = configs;
+}
+
 void AccessUnitQueue::SetHistorySizeForTesting(size_t history_chunks_amount) {
   history_chunks_amount_ = history_chunks_amount;
 }
 
+std::vector<DemuxerData*> AccessUnitQueue::CloneData(const DemuxerData& data) {
+  if (emulate_config_changes_ &&
+      (last_configs_.audio_codec != kUnknownAudioCodec ||
+       last_configs_.video_codec != kUnknownVideoCodec)) {
+    std::vector<AccessUnit>::const_iterator begin = data.access_units.begin();
+    std::vector<AccessUnit>::const_iterator end = data.access_units.end();
+    std::vector<AccessUnit>::const_iterator key_frame;
+    for (key_frame = begin; key_frame != end; ++key_frame)
+      if (key_frame->is_key_frame)
+        break;
+
+    if (key_frame != end) {
+      std::vector<DemuxerData*> result;
+
+      result.push_back(new DemuxerData());
+      result.back()->access_units = std::vector<AccessUnit>(begin, key_frame);
+      result.back()->access_units.push_back(AccessUnit());
+      result.back()->access_units.back().status = DemuxerStream::kConfigChanged;
+      result.back()->demuxer_configs.push_back(last_configs_);
+
+      result.push_back(new DemuxerData());
+      result.back()->access_units = std::vector<AccessUnit>(key_frame, end);
+
+      return result;
+    }
+  }
+
+  return std::vector<DemuxerData*>(1, new DemuxerData(data));
+}
+
 int AccessUnitQueue::GetUnconsumedAccessUnitLength() const {
   int result = 0;
   DataChunkQueue::const_iterator chunk;
-  for (chunk = current_chunk_; chunk != chunks_.end(); ++chunk)
+  for (chunk = current_chunk_; chunk != chunks_.end(); ++chunk) {
     result += (*chunk)->access_units.size();
 
+    // Do not count configuration changes.
+    if (!(*chunk)->demuxer_configs.empty()) {
+      DCHECK((*chunk)->demuxer_configs.size() == 1);
+      --result;
+    }
+  }
+
   result -= index_in_chunk_;
   return result;
 }
 
 }  // namespace media