EME: Handle NO_KEY and resume playback after key is added.

media/base/android/media_decoder_job.cc

 // Copyright 2013 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_decoder_job.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/android/media_codec_bridge.h"
@@ skipping 11 matching lines @@
     MediaCodecBridge* media_codec_bridge,
     const base::Closure& request_data_cb)
     : ui_loop_(base::MessageLoopProxy::current()),
       decoder_loop_(decoder_loop),
       media_codec_bridge_(media_codec_bridge),
       needs_flush_(false),
       input_eos_encountered_(false),
       weak_this_(this),
       request_data_cb_(request_data_cb),
       access_unit_index_(0),
+      input_buf_index_(-1),
       stop_decode_pending_(false),
       destroy_pending_(false) {
 }
 
 MediaDecoderJob::~MediaDecoderJob() {}
 
 void MediaDecoderJob::OnDataReceived(const DemuxerData& data) {
+  DVLOG(1) << __FUNCTION__ << ": " << data.access_units.size() << " units";
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(!on_data_received_cb_.is_null());
 
   base::Closure done_cb = base::ResetAndReturn(&on_data_received_cb_);
 
   if (stop_decode_pending_) {
     OnDecodeCompleted(MEDIA_CODEC_STOPPED, kNoTimestamp(), 0);
     return;
   }
 
@@ skipping 76 matching lines @@
   request_data_cb_.Reset();
   on_data_received_cb_.Reset();
   decode_cb_.Reset();
 
   if (destroy_pending_)
     return;
 
   delete this;
 }
 
-MediaCodecStatus MediaDecoderJob::QueueInputBuffer(
-    const AccessUnit& unit) {
-  base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(
-      kMediaCodecTimeoutInMilliseconds);
-  int input_buf_index = 0;
-  MediaCodecStatus status =
-      media_codec_bridge_->DequeueInputBuffer(timeout, &input_buf_index);
-  if (status != MEDIA_CODEC_OK)
-    return status;
+MediaCodecStatus MediaDecoderJob::QueueInputBuffer(const AccessUnit& unit) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(decoder_loop_->BelongsToCurrentThread());
+
+  int input_buf_index = input_buf_index_;
+  input_buf_index_ = -1;
+
+  // TODO(xhwang): Hide DequeueInputBuffer() and the index in MediaCodecBridge.
+  if (input_buf_index == -1) {
+    base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(
+        kMediaCodecTimeoutInMilliseconds);
+    MediaCodecStatus status =
+        media_codec_bridge_->DequeueInputBuffer(timeout, &input_buf_index);
+    if (status != MEDIA_CODEC_OK) {
+      DVLOG(1) << "DequeueInputBuffer fails: " << status;
+      return status;
+    }
+  }
 
   // TODO(qinmin): skip frames if video is falling far behind.
   DCHECK_GE(input_buf_index, 0);
   if (unit.end_of_stream || unit.data.empty()) {
-    media_codec_bridge_->QueueEOS(input_buf_index);
+    media_codec_bridge_->QueueEOS(input_buf_index_);
     return MEDIA_CODEC_INPUT_END_OF_STREAM;
   }
 
   if (unit.key_id.empty()) {
-    media_codec_bridge_->QueueInputBuffer(
+    return media_codec_bridge_->QueueInputBuffer(
         input_buf_index, &unit.data[0], unit.data.size(), unit.timestamp);
-    return MEDIA_CODEC_OK;
   }
 
   if (unit.iv.empty() || unit.subsamples.empty()) {
-    LOG(ERROR) << "The access unit doesn't have iv or subsamples while it "
+    DVLOG(1) << "The access unit doesn't have iv or subsamples while it "
                << "has key IDs!";
     return MEDIA_CODEC_ERROR;
   }
 
-  media_codec_bridge_->QueueSecureInputBuffer(
+  MediaCodecStatus status = media_codec_bridge_->QueueSecureInputBuffer(
       input_buf_index, &unit.data[0], unit.data.size(),
       reinterpret_cast<const uint8*>(&unit.key_id[0]), unit.key_id.size(),
       reinterpret_cast<const uint8*>(&unit.iv[0]), unit.iv.size(),
       &unit.subsamples[0], unit.subsamples.size(), unit.timestamp);
-  return MEDIA_CODEC_OK;
+
+  // In case of MEDIA_CODEC_NO_KEY, we must reuse the |input_buf_index_|.
+  // Otherwise MediaDrm will report errors.
+  if (status == MEDIA_CODEC_NO_KEY)
+    input_buf_index_ = input_buf_index;
+
+  return status;
 }
 
 void MediaDecoderJob::RequestData(const base::Closure& done_cb) {
+  DVLOG(1) << __FUNCTION__;
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(on_data_received_cb_.is_null());
 
   received_data_ = DemuxerData();
   access_unit_index_ = 0;
   on_data_received_cb_ = done_cb;
 
   request_data_cb_.Run();
 }
 
@@ skipping 11 matching lines @@
           &MediaDecoderJob::OnDecodeCompleted, base::Unretained(this)))));
   needs_flush_ = false;
 }
 
 void MediaDecoderJob::DecodeInternal(
     const AccessUnit& unit,
     const base::TimeTicks& start_time_ticks,
     const base::TimeDelta& start_presentation_timestamp,
     bool needs_flush,
     const MediaDecoderJob::DecoderCallback& callback) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(decoder_loop_->BelongsToCurrentThread());
+
   if (needs_flush) {
     DVLOG(1) << "DecodeInternal needs flush.";
     input_eos_encountered_ = false;
     media_codec_bridge_->Reset();
   }
 
   MediaCodecStatus input_status = MEDIA_CODEC_INPUT_END_OF_STREAM;
   if (!input_eos_encountered_) {
     input_status = QueueInputBuffer(unit);
     if (input_status == MEDIA_CODEC_INPUT_END_OF_STREAM) {
@@ skipping 38 matching lines @@
 
   base::TimeDelta time_to_render;
   DCHECK(!start_time_ticks.is_null());
   if (ComputeTimeToRender()) {
     time_to_render = presentation_timestamp - (base::TimeTicks::Now() -
         start_time_ticks + start_presentation_timestamp);
   }
 
   // TODO(acolwell): Change to > since the else will never run for audio.
   if (time_to_render >= base::TimeDelta()) {
-    base::MessageLoop::current()->PostDelayedTask(
+    decoder_loop_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&MediaDecoderJob::ReleaseOutputBuffer,
                    weak_this_.GetWeakPtr(), buffer_index, size,
                    presentation_timestamp, callback, status),
         time_to_render);
     return;
   }
 
   // TODO(qinmin): The codec is lagging behind, need to recalculate the
   // |start_presentation_timestamp_| and |start_time_ticks_|.
   DVLOG(1) << "codec is lagging behind :" << time_to_render.InMicroseconds();
   ReleaseOutputBuffer(buffer_index, size, presentation_timestamp,
                       callback, status);
 }
 
 void MediaDecoderJob::OnDecodeCompleted(
     MediaCodecStatus status, const base::TimeDelta& presentation_timestamp,
     size_t audio_output_bytes) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(status != MEDIA_CODEC_STOPPED || received_data_.access_units.empty());
 
   if (destroy_pending_) {
     delete this;
     return;
   }
 
   DCHECK(!decode_cb_.is_null());
 
   if (status != MEDIA_CODEC_ERROR &&
-      status != MEDIA_CODEC_ENQUEUE_INPUT_AGAIN_LATER &&
+      status != MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER &&
       status != MEDIA_CODEC_INPUT_END_OF_STREAM &&
+      status != MEDIA_CODEC_NO_KEY &&
       status != MEDIA_CODEC_STOPPED) {
     access_unit_index_++;
   }
 
   stop_decode_pending_ = false;
   base::ResetAndReturn(&decode_cb_).Run(status, presentation_timestamp,
                                         audio_output_bytes);
 }
 
 }  // namespace media