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

media/base/android/media_codec_bridge.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_codec_bridge.h"
 
 #include <jni.h>
 #include <string>
 
 #include "base/android/build_info.h"
@@ skipping 110 matching lines @@
   Java_MediaCodecBridge_stop(env, j_media_codec_.obj());
 }
 
 void MediaCodecBridge::GetOutputFormat(int* width, int* height) {
   JNIEnv* env = AttachCurrentThread();
 
   *width = Java_MediaCodecBridge_getOutputWidth(env, j_media_codec_.obj());
   *height = Java_MediaCodecBridge_getOutputHeight(env, j_media_codec_.obj());
 }
 
-size_t MediaCodecBridge::QueueInputBuffer(
-    int index, const uint8* data, int size,
+MediaCodecStatus MediaCodecBridge::QueueInputBuffer(
+    int index, const uint8* data, int data_size,
     const base::TimeDelta& presentation_time) {
-  size_t size_to_copy = FillInputBuffer(index, data, size);
+  int size_to_copy = FillInputBuffer(index, data, data_size);
+  DCHECK_EQ(size_to_copy, data_size);
   JNIEnv* env = AttachCurrentThread();
-  Java_MediaCodecBridge_queueInputBuffer(
+  return static_cast<MediaCodecStatus>(Java_MediaCodecBridge_queueInputBuffer(
       env, j_media_codec_.obj(),
-      index, 0, size_to_copy, presentation_time.InMicroseconds(), 0);
-  return size_to_copy;
+      index, 0, size_to_copy, presentation_time.InMicroseconds(), 0));
 }
 
-size_t MediaCodecBridge::QueueSecureInputBuffer(
+MediaCodecStatus MediaCodecBridge::QueueSecureInputBuffer(
     int index, const uint8* data, int data_size, const uint8* key_id,
     int key_id_size, const uint8* iv, int iv_size,
     const SubsampleEntry* subsamples, int subsamples_size,
     const base::TimeDelta& presentation_time) {
-  size_t size_to_copy = FillInputBuffer(index, data, data_size);
+  int size_to_copy = FillInputBuffer(index, data, data_size);
+  DCHECK_EQ(size_to_copy, data_size);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_key_id =
       base::android::ToJavaByteArray(env, key_id, key_id_size);
   ScopedJavaLocalRef<jbyteArray> j_iv =
       base::android::ToJavaByteArray(env, iv, iv_size);
   scoped_ptr<jint[]> native_clear_array(new jint[subsamples_size]);
   scoped_ptr<jint[]> native_cypher_array(new jint[subsamples_size]);
   for (int i = 0; i < subsamples_size; ++i) {
     native_clear_array[i] = subsamples[i].clear_bytes;
     native_cypher_array[i] = subsamples[i].cypher_bytes;
   }
   ScopedJavaLocalRef<jintArray> clear_array = ToJavaIntArray(
       env, native_clear_array.Pass(), subsamples_size);
   ScopedJavaLocalRef<jintArray> cypher_array = ToJavaIntArray(
       env, native_cypher_array.Pass(), subsamples_size);
 
-  Java_MediaCodecBridge_queueSecureInputBuffer(
-      env, j_media_codec_.obj(), index, 0, j_iv.obj(), j_key_id.obj(),
-      clear_array.obj(), cypher_array.obj(), subsamples_size,
-      presentation_time.InMicroseconds());
-
-  return size_to_copy;
+  return static_cast<MediaCodecStatus>(
+      Java_MediaCodecBridge_queueSecureInputBuffer(
+          env, j_media_codec_.obj(), index, 0, j_iv.obj(), j_key_id.obj(),
+          clear_array.obj(), cypher_array.obj(), subsamples_size,
+          presentation_time.InMicroseconds()));
 }
 
 void MediaCodecBridge::QueueEOS(int input_buffer_index) {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_queueInputBuffer(
       env, j_media_codec_.obj(),
       input_buffer_index, 0, 0, 0, kBufferFlagEndOfStream);
 }
 
 MediaCodecStatus MediaCodecBridge::DequeueInputBuffer(
     const base::TimeDelta& timeout, int* index) {
   JNIEnv* env = AttachCurrentThread();
-  int result = Java_MediaCodecBridge_dequeueInputBuffer(
+  ScopedJavaLocalRef<jobject> result = Java_MediaCodecBridge_dequeueInputBuffer(
       env, j_media_codec_.obj(), timeout.InMicroseconds());
-  if (result == INFO_MEDIA_CODEC_ERROR)
-    return MEDIA_CODEC_ERROR;
-  else if (result == INFO_TRY_AGAIN_LATER)
-    return MEDIA_CODEC_ENQUEUE_INPUT_AGAIN_LATER;
-
-  DCHECK_GE(result, 0);
-  *index = result;
-  return MEDIA_CODEC_OK;
+  *index = Java_DequeueInputResult_index(env, result.obj());
+  return static_cast<MediaCodecStatus>(
+      Java_DequeueInputResult_status(env, result.obj()));
 }
 
 MediaCodecStatus MediaCodecBridge::DequeueOutputBuffer(
     const base::TimeDelta& timeout, int* index, size_t* offset, size_t* size,
     base::TimeDelta* presentation_time, bool* end_of_stream) {
   JNIEnv* env = AttachCurrentThread();
-
   ScopedJavaLocalRef<jobject> result =
       Java_MediaCodecBridge_dequeueOutputBuffer(env, j_media_codec_.obj(),
                                                 timeout.InMicroseconds());
-
-  int j_index = Java_DequeueOutputResult_index(env, result.obj());
-  switch (j_index) {
-    case INFO_OUTPUT_BUFFERS_CHANGED:
-      return MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED;
-    case INFO_OUTPUT_FORMAT_CHANGED:
-      return MEDIA_CODEC_OUTPUT_FORMAT_CHANGED;
-    case INFO_TRY_AGAIN_LATER:
-      return MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER;
-    case INFO_MEDIA_CODEC_ERROR:
-      return MEDIA_CODEC_ERROR;
-  }
-
-  DCHECK_GE(j_index, 0);
-  *index = j_index;
+  *index = Java_DequeueOutputResult_index(env, result.obj());;
   *offset = base::checked_numeric_cast<size_t>(
        Java_DequeueOutputResult_offset(env, result.obj()));
   *size = base::checked_numeric_cast<size_t>(
        Java_DequeueOutputResult_numBytes(env, result.obj()));
   *presentation_time = base::TimeDelta::FromMicroseconds(
       Java_DequeueOutputResult_presentationTimeMicroseconds(env, result.obj()));
   int flags = Java_DequeueOutputResult_flags(env, result.obj());
   *end_of_stream = flags & kBufferFlagEndOfStream;
-  return MEDIA_CODEC_OK;
+  return static_cast<MediaCodecStatus>(
+      Java_DequeueOutputResult_status(env, result.obj()));
 }
 
 void MediaCodecBridge::ReleaseOutputBuffer(int index, bool render) {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
   Java_MediaCodecBridge_releaseOutputBuffer(
       env, j_media_codec_.obj(), index, render);
 }
 
@@ skipping 59 matching lines @@
   return true;
 }
 
 bool AudioCodecBridge::ConfigureMediaFormat(
     jobject j_format, const AudioCodec codec, const uint8* extra_data,
     size_t extra_data_size) {
   if (extra_data_size == 0)
     return true;
 
   JNIEnv* env = AttachCurrentThread();
-  switch(codec) {
+  switch (codec) {
     case kCodecVorbis:
     {
       if (extra_data[0] != 2) {
         LOG(ERROR) << "Invalid number of vorbis headers before the codec "
                    << "header: " << extra_data[0];
         return false;
       }
 
       size_t header_length[2];
       // |total_length| keeps track of the total number of bytes before the last
@@ skipping 140 matching lines @@
 VideoCodecBridge* VideoCodecBridge::Create(const VideoCodec codec) {
   const std::string mime = VideoCodecToMimeType(codec);
   return mime.empty() ? NULL : new VideoCodecBridge(mime);
 }
 
 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace media