/media/base/android/media_codec_decoder.cc
C++ | 958 lines | 666 code | 210 blank | 82 comment | 109 complexity | 8313295519847001ab5a6de15bb723aa MD5 | raw file
- // 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/media_codec_decoder.h"
- #include "base/bind.h"
- #include "base/bind_helpers.h"
- #include "base/callback_helpers.h"
- #include "base/logging.h"
- #include "media/base/android/media_codec_bridge.h"
- namespace media {
- namespace {
- // Stop requesting new data in the kPrefetching state when the queue size
- // reaches this limit.
- const int kPrefetchLimit = 8;
- // Request new data in the kRunning state if the queue size is less than this.
- const int kPlaybackLowLimit = 4;
- // Posting delay of the next frame processing, in milliseconds
- const int kNextFrameDelay = 1;
- // Timeout for dequeuing an input buffer from MediaCodec in milliseconds.
- const int kInputBufferTimeout = 20;
- // Timeout for dequeuing an output buffer from MediaCodec in milliseconds.
- const int kOutputBufferTimeout = 20;
- }
- MediaCodecDecoder::MediaCodecDecoder(
- const char* decoder_thread_name,
- const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
- FrameStatistics* frame_statistics,
- const base::Closure& external_request_data_cb,
- const base::Closure& starvation_cb,
- const base::Closure& decoder_drained_cb,
- const base::Closure& stop_done_cb,
- const base::Closure& waiting_for_decryption_key_cb,
- const base::Closure& error_cb)
- : decoder_thread_(decoder_thread_name),
- media_task_runner_(media_task_runner),
- frame_statistics_(frame_statistics),
- needs_reconfigure_(false),
- drain_decoder_(false),
- always_reconfigure_for_tests_(false),
- external_request_data_cb_(external_request_data_cb),
- starvation_cb_(starvation_cb),
- decoder_drained_cb_(decoder_drained_cb),
- stop_done_cb_(stop_done_cb),
- waiting_for_decryption_key_cb_(waiting_for_decryption_key_cb),
- error_cb_(error_cb),
- state_(kStopped),
- is_prepared_(false),
- eos_enqueued_(false),
- missing_key_reported_(false),
- completed_(false),
- last_frame_posted_(false),
- is_data_request_in_progress_(false),
- is_incoming_data_invalid_(false),
- #ifndef NDEBUG
- verify_next_frame_is_key_(false),
- #endif
- weak_factory_(this) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << "Decoder::Decoder() " << decoder_thread_name;
- internal_error_cb_ =
- base::Bind(&MediaCodecDecoder::OnCodecError, weak_factory_.GetWeakPtr());
- internal_preroll_done_cb_ =
- base::Bind(&MediaCodecDecoder::OnPrerollDone, weak_factory_.GetWeakPtr());
- request_data_cb_ =
- base::Bind(&MediaCodecDecoder::RequestData, weak_factory_.GetWeakPtr());
- }
- MediaCodecDecoder::~MediaCodecDecoder() {}
- const char* MediaCodecDecoder::class_name() const {
- return "Decoder";
- }
- void MediaCodecDecoder::Flush() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__;
- DCHECK_EQ(GetState(), kStopped);
- // Flush() is a part of the Seek request. Whenever we request a seek we need
- // to invalidate the current data request.
- if (is_data_request_in_progress_)
- is_incoming_data_invalid_ = true;
- eos_enqueued_ = false;
- missing_key_reported_ = false;
- completed_ = false;
- drain_decoder_ = false;
- au_queue_.Flush();
- // |is_prepared_| is set on the decoder thread, it shouldn't be running now.
- DCHECK(!decoder_thread_.IsRunning());
- is_prepared_ = false;
- #ifndef NDEBUG
- // We check and reset |verify_next_frame_is_key_| on Decoder thread.
- // We have just DCHECKed that decoder thread is not running.
- // For video the first frame after flush must be key frame.
- verify_next_frame_is_key_ = true;
- #endif
- if (media_codec_bridge_) {
- // MediaCodecBridge::Reset() performs MediaCodecBridge.flush()
- MediaCodecStatus flush_status = media_codec_bridge_->Reset();
- if (flush_status != MEDIA_CODEC_OK) {
- DVLOG(0) << class_name() << "::" << __FUNCTION__
- << "MediaCodecBridge::Reset() failed";
- media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
- }
- }
- }
- void MediaCodecDecoder::ReleaseMediaCodec() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__;
- DCHECK(!decoder_thread_.IsRunning());
- media_codec_bridge_.reset();
- // |is_prepared_| is set on the decoder thread, it shouldn't be running now.
- is_prepared_ = false;
- }
- bool MediaCodecDecoder::IsPrefetchingOrPlaying() const {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- // Whether decoder needs to be stopped.
- base::AutoLock lock(state_lock_);
- switch (state_) {
- case kPrefetching:
- case kPrefetched:
- case kPrerolling:
- case kPrerolled:
- case kRunning:
- return true;
- case kStopped:
- case kStopping:
- case kInEmergencyStop:
- case kError:
- return false;
- }
- NOTREACHED();
- return false;
- }
- bool MediaCodecDecoder::IsStopped() const {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- return GetState() == kStopped;
- }
- bool MediaCodecDecoder::IsCompleted() const {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- return completed_;
- }
- bool MediaCodecDecoder::NotCompletedAndNeedsPreroll() const {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- return HasStream() && !completed_ &&
- (!is_prepared_ || preroll_timestamp_ != base::TimeDelta());
- }
- void MediaCodecDecoder::SetPrerollTimestamp(base::TimeDelta preroll_timestamp) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__ << ": " << preroll_timestamp;
- preroll_timestamp_ = preroll_timestamp;
- }
- void MediaCodecDecoder::SetNeedsReconfigure() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__;
- needs_reconfigure_ = true;
- }
- void MediaCodecDecoder::Prefetch(const base::Closure& prefetch_done_cb) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__;
- DCHECK(GetState() == kStopped);
- prefetch_done_cb_ = prefetch_done_cb;
- SetState(kPrefetching);
- PrefetchNextChunk();
- }
- MediaCodecDecoder::ConfigStatus MediaCodecDecoder::Configure(
- jobject media_crypto) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__;
- if (GetState() == kError) {
- DVLOG(0) << class_name() << "::" << __FUNCTION__ << ": wrong state kError";
- return kConfigFailure;
- }
- if (needs_reconfigure_) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << ": needs reconfigure, deleting MediaCodec";
- needs_reconfigure_ = false;
- ReleaseMediaCodec();
- }
- if (media_codec_bridge_) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << ": reconfiguration is not required, ignoring";
- return kConfigOk;
- }
- // Read all |kConfigChanged| units preceding the data one.
- AccessUnitQueue::Info au_info = au_queue_.GetInfo();
- while (au_info.configs) {
- SetDemuxerConfigs(*au_info.configs);
- au_queue_.Advance();
- au_info = au_queue_.GetInfo();
- }
- MediaCodecDecoder::ConfigStatus result = ConfigureInternal(media_crypto);
- #ifndef NDEBUG
- // We check and reset |verify_next_frame_is_key_| on Decoder thread.
- // This DCHECK ensures we won't need to lock this variable.
- DCHECK(!decoder_thread_.IsRunning());
- // For video the first frame after reconfiguration must be key frame.
- if (result == kConfigOk)
- verify_next_frame_is_key_ = true;
- #endif
- return result;
- }
- bool MediaCodecDecoder::Preroll(const base::Closure& preroll_done_cb) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << " preroll_timestamp:" << preroll_timestamp_;
- DecoderState state = GetState();
- if (state != kPrefetched) {
- DVLOG(0) << class_name() << "::" << __FUNCTION__ << ": wrong state "
- << AsString(state) << ", ignoring";
- return false;
- }
- if (!media_codec_bridge_) {
- DVLOG(0) << class_name() << "::" << __FUNCTION__
- << ": not configured, ignoring";
- return false;
- }
- DCHECK(!decoder_thread_.IsRunning());
- preroll_done_cb_ = preroll_done_cb;
- // We only synchronize video stream.
- DissociatePTSFromTime(); // associaton will happen after preroll is done.
- last_frame_posted_ = false;
- // Start the decoder thread
- if (!decoder_thread_.Start()) {
- DVLOG(0) << class_name() << "::" << __FUNCTION__
- << ": cannot start decoder thread";
- return false;
- }
- SetState(kPrerolling);
- decoder_thread_.task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&MediaCodecDecoder::ProcessNextFrame, base::Unretained(this)));
- return true;
- }
- bool MediaCodecDecoder::Start(base::TimeDelta start_timestamp) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << " start_timestamp:" << start_timestamp;
- DecoderState state = GetState();
- if (state != kPrefetched && state != kPrerolled) {
- DVLOG(0) << class_name() << "::" << __FUNCTION__ << ": wrong state "
- << AsString(state) << ", ignoring";
- return false;
- }
- if (!media_codec_bridge_) {
- DVLOG(0) << class_name() << "::" << __FUNCTION__
- << ": not configured, ignoring";
- return false;
- }
- // We only synchronize video stream.
- AssociateCurrentTimeWithPTS(start_timestamp);
- DCHECK(preroll_timestamp_ == base::TimeDelta());
- // Start the decoder thread
- if (!decoder_thread_.IsRunning()) {
- last_frame_posted_ = false;
- if (!decoder_thread_.Start()) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << ": cannot start decoder thread";
- return false;
- }
- }
- SetState(kRunning);
- decoder_thread_.task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&MediaCodecDecoder::ProcessNextFrame, base::Unretained(this)));
- return true;
- }
- void MediaCodecDecoder::SyncStop() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__;
- if (GetState() == kError) {
- DVLOG(0) << class_name() << "::" << __FUNCTION__
- << ": wrong state kError, ignoring";
- return;
- }
- DoEmergencyStop();
- ReleaseDelayedBuffers();
- }
- void MediaCodecDecoder::RequestToStop() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__;
- DecoderState state = GetState();
- switch (state) {
- case kError:
- DVLOG(0) << class_name() << "::" << __FUNCTION__
- << ": wrong state kError, ignoring";
- break;
- case kRunning:
- SetState(kStopping);
- break;
- case kPrerolling:
- case kPrerolled:
- DCHECK(decoder_thread_.IsRunning());
- // Synchronous stop.
- decoder_thread_.Stop();
- SetState(kStopped);
- media_task_runner_->PostTask(FROM_HERE, stop_done_cb_);
- break;
- case kStopping:
- case kStopped:
- break; // ignore
- case kPrefetching:
- case kPrefetched:
- // There is nothing to wait for, we can sent notification right away.
- DCHECK(!decoder_thread_.IsRunning());
- SetState(kStopped);
- media_task_runner_->PostTask(FROM_HERE, stop_done_cb_);
- break;
- default:
- NOTREACHED();
- break;
- }
- }
- void MediaCodecDecoder::OnLastFrameRendered(bool eos_encountered) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << " eos_encountered:" << eos_encountered;
- decoder_thread_.Stop(); // synchronous
- SetState(kStopped);
- completed_ = (eos_encountered && !drain_decoder_);
- missing_key_reported_ = false;
- // If the stream is completed during preroll we need to report it since
- // another stream might be running and the player waits for two callbacks.
- if (completed_ && !preroll_done_cb_.is_null()) {
- preroll_timestamp_ = base::TimeDelta();
- media_task_runner_->PostTask(FROM_HERE,
- base::ResetAndReturn(&preroll_done_cb_));
- }
- if (eos_encountered && drain_decoder_) {
- drain_decoder_ = false;
- eos_enqueued_ = false;
- ReleaseMediaCodec();
- media_task_runner_->PostTask(FROM_HERE, decoder_drained_cb_);
- }
- media_task_runner_->PostTask(FROM_HERE, stop_done_cb_);
- }
- void MediaCodecDecoder::OnPrerollDone() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << " state:" << AsString(GetState());
- preroll_timestamp_ = base::TimeDelta();
- // The state might be kStopping (?)
- if (GetState() == kPrerolling)
- SetState(kPrerolled);
- if (!preroll_done_cb_.is_null())
- base::ResetAndReturn(&preroll_done_cb_).Run();
- }
- void MediaCodecDecoder::OnDemuxerDataAvailable(const DemuxerData& data) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- // If |data| contains an aborted data, the last AU will have kAborted status.
- bool aborted_data =
- !data.access_units.empty() &&
- data.access_units.back().status == DemuxerStream::kAborted;
- #ifndef NDEBUG
- const char* explain_if_skipped =
- is_incoming_data_invalid_ ? " skipped as invalid"
- : (aborted_data ? " skipped as aborted" : "");
- for (const auto& unit : data.access_units)
- DVLOG(2) << class_name() << "::" << __FUNCTION__ << explain_if_skipped
- << " au: " << unit;
- for (const auto& configs : data.demuxer_configs)
- DVLOG(2) << class_name() << "::" << __FUNCTION__ << " configs: " << configs;
- #endif
- if (!is_incoming_data_invalid_ && !aborted_data)
- au_queue_.PushBack(data);
- is_incoming_data_invalid_ = false;
- is_data_request_in_progress_ = false;
- // Do not request data if we got kAborted. There is no point to request the
- // data after kAborted and before the OnDemuxerSeekDone.
- if (GetState() == kPrefetching && !aborted_data)
- PrefetchNextChunk();
- }
- bool MediaCodecDecoder::IsPrerollingForTests() const {
- // UI task runner.
- return GetState() == kPrerolling;
- }
- void MediaCodecDecoder::SetAlwaysReconfigureForTests() {
- // UI task runner.
- always_reconfigure_for_tests_ = true;
- }
- void MediaCodecDecoder::SetCodecCreatedCallbackForTests(base::Closure cb) {
- // UI task runner.
- codec_created_for_tests_cb_ = cb;
- }
- int MediaCodecDecoder::NumDelayedRenderTasks() const {
- return 0;
- }
- void MediaCodecDecoder::DoEmergencyStop() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__;
- // After this method returns, decoder thread will not be running.
- // Set [kInEmergencyStop| state to block already posted ProcessNextFrame().
- SetState(kInEmergencyStop);
- decoder_thread_.Stop(); // synchronous
- SetState(kStopped);
- missing_key_reported_ = false;
- }
- void MediaCodecDecoder::CheckLastFrame(bool eos_encountered,
- bool has_delayed_tasks) {
- DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
- bool last_frame_when_stopping = GetState() == kStopping && !has_delayed_tasks;
- if (last_frame_when_stopping || eos_encountered) {
- media_task_runner_->PostTask(
- FROM_HERE, base::Bind(&MediaCodecDecoder::OnLastFrameRendered,
- weak_factory_.GetWeakPtr(), eos_encountered));
- last_frame_posted_ = true;
- }
- }
- void MediaCodecDecoder::OnCodecError() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- // Ignore codec errors from the moment surface is changed till the
- // |media_codec_bridge_| is deleted.
- if (needs_reconfigure_) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << ": needs reconfigure, ignoring";
- return;
- }
- SetState(kError);
- error_cb_.Run();
- }
- void MediaCodecDecoder::RequestData() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- // Ensure one data request at a time.
- if (!is_data_request_in_progress_) {
- is_data_request_in_progress_ = true;
- external_request_data_cb_.Run();
- }
- }
- void MediaCodecDecoder::PrefetchNextChunk() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DVLOG(1) << class_name() << "::" << __FUNCTION__;
- AccessUnitQueue::Info au_info = au_queue_.GetInfo();
- if (eos_enqueued_ || au_info.data_length >= kPrefetchLimit ||
- au_info.has_eos) {
- // We are done prefetching
- SetState(kPrefetched);
- DVLOG(1) << class_name() << "::" << __FUNCTION__ << " posting PrefetchDone";
- media_task_runner_->PostTask(FROM_HERE,
- base::ResetAndReturn(&prefetch_done_cb_));
- return;
- }
- request_data_cb_.Run();
- }
- void MediaCodecDecoder::ProcessNextFrame() {
- DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
- DVLOG(2) << class_name() << "::" << __FUNCTION__;
- DecoderState state = GetState();
- if (state != kPrerolling && state != kRunning && state != kStopping) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << ": state: " << AsString(state) << " stopping frame processing";
- return;
- }
- if (state == kStopping) {
- if (NumDelayedRenderTasks() == 0 && !last_frame_posted_) {
- media_task_runner_->PostTask(
- FROM_HERE, base::Bind(&MediaCodecDecoder::OnLastFrameRendered,
- weak_factory_.GetWeakPtr(), false));
- last_frame_posted_ = true;
- }
- // We can stop processing, the |au_queue_| and MediaCodec queues can freeze.
- // We only need to let finish the delayed rendering tasks.
- DVLOG(1) << class_name() << "::" << __FUNCTION__ << " kStopping, returning";
- return;
- }
- DCHECK(state == kPrerolling || state == kRunning);
- if (!EnqueueInputBuffer())
- return;
- if (!DepleteOutputBufferQueue())
- return;
- // We need a small delay if we want to stop this thread by
- // decoder_thread_.Stop() reliably.
- // The decoder thread message loop processes all pending
- // (but not delayed) tasks before it can quit; without a delay
- // the message loop might be forever processing the pendng tasks.
- decoder_thread_.task_runner()->PostDelayedTask(
- FROM_HERE,
- base::Bind(&MediaCodecDecoder::ProcessNextFrame, base::Unretained(this)),
- base::TimeDelta::FromMilliseconds(kNextFrameDelay));
- }
- // Returns false if we should stop decoding process. Right now
- // it happens if we got MediaCodec error or detected starvation.
- bool MediaCodecDecoder::EnqueueInputBuffer() {
- DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
- DVLOG(2) << class_name() << "::" << __FUNCTION__;
- if (eos_enqueued_) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << ": EOS enqueued, returning";
- return true; // Nothing to do
- }
- if (missing_key_reported_) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << ": NO KEY reported, returning";
- return true; // Nothing to do
- }
- // Keep the number pending video frames low, ideally maintaining
- // the same audio and video duration after stop request
- if (NumDelayedRenderTasks() > 1) {
- DVLOG(2) << class_name() << "::" << __FUNCTION__ << ": # delayed buffers ("
- << NumDelayedRenderTasks() << ") exceeds 1, returning";
- return true; // Nothing to do
- }
- // Get the next frame from the queue. As we go, request more data and
- // consume |kConfigChanged| units.
- // |drain_decoder_| can be already set here if we could not dequeue the input
- // buffer for it right away.
- AccessUnitQueue::Info au_info;
- if (!drain_decoder_) {
- au_info = AdvanceAccessUnitQueue(&drain_decoder_);
- if (!au_info.length) {
- // Report starvation and return, Start() will be called again later.
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << ": starvation detected";
- media_task_runner_->PostTask(FROM_HERE, starvation_cb_);
- return true;
- }
- DCHECK(au_info.front_unit);
- #ifndef NDEBUG
- if (verify_next_frame_is_key_) {
- verify_next_frame_is_key_ = false;
- VerifyUnitIsKeyFrame(au_info.front_unit);
- }
- #endif
- }
- // Dequeue input buffer
- base::TimeDelta timeout =
- base::TimeDelta::FromMilliseconds(kInputBufferTimeout);
- int index = -1;
- MediaCodecStatus status =
- media_codec_bridge_->DequeueInputBuffer(timeout, &index);
- DVLOG(2) << class_name() << ":: DequeueInputBuffer index:" << index;
- switch (status) {
- case MEDIA_CODEC_ERROR:
- DVLOG(0) << class_name() << "::" << __FUNCTION__
- << ": MEDIA_CODEC_ERROR DequeueInputBuffer failed";
- media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
- return false;
- case MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER:
- DVLOG(2)
- << class_name() << "::" << __FUNCTION__
- << ": DequeueInputBuffer returned MediaCodec.INFO_TRY_AGAIN_LATER.";
- return true;
- default:
- break;
- }
- // We got the buffer
- DCHECK_EQ(status, MEDIA_CODEC_OK);
- DCHECK_GE(index, 0);
- const AccessUnit* unit = au_info.front_unit;
- if (drain_decoder_ || unit->is_end_of_stream) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__ << ": QueueEOS";
- media_codec_bridge_->QueueEOS(index);
- eos_enqueued_ = true;
- return true;
- }
- DCHECK(unit);
- DCHECK(!unit->data.empty());
- if (unit->key_id.empty() || unit->iv.empty()) {
- DVLOG(2) << class_name() << "::" << __FUNCTION__
- << ": QueueInputBuffer pts:" << unit->timestamp;
- status = media_codec_bridge_->QueueInputBuffer(
- index, &unit->data[0], unit->data.size(), unit->timestamp);
- } else {
- DVLOG(2) << class_name() << "::" << __FUNCTION__
- << ": QueueSecureInputBuffer pts:" << unit->timestamp
- << " key_id size:" << unit->key_id.size()
- << " iv size:" << unit->iv.size()
- << " subsamples size:" << unit->subsamples.size();
- status = media_codec_bridge_->QueueSecureInputBuffer(
- index, &unit->data[0], unit->data.size(),
- reinterpret_cast<const uint8_t*>(&unit->key_id[0]), unit->key_id.size(),
- reinterpret_cast<const uint8_t*>(&unit->iv[0]), unit->iv.size(),
- unit->subsamples.empty() ? nullptr : &unit->subsamples[0],
- unit->subsamples.size(), unit->timestamp);
- }
- switch (status) {
- case MEDIA_CODEC_OK:
- break;
- case MEDIA_CODEC_ERROR:
- DVLOG(0) << class_name() << "::" << __FUNCTION__
- << ": MEDIA_CODEC_ERROR: QueueInputBuffer failed";
- media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
- return false;
- case MEDIA_CODEC_NO_KEY:
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << ": MEDIA_CODEC_NO_KEY";
- media_task_runner_->PostTask(FROM_HERE, waiting_for_decryption_key_cb_);
- // In response to the |waiting_for_decryption_key_cb_| the player will
- // request to stop decoder. We need to keep running to properly perform
- // the stop, but prevent enqueuing the same frame over and over again so
- // we won't generate more |waiting_for_decryption_key_cb_|.
- missing_key_reported_ = true;
- return true;
- default:
- NOTREACHED() << class_name() << "::" << __FUNCTION__
- << ": unexpected error code " << status;
- media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
- return false;
- }
- // Have successfully queued input buffer, go to next access unit.
- au_queue_.Advance();
- return true;
- }
- AccessUnitQueue::Info MediaCodecDecoder::AdvanceAccessUnitQueue(
- bool* drain_decoder) {
- DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
- DVLOG(2) << class_name() << "::" << __FUNCTION__;
- // Retrieve access units from the |au_queue_| in a loop until we either get
- // a non-config front unit or until the queue is empty.
- DCHECK(drain_decoder != nullptr);
- AccessUnitQueue::Info au_info;
- do {
- // Get current frame
- au_info = au_queue_.GetInfo();
- // Request the data from Demuxer
- if (au_info.data_length <= kPlaybackLowLimit && !au_info.has_eos)
- media_task_runner_->PostTask(FROM_HERE, request_data_cb_);
- if (!au_info.length)
- break; // Starvation
- if (au_info.configs) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__ << ": received configs "
- << (*au_info.configs);
- // Compare the new and current configs.
- if (IsCodecReconfigureNeeded(*au_info.configs)) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << ": reconfiguration and decoder drain required";
- *drain_decoder = true;
- }
- // Replace the current configs.
- SetDemuxerConfigs(*au_info.configs);
- // Move to the next frame
- au_queue_.Advance();
- }
- } while (au_info.configs);
- return au_info;
- }
- // Returns false if there was MediaCodec error.
- bool MediaCodecDecoder::DepleteOutputBufferQueue() {
- DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
- DVLOG(2) << class_name() << "::" << __FUNCTION__;
- int buffer_index = 0;
- size_t offset = 0;
- size_t size = 0;
- base::TimeDelta pts;
- MediaCodecStatus status;
- bool eos_encountered = false;
- RenderMode render_mode;
- base::TimeDelta timeout =
- base::TimeDelta::FromMilliseconds(kOutputBufferTimeout);
- // Extract all output buffers that are available.
- // Usually there will be only one, but sometimes it is preceeded by
- // MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED or MEDIA_CODEC_OUTPUT_FORMAT_CHANGED.
- do {
- status = media_codec_bridge_->DequeueOutputBuffer(
- timeout, &buffer_index, &offset, &size, &pts, &eos_encountered,
- nullptr);
- // Reset the timeout to 0 for the subsequent DequeueOutputBuffer() calls
- // to quickly break the loop after we got all currently available buffers.
- timeout = base::TimeDelta::FromMilliseconds(0);
- switch (status) {
- case MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
- // Output buffers are replaced in MediaCodecBridge, nothing to do.
- DVLOG(2) << class_name() << "::" << __FUNCTION__
- << " MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED";
- break;
- case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:
- DVLOG(2) << class_name() << "::" << __FUNCTION__
- << " MEDIA_CODEC_OUTPUT_FORMAT_CHANGED";
- OnOutputFormatChanged();
- break;
- case MEDIA_CODEC_OK:
- // We got the decoded frame.
- is_prepared_ = true;
- if (pts < preroll_timestamp_)
- render_mode = kRenderSkip;
- else if (GetState() == kPrerolling)
- render_mode = kRenderAfterPreroll;
- else
- render_mode = kRenderNow;
- Render(buffer_index, offset, size, render_mode, pts, eos_encountered);
- if (render_mode == kRenderAfterPreroll) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__ << " pts " << pts
- << " >= preroll timestamp " << preroll_timestamp_
- << " preroll done, stopping frame processing";
- media_task_runner_->PostTask(FROM_HERE, internal_preroll_done_cb_);
- return false;
- }
- break;
- case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
- // Nothing to do.
- DVLOG(2) << class_name() << "::" << __FUNCTION__
- << " MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER";
- break;
- case MEDIA_CODEC_ERROR:
- DVLOG(0) << class_name() << "::" << __FUNCTION__
- << ": MEDIA_CODEC_ERROR from DequeueOutputBuffer";
- media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
- break;
- default:
- NOTREACHED();
- break;
- }
- } while (status != MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER &&
- status != MEDIA_CODEC_ERROR && !eos_encountered);
- if (eos_encountered) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__
- << " EOS dequeued, stopping frame processing";
- return false;
- }
- if (status == MEDIA_CODEC_ERROR) {
- DVLOG(0) << class_name() << "::" << __FUNCTION__
- << " MediaCodec error, stopping frame processing";
- return false;
- }
- return true;
- }
- MediaCodecDecoder::DecoderState MediaCodecDecoder::GetState() const {
- base::AutoLock lock(state_lock_);
- return state_;
- }
- void MediaCodecDecoder::SetState(DecoderState state) {
- DVLOG(1) << class_name() << "::" << __FUNCTION__ << " " << AsString(state);
- base::AutoLock lock(state_lock_);
- state_ = state;
- }
- #undef RETURN_STRING
- #define RETURN_STRING(x) \
- case x: \
- return #x;
- const char* MediaCodecDecoder::AsString(RenderMode render_mode) {
- switch (render_mode) {
- RETURN_STRING(kRenderSkip);
- RETURN_STRING(kRenderAfterPreroll);
- RETURN_STRING(kRenderNow);
- }
- return nullptr; // crash early
- }
- const char* MediaCodecDecoder::AsString(DecoderState state) {
- switch (state) {
- RETURN_STRING(kStopped);
- RETURN_STRING(kPrefetching);
- RETURN_STRING(kPrefetched);
- RETURN_STRING(kPrerolling);
- RETURN_STRING(kPrerolled);
- RETURN_STRING(kRunning);
- RETURN_STRING(kStopping);
- RETURN_STRING(kInEmergencyStop);
- RETURN_STRING(kError);
- }
- return nullptr; // crash early
- }
- #undef RETURN_STRING
- } // namespace media