Audio and video decoders for MediaCodecPlayer

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..b6c23b6729758a9c049954e4745082475af9ea2c
--- /dev/null
+++ b/media/base/android/access_unit_queue.cc
@@ -0,0 +1,150 @@
+// 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() {

[liberato (no reviews please), 2015/06/12 22:24:15]

nit: why provide an empty, non-virtual destructor?  probably doesn't make a
difference since the class has members which (probably) have non-trivial
destructors.  AUQ will end up with the same non-trivial destructor either way.

or is there some rule i'm forgetting about these things?  c++ is so subtle these
days, it's hard to tell.

[Tima Vaisburd, 2015/06/12 22:49:01]

Having access_unit_queue in this CL is really confusing. The queue and it's unit
tests are extracted and iterating in a separate CL with Matt and is supposed to
land first. I had to put an obsolete copy of these files to make this CL compile
and work.

[Tima Vaisburd, 2015/06/15 18:57:08]

In the latest version of AccessUnitQueue that has been committed destructor
became non-trivial.
Back to the essence of you question though: I put the destructor by habit,
although maybe a bad one... My major motivation was to explicitly show that
"destructor is here and is default desctructor, indeed". Omitting it would do
just the same, and I do not know any c++ rule that would overcome this, I think
you are absolutely right. You would need to make sure there is no dtor at all by
examining the header file, which might be inconvenient as the class grows
bigger. Probably "=default" from c++11 is the best.

+}
+
+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;
+
+  for (size_t i = 0; i < data.access_units.size(); ++i) {
+    const AccessUnit& unit = data.access_units[i];
+    if (unit.status == DemuxerStream::kConfigChanged)
+      ++num_config_placeholders;
+
+    // EOS must be the last unit in the chunk
+    if (unit.is_end_of_stream) {
+      DCHECK(i == data.access_units.size() - 1);
+    }
+  }
+#endif
+
+  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));
+
+  // EOS flag can only be in the last access unit.
+  bool has_eos = chunk->access_units.back().is_end_of_stream;
+
+  // 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();
+    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) {
+      index_in_chunk_ = i;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+AccessUnitQueue::Info AccessUnitQueue::GetInfo() const {
+  // Media thread, Decoder thread
+
+  Info info;
+  base::AutoLock lock(lock_);
+
+  info.length = GetUndecodedAccessUnitLength();
+  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.size() == 1);
+      info.configs = &(*current_chunk_)->demuxer_configs[0];
+    }
+  }
+  return info;
+}
+
+int AccessUnitQueue::GetUndecodedAccessUnitLength() const {
+  int result = 0;
+  DataChunkQueue::const_iterator chunk;
+  for (chunk = current_chunk_; chunk != chunks_.end(); ++chunk)
+    result += (*chunk)->access_units.size();
+
+  result -= index_in_chunk_;
+  return result;
+}
+
+}  // namespace media