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

media/base/android/media_source_player.cc

 // Copyright (c) 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_source_player.h"
 
+#include <limits>
+
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/barrier_closure.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/android/audio_decoder_job.h"
 #include "media/base/android/media_drm_bridge.h"
 #include "media/base/android/media_player_manager.h"
 #include "media/base/android/video_decoder_job.h"
@@ skipping 161 matching lines @@
   pending_event_ = NO_EVENT_PENDING;
   surface_ = gfx::ScopedJavaSurface();
   ReleaseMediaResourcesFromManager();
 }
 
 void MediaSourcePlayer::SetVolume(double volume) {
   volume_ = volume;
   SetVolumeInternal();
 }
 
+void MediaSourcePlayer::OnKeyAdded() {
+  DVLOG(1) << __FUNCTION__;
+  if (playing_)
+    StartInternal();
+}
+
 bool MediaSourcePlayer::CanPause() {
   return Seekable();
 }
 
 bool MediaSourcePlayer::CanSeekForward() {
   return Seekable();
 }
 
 bool MediaSourcePlayer::CanSeekBackward() {
   return Seekable();
 }
 
 bool MediaSourcePlayer::IsPlayerReady() {
   return audio_decoder_job_ || video_decoder_job_;
 }
 
 void MediaSourcePlayer::StartInternal() {
   DVLOG(1) << __FUNCTION__;
   // If there are pending events, wait for them finish.
   if (pending_event_ != NO_EVENT_PENDING)
     return;
 
   // Create decoder jobs if they are not created
   ConfigureAudioDecoderJob();
   ConfigureVideoDecoderJob();
 
-
   // If one of the decoder job is not ready, do nothing.
   if ((HasAudio() && !audio_decoder_job_) ||
       (HasVideo() && !video_decoder_job_)) {
     return;
   }
 
   audio_finished_ = false;
   video_finished_ = false;
   SetPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
   ProcessPendingEvents();
@@ skipping 114 matching lines @@
         audio_output_bytes / (kBytesPerAudioOutputSample * num_channels_));
     clock_.SetMaxTime(audio_timestamp_helper_->GetTimestamp());
   } else {
     clock_.SetMaxTime(presentation_timestamp);
   }
 
   OnTimeUpdated();
 }
 
 void MediaSourcePlayer::ProcessPendingEvents() {
-  DVLOG(1) << __FUNCTION__ << " : 0x"
-           << std::hex << pending_event_;
+  DVLOG(1) << __FUNCTION__ << " : 0x" << std::hex << pending_event_;
   // Wait for all the decoding jobs to finish before processing pending tasks.
-  if ((audio_decoder_job_ && audio_decoder_job_->is_decoding()) ||
-      (video_decoder_job_ && video_decoder_job_->is_decoding())) {
-    DVLOG(1) << __FUNCTION__ << " : A job is still decoding.";
+  if (video_decoder_job_ && video_decoder_job_->is_decoding()) {
+    DVLOG(1) << __FUNCTION__ << " : A video job is still decoding.";
     return;
   }
 
+  if (audio_decoder_job_ && audio_decoder_job_->is_decoding()) {
+    DVLOG(1) << __FUNCTION__ << " : An audio job is still decoding.";
+    return;
+  }
+
   if (IsEventPending(PREFETCH_DONE_EVENT_PENDING)) {
     DVLOG(1) << __FUNCTION__ << " : PREFETCH_DONE still pending.";
     return;
   }
 
   if (IsEventPending(SEEK_EVENT_PENDING)) {
     DVLOG(1) << __FUNCTION__ << " : Handling SEEK_EVENT.";
     ClearDecodingData();
     manager()->OnMediaSeekRequest(
         player_id(), GetCurrentTime(), ++seek_request_id_);
@@ skipping 37 matching lines @@
 
   // Now that all pending events have been handled, resume decoding if we are
   // still playing.
   if (playing_)
     StartInternal();
 }
 
 void MediaSourcePlayer::MediaDecoderCallback(
     bool is_audio, MediaCodecStatus status,
     const base::TimeDelta& presentation_timestamp, size_t audio_output_bytes) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__ << ": " << is_audio << ", " << status;
   if (is_audio)
     decoder_starvation_callback_.Cancel();
 
   if (status == MEDIA_CODEC_ERROR) {
     Release();
     OnMediaError(MEDIA_ERROR_DECODE);
     return;
   }
 
   if (pending_event_ != NO_EVENT_PENDING) {
     ProcessPendingEvents();
     return;
   }
 
   if (status == MEDIA_CODEC_OK && (is_audio || !HasAudio())) {
     UpdateTimestamps(presentation_timestamp, audio_output_bytes);
   }
 
   if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) {
     PlaybackCompleted(is_audio);
     return;
   }
 
   if (!playing_) {
     if (is_audio || !HasAudio())
       clock_.Pause();
     return;
   }
 
+  if (status == MEDIA_CODEC_NO_KEY)
+    return;
+
   base::TimeDelta current_timestamp = GetCurrentTime();
   if (is_audio) {
     if (status == MEDIA_CODEC_OK) {
       base::TimeDelta timeout =
           audio_timestamp_helper_->GetTimestamp() - current_timestamp;
       StartStarvationCallback(timeout);
     }
-      DecodeMoreAudio();
+    DecodeMoreAudio();
     return;
   }
 
   if (!HasAudio() && status == MEDIA_CODEC_OK) {
     DCHECK(current_timestamp <= presentation_timestamp);
     // For video only streams, fps can be estimated from the difference
     // between the previous and current presentation timestamps. The
     // previous presentation timestamp is equal to current_timestamp.
     // TODO(qinmin): determine whether 2 is a good coefficient for estimating
     // video frame timeout.
@@ skipping 219 matching lines @@
 
 void MediaSourcePlayer::ClearPendingEvent(PendingEventFlags event) {
   DVLOG(1) << __FUNCTION__ << "(" << GetEventName(event) << ")";
   DCHECK_NE(event, NO_EVENT_PENDING);
   DCHECK(IsEventPending(event));
 
   pending_event_ &= ~event;
 }
 
 }  // namespace media