Implementation of MediaCodecPlayer stage 1

media/base/android/access_unit_queue.cc

Index: media/base/android/access_unit_queue.cc
diff --git a/media/base/android/access_unit_queue.cc b/media/base/android/access_unit_queue.cc
new file mode 100644
index 0000000000000000000000000000000000000000..dc867460481c2d6ee13f8bb23670c2a1357b4a0c
--- /dev/null
+++ b/media/base/android/access_unit_queue.cc
@@ -0,0 +1,148 @@
+// 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 "media/base/demuxer_stream.h"
+
+namespace media {
+
+AccessUnitQueue::AccessUnitQueue()
+    : index_in_chunk_(0),
+      has_eos_(false) {
+  current_chunk_ = chunks_.end();
+}
+
+AccessUnitQueue::~AccessUnitQueue() {}
+
+void AccessUnitQueue::PushBack(const DemuxerData& data) {
+  // Media thread
+  DCHECK(!data.access_units.empty());
+
+#if DCHECK_IS_ON()
+  // Verify the rule "one DemuxerConfigs for one AU with |kConfigChanged|".
+  size_t num_config_placeholders = 0;
+#endif
+
+  // Determine whether the chunk contains EOS.
+  bool has_eos = false;
+  for (const AccessUnit& unit : data.access_units) {

[qinmin, 2015/05/31 20:19:12]

When DCHECK_IS_ON() is turned off, this for loop only checks the has_eos
variable. In that case, we should start from the last access unit to reduce the
number of loops.
Or even better, we shouldn't do the loop to get EOS here, just do has_eos_ =
data.access_units.back().is_end_of_stream after the lock is acquired.

[Tima Vaisburd, 2015/06/01 18:56:52]

Done: check that EOS is in the last unit in chunk when DCHECK_IS_ON(), but
assume this without checking when DCHECK is off.

+#if DCHECK_IS_ON()
+    if (unit.status == DemuxerStream::kConfigChanged)
+      ++num_config_placeholders;
+#endif
+    if (unit.is_end_of_stream) {
+      DVLOG(1) << "AccessUnitQueue::" << __FUNCTION__ << ": EOS detected";
+      has_eos = true;
+    }
+  }
+
+  DCHECK(data.demuxer_configs.size() == num_config_placeholders);
+
+  // Also verify that there is no more than one |kConfigChanged| per chunk.
+  DCHECK(num_config_placeholders <= 1);
+
+  // Create the next chunk and copy data to it.
+  scoped_ptr<DemuxerData> chunk(new DemuxerData(data));
+
+  // Append this chunk to the queue.
+  base::AutoLock lock(lock_);
+
+  bool was_empty = (current_chunk_ == chunks_.end());
+
+  chunks_.push_back(chunk.Pass());
+
+  // Position the current chunk.
+  if (was_empty) {
+    current_chunk_ = chunks_.end();
+    --current_chunk_;
+    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_);
+
+  if (current_chunk_ == chunks_.end())
+    return;
+
+  ++index_in_chunk_;
+  if ((*current_chunk_)->access_units.size() <= index_in_chunk_) {
+    index_in_chunk_ = 0;
+    ++current_chunk_;
+  }
+
+  // Remove all chunks before the current
+  DataChunkQueue::iterator first_to_keep = current_chunk_;
+  chunks_.erase(chunks_.begin(), first_to_keep);
+}
+
+void AccessUnitQueue::Flush() {
+  // Media thread
+  base::AutoLock lock(lock_);
+
+  chunks_.clear();
+
+  current_chunk_ = chunks_.end();
+  index_in_chunk_ = 0;
+  has_eos_ = false;
+}
+
+bool AccessUnitQueue::SkipToKeyFrame() {
+  // Media thread
+  base::AutoLock lock(lock_);
+
+  // Search backwards in the current chunk only.
+
+  if (current_chunk_ == chunks_.end())
+    return false;
+
+  for (int i = index_in_chunk_; i >= 0; --i) {
+    if ((*current_chunk_)->access_units[i].is_key_frame)
+      return true;
+  }
+
+  return false;
+}
+
+void AccessUnitQueue::GetInfo(Info* info) const {
+  // Media thread, Decoder thread
+  base::AutoLock lock(lock_);
+
+  info->length = GetLength();
+  info->has_eos = has_eos_;
+  info->front_unit = nullptr;
+  info->configs = nullptr;
+
+  if (info->length > 0) {
+    DCHECK(current_chunk_ != chunks_.end());
+    DCHECK(index_in_chunk_ < (*current_chunk_)->access_units.size());
+    info->front_unit = &(*current_chunk_)->access_units[index_in_chunk_];
+
+    if (info->front_unit->status == DemuxerStream::kConfigChanged) {
+      DCHECK(!(*current_chunk_)->demuxer_configs.empty());
+      DCHECK((*current_chunk_)->demuxer_configs.size() == 1);
+      info->configs = &(*current_chunk_)->demuxer_configs[0];
+    }
+  }
+}
+
+int AccessUnitQueue::GetLength() const {
+  int result = 0;
+  DataChunkQueue::const_iterator chunk;
+  for (chunk = current_chunk_; chunk != chunks_.end(); ++chunk) {
+    result += (*chunk)->access_units.size();
+    if (chunk == current_chunk_)
+      result -= index_in_chunk_;
+  }
+  return result;
+}
+
+}  // namespace media