Implementation of MediaCodecPlayer stage 1

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 "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;
+
+  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();
+    --current_chunk_;

[watk, 2015/06/04 20:56:43]

It seems more obvious to use chunks_.begin()?

[Tima Vaisburd, 2015/06/05 04:17:46]

I need an iterator that points to the last (newly added) element, not the first
one. I changed to
current_chunk_ = --chunks_.end();

[watk, 2015/06/05 20:13:22]

Oh, I thought was_empty meant chunks_ was empty

[Tima Vaisburd, 2015/06/05 22:09:46]

I did not explain it well. I agree with you that right now, when we keep no
history, here first and last chunk is the same one. But I'd like to leave an
option to have longer history, in this case was_empty means that Advance()
passed through the end, but does not mean the chunks_ is actually empty.

+    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;
+}
+
+void AccessUnitQueue::GetInfo(Info* info) const {

[watk, 2015/06/04 20:56:43]

Any reason to not return the Info by value here? It seems like it would be a
nicer api and it's a tiny struct.

[Tima Vaisburd, 2015/06/05 04:17:46]

Still it would be perhaps 16 bytes instead of 4, why wouldn't we care?

[watk, 2015/06/05 20:13:22]

With RVO I doubt this will be a copy. In any case, even if we're copying 16
bytes I think it's worth it.

Totally up to you, though!

[Tima Vaisburd, 2015/06/05 22:09:45]

Done.

+  // Media thread, Decoder thread
+  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];
+    }
+  }
+}
+
+int AccessUnitQueue::GetUndecodedAccessUnitLength() 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_;

[watk, 2015/06/04 20:56:43]

Can you move this outside of the for loop and remove the if-statement?

[Tima Vaisburd, 2015/06/05 04:17:46]

I redid the method but not sure I like it better the new way. Please take a
look.

[watk, 2015/06/05 20:13:22]

I agree your previous version was better than the current one. Sorry for being
confusing. I was thinking this:

int result = 0;
DataChunkQueue::const_iterator chunk;
for (chunk = current_chunk_; chunk != chunks_.end(); ++chunk) {
  result += (*chunk)->access_units.size();
}
result -= index_in_chunk_;

[Tima Vaisburd, 2015/06/05 22:09:46]

Shame on me! Done.

+  }
+  return result;
+}
+
+}  // namespace media