media: Remove the unused NdkMediaCodecBridge

media/base/android/media_codec_bridge_impl.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/sdk_media_codec_bridge.h"
+#include "media/base/android/media_codec_bridge_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
@@ skipping 13 matching lines @@
 
 #define RETURN_ON_ERROR(condition)                             \
   do {                                                         \
     if (!(condition)) {                                        \
       LOG(ERROR) << "Unable to parse AAC header: " #condition; \
       return false;                                            \
     }                                                          \
   } while (0)
 
 namespace media {
+namespace {
 
 enum {
   kBufferFlagSyncFrame = 1,    // BUFFER_FLAG_SYNC_FRAME
   kBufferFlagEndOfStream = 4,  // BUFFER_FLAG_END_OF_STREAM
   kConfigureFlagEncode = 1,    // CONFIGURE_FLAG_ENCODE
 };
 
-static ScopedJavaLocalRef<jintArray>
-ToJavaIntArray(JNIEnv* env, std::unique_ptr<jint[]> native_array, int size) {
-  ScopedJavaLocalRef<jintArray> j_array(env, env->NewIntArray(size));
-  env->SetIntArrayRegion(j_array.obj(), 0, size, native_array.get());
-  return j_array;
-}
-
-static const std::string AudioCodecToAndroidMimeType(const AudioCodec& codec) {
+const std::string AudioCodecToAndroidMimeType(const AudioCodec& codec) {
   switch (codec) {
     case kCodecMP3:
       return "audio/mpeg";
     case kCodecVorbis:
       return "audio/vorbis";
     case kCodecOpus:
       return "audio/opus";
     case kCodecAAC:
       return "audio/mp4a-latm";
     case kCodecAC3:
       return "audio/ac3";
     case kCodecEAC3:
       return "audio/eac3";
     default:
       return std::string();
   }
 }
 
-static const std::string VideoCodecToAndroidMimeType(const VideoCodec& codec) {
+const std::string VideoCodecToAndroidMimeType(const VideoCodec& codec) {
   switch (codec) {
     case kCodecH264:
       return "video/avc";
     case kCodecHEVC:
       return "video/hevc";
     case kCodecVP8:
       return "video/x-vnd.on2.vp8";
     case kCodecVP9:
       return "video/x-vnd.on2.vp9";
     default:
       return std::string();
   }
 }
 
-SdkMediaCodecBridge::SdkMediaCodecBridge(const std::string& mime,
-                                         bool is_secure,
-                                         MediaCodecDirection direction,
-                                         bool require_software_codec) {
+static ScopedJavaLocalRef<jintArray>
+ToJavaIntArray(JNIEnv* env, std::unique_ptr<jint[]> native_array, int size) {
+  ScopedJavaLocalRef<jintArray> j_array(env, env->NewIntArray(size));
+  env->SetIntArrayRegion(j_array.obj(), 0, size, native_array.get());
+  return j_array;
+}
+
+}  // namespace
+
+MediaCodecBridgeImpl::MediaCodecBridgeImpl(const std::string& mime,
+                                           bool is_secure,
+                                           MediaCodecDirection direction,
+                                           bool require_software_codec) {
   JNIEnv* env = AttachCurrentThread();
   DCHECK(!mime.empty());
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   j_media_codec_.Reset(Java_MediaCodecBridge_create(
       env, j_mime, is_secure, direction, require_software_codec));
 }
 
-SdkMediaCodecBridge::~SdkMediaCodecBridge() {
+MediaCodecBridgeImpl::~MediaCodecBridgeImpl() {
   JNIEnv* env = AttachCurrentThread();
   if (j_media_codec_.obj())
     Java_MediaCodecBridge_release(env, j_media_codec_);
 }
 
-bool SdkMediaCodecBridge::Start() {
+bool MediaCodecBridgeImpl::Start() {
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_start(env, j_media_codec_);
 }
 
-void SdkMediaCodecBridge::Stop() {
+void MediaCodecBridgeImpl::Stop() {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_stop(env, j_media_codec_);
 }
 
-MediaCodecStatus SdkMediaCodecBridge::Flush() {
+MediaCodecStatus MediaCodecBridgeImpl::Flush() {
   JNIEnv* env = AttachCurrentThread();
   return static_cast<MediaCodecStatus>(
       Java_MediaCodecBridge_flush(env, j_media_codec_));
 }
 
-MediaCodecStatus SdkMediaCodecBridge::GetOutputSize(gfx::Size* size) {
+MediaCodecStatus MediaCodecBridgeImpl::GetOutputSize(gfx::Size* size) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result =
       Java_MediaCodecBridge_getOutputFormat(env, j_media_codec_);
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
       Java_GetOutputFormatResult_status(env, result));
   if (status == MEDIA_CODEC_OK) {
     size->SetSize(Java_GetOutputFormatResult_width(env, result),
                   Java_GetOutputFormatResult_height(env, result));
   }
   return status;
 }
 
-MediaCodecStatus SdkMediaCodecBridge::GetOutputSamplingRate(
+MediaCodecStatus MediaCodecBridgeImpl::GetOutputSamplingRate(
     int* sampling_rate) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result =
       Java_MediaCodecBridge_getOutputFormat(env, j_media_codec_);
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
       Java_GetOutputFormatResult_status(env, result));
   if (status == MEDIA_CODEC_OK)
     *sampling_rate = Java_GetOutputFormatResult_sampleRate(env, result);
   return status;
 }
 
-MediaCodecStatus SdkMediaCodecBridge::GetOutputChannelCount(
+MediaCodecStatus MediaCodecBridgeImpl::GetOutputChannelCount(
     int* channel_count) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result =
       Java_MediaCodecBridge_getOutputFormat(env, j_media_codec_);
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
       Java_GetOutputFormatResult_status(env, result));
   if (status == MEDIA_CODEC_OK)
     *channel_count = Java_GetOutputFormatResult_channelCount(env, result);
   return status;
 }
 
-MediaCodecStatus SdkMediaCodecBridge::QueueInputBuffer(
+MediaCodecStatus MediaCodecBridgeImpl::QueueInputBuffer(
     int index,
     const uint8_t* data,
     size_t data_size,
     base::TimeDelta presentation_time) {
-  DVLOG(3) << __func__ << index << ": " << data_size;
+  DVLOG(3) << __func__ << " " << index << ": " << data_size;
   if (data_size >
       base::checked_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return MEDIA_CODEC_ERROR;
   }
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
   JNIEnv* env = AttachCurrentThread();
   return static_cast<MediaCodecStatus>(Java_MediaCodecBridge_queueInputBuffer(
       env, j_media_codec_, index, 0, data_size,
       presentation_time.InMicroseconds(), 0));
 }
 
-// TODO(timav): Combine this and above methods together keeping only the first
-// interface after we switch to Spitzer pipeline.
-MediaCodecStatus SdkMediaCodecBridge::QueueSecureInputBuffer(
+MediaCodecStatus MediaCodecBridgeImpl::QueueSecureInputBuffer(
     int index,
     const uint8_t* data,
     size_t data_size,
-    const std::vector<char>& key_id,
-    const std::vector<char>& iv,
-    const SubsampleEntry* subsamples,
-    int subsamples_size,
+    const std::string& key_id,
+    const std::string& iv,
+    const std::vector<SubsampleEntry>& subsamples,
     const EncryptionScheme& encryption_scheme,
     base::TimeDelta presentation_time) {
-  DVLOG(3) << __func__ << index << ": " << data_size;
+  DVLOG(3) << __func__ << " " << index << ": " << data_size;
   if (data_size >
       base::checked_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return MEDIA_CODEC_ERROR;
   }
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_key_id = base::android::ToJavaByteArray(
       env, reinterpret_cast<const uint8_t*>(key_id.data()), key_id.size());
   ScopedJavaLocalRef<jbyteArray> j_iv = base::android::ToJavaByteArray(
       env, reinterpret_cast<const uint8_t*>(iv.data()), iv.size());
 
-  // MediaCodec.CryptoInfo documentations says passing NULL for |clear_array|
+  // The MediaCodec.CryptoInfo documentation says to pass NULL for |clear_array|
   // to indicate that all data is encrypted. But it doesn't specify what
-  // |cypher_array| and |subsamples_size| should be in that case. Passing
+  // |cypher_array| and |subsamples_size| should be in that case. We pass
   // one subsample here just to be on the safe side.
-  int new_subsamples_size = subsamples_size == 0 ? 1 : subsamples_size;
+  int num_subsamples = std::max(static_cast<size_t>(1), subsamples.size());
 
-  std::unique_ptr<jint[]> native_clear_array(new jint[new_subsamples_size]);
-  std::unique_ptr<jint[]> native_cypher_array(new jint[new_subsamples_size]);
+  std::unique_ptr<jint[]> native_clear_array(new jint[num_subsamples]);
+  std::unique_ptr<jint[]> native_cypher_array(new jint[num_subsamples]);
 
-  if (subsamples_size == 0) {
-    DCHECK(!subsamples);
+  if (subsamples.empty()) {
     native_clear_array[0] = 0;
     native_cypher_array[0] = data_size;
   } else {
-    DCHECK_GT(subsamples_size, 0);
-    DCHECK(subsamples);
-    for (int i = 0; i < subsamples_size; ++i) {
+    for (size_t i = 0; i < subsamples.size(); ++i) {
       DCHECK(subsamples[i].clear_bytes <= std::numeric_limits<uint16_t>::max());
       if (subsamples[i].cypher_bytes >
           static_cast<uint32_t>(std::numeric_limits<jint>::max())) {
         return MEDIA_CODEC_ERROR;
       }
 
       native_clear_array[i] = subsamples[i].clear_bytes;
       native_cypher_array[i] = subsamples[i].cypher_bytes;
     }
   }
 
   ScopedJavaLocalRef<jintArray> clear_array =
-      ToJavaIntArray(env, std::move(native_clear_array), new_subsamples_size);
+      ToJavaIntArray(env, std::move(native_clear_array), num_subsamples);
   ScopedJavaLocalRef<jintArray> cypher_array =
-      ToJavaIntArray(env, std::move(native_cypher_array), new_subsamples_size);
+      ToJavaIntArray(env, std::move(native_cypher_array), num_subsamples);
 
   return static_cast<MediaCodecStatus>(
       Java_MediaCodecBridge_queueSecureInputBuffer(
           env, j_media_codec_.obj(), index, 0, j_iv.obj(), j_key_id.obj(),
-          clear_array, cypher_array, new_subsamples_size,
+          clear_array, cypher_array, num_subsamples,
           static_cast<int>(encryption_scheme.mode()),
           static_cast<int>(encryption_scheme.pattern().encrypt_blocks()),
           static_cast<int>(encryption_scheme.pattern().skip_blocks()),
           presentation_time.InMicroseconds()));
 }
 
-void SdkMediaCodecBridge::QueueEOS(int input_buffer_index) {
+void MediaCodecBridgeImpl::QueueEOS(int input_buffer_index) {
   DVLOG(3) << __func__ << ": " << input_buffer_index;
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_queueInputBuffer(
       env, j_media_codec_, input_buffer_index, 0, 0, 0, kBufferFlagEndOfStream);
 }
 
-MediaCodecStatus SdkMediaCodecBridge::DequeueInputBuffer(
+MediaCodecStatus MediaCodecBridgeImpl::DequeueInputBuffer(
     base::TimeDelta timeout,
     int* index) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result = Java_MediaCodecBridge_dequeueInputBuffer(
       env, j_media_codec_, timeout.InMicroseconds());
   *index = Java_DequeueInputResult_index(env, result);
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
       Java_DequeueInputResult_status(env, result));
   DVLOG(3) << __func__ << ": status: " << status << ", index: " << *index;
   return status;
 }
 
-MediaCodecStatus SdkMediaCodecBridge::DequeueOutputBuffer(
+MediaCodecStatus MediaCodecBridgeImpl::DequeueOutputBuffer(
     base::TimeDelta timeout,
     int* index,
     size_t* offset,
     size_t* size,
     base::TimeDelta* presentation_time,
     bool* end_of_stream,
     bool* key_frame) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result =
       Java_MediaCodecBridge_dequeueOutputBuffer(env, j_media_codec_,
@@ skipping 13 matching lines @@
   if (key_frame)
     *key_frame = flags & kBufferFlagSyncFrame;
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
       Java_DequeueOutputResult_status(env, result));
   DVLOG(3) << __func__ << ": status: " << status << ", index: " << *index
            << ", offset: " << *offset << ", size: " << *size
            << ", flags: " << flags;
   return status;
 }
 
-void SdkMediaCodecBridge::ReleaseOutputBuffer(int index, bool render) {
+void MediaCodecBridgeImpl::ReleaseOutputBuffer(int index, bool render) {
   DVLOG(3) << __func__ << ": " << index;
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_releaseOutputBuffer(env, j_media_codec_, index, render);
 }
 
-MediaCodecStatus SdkMediaCodecBridge::GetInputBuffer(int input_buffer_index,
-                                                     uint8_t** data,
-                                                     size_t* capacity) {
+MediaCodecStatus MediaCodecBridgeImpl::GetInputBuffer(int input_buffer_index,
+                                                      uint8_t** data,
+                                                      size_t* capacity) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(Java_MediaCodecBridge_getInputBuffer(
       env, j_media_codec_, input_buffer_index));
   if (j_buffer.is_null())
     return MEDIA_CODEC_ERROR;
 
   *data = static_cast<uint8_t*>(env->GetDirectBufferAddress(j_buffer.obj()));
   *capacity =
       base::checked_cast<size_t>(env->GetDirectBufferCapacity(j_buffer.obj()));
   return MEDIA_CODEC_OK;
 }
 
-MediaCodecStatus SdkMediaCodecBridge::GetOutputBufferAddress(
+MediaCodecStatus MediaCodecBridgeImpl::CopyFromOutputBuffer(int index,
+                                                            size_t offset,
+                                                            void* dst,
+                                                            size_t num) {
+  const uint8_t* src_data = nullptr;
+  size_t src_capacity = 0;
+  MediaCodecStatus status =
+      GetOutputBufferAddress(index, offset, &src_data, &src_capacity);
+  if (status == MEDIA_CODEC_OK) {
+    CHECK_GE(src_capacity, num);
+    memcpy(dst, src_data, num);
+  }
+  return status;
+}
+
+MediaCodecStatus MediaCodecBridgeImpl::GetOutputBufferAddress(
     int index,
     size_t offset,
     const uint8_t** addr,
     size_t* capacity) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(
       Java_MediaCodecBridge_getOutputBuffer(env, j_media_codec_, index));
   if (j_buffer.is_null())
     return MEDIA_CODEC_ERROR;
   const size_t total_capacity = env->GetDirectBufferCapacity(j_buffer.obj());
   CHECK_GE(total_capacity, offset);
   *addr = reinterpret_cast<const uint8_t*>(
               env->GetDirectBufferAddress(j_buffer.obj())) +
           offset;
   *capacity = total_capacity - offset;
   return MEDIA_CODEC_OK;
 }
 
-std::string SdkMediaCodecBridge::GetName() {
+std::string MediaCodecBridgeImpl::GetName() {
   if (base::android::BuildInfo::GetInstance()->sdk_int() < 18)
     return "";
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_name =
       Java_MediaCodecBridge_getName(env, j_media_codec_);
   return ConvertJavaStringToUTF8(env, j_name);
 }
 
+bool MediaCodecBridgeImpl::FillInputBuffer(int index,
+                                           const uint8_t* data,
+                                           size_t size) {
+  uint8_t* dst = nullptr;
+  size_t capacity = 0;
+  if (GetInputBuffer(index, &dst, &capacity) != MEDIA_CODEC_OK) {
+    LOG(ERROR) << "GetInputBuffer failed";
+    return false;
+  }
+  CHECK(dst);
+
+  if (size > capacity) {
+    LOG(ERROR) << "Input buffer size " << size
+               << " exceeds MediaCodec input buffer capacity: " << capacity;
+    return false;
+  }
+
+  memcpy(dst, data, size);
+  return true;
+}
+
 // static
 AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec& codec) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
 
   const std::string mime = AudioCodecToAndroidMimeType(codec);
   if (mime.empty())
     return nullptr;
 
   std::unique_ptr<AudioCodecBridge> bridge(new AudioCodecBridge(mime));
   if (!bridge->media_codec())
     return nullptr;
 
   return bridge.release();
 }
 
 // static
 bool AudioCodecBridge::IsKnownUnaccelerated(const AudioCodec& codec) {
   return MediaCodecUtil::IsKnownUnaccelerated(
       AudioCodecToAndroidMimeType(codec), MEDIA_CODEC_DECODER);
 }
 
 AudioCodecBridge::AudioCodecBridge(const std::string& mime)
     // Audio codec doesn't care about security level and there is no need for
     // audio encoding yet.
-    : SdkMediaCodecBridge(mime, false, MEDIA_CODEC_DECODER, false) {}
+    : MediaCodecBridgeImpl(mime, false, MEDIA_CODEC_DECODER, false) {}
 
 bool AudioCodecBridge::ConfigureAndStart(const AudioDecoderConfig& config,
                                          jobject media_crypto) {
   const int channel_count =
       ChannelLayoutToChannelCount(config.channel_layout());
   const int64_t codec_delay_ns = base::Time::kNanosecondsPerSecond *
                                  config.codec_delay() /
                                  config.samples_per_second();
   const int64_t seek_preroll_ns =
       1000LL * config.seek_preroll().InMicroseconds();
@@ skipping 267 matching lines @@
     return nullptr;
   }
 
   return bridge->Start() ? bridge.release() : nullptr;
 }
 
 VideoCodecBridge::VideoCodecBridge(const std::string& mime,
                                    bool is_secure,
                                    MediaCodecDirection direction,
                                    bool require_software_codec)
-    : SdkMediaCodecBridge(mime, is_secure, direction, require_software_codec),
+    : MediaCodecBridgeImpl(mime, is_secure, direction, require_software_codec),
       adaptive_playback_supported_for_testing_(-1) {}
 
 bool VideoCodecBridge::SetSurface(jobject surface) {
   DCHECK_GE(base::android::BuildInfo::GetInstance()->sdk_int(), 23);
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_setSurface(env, media_codec(), surface);
 }
 
 void VideoCodecBridge::SetVideoBitrate(int bps, int frame_rate) {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_setVideoBitrate(env, media_codec(), bps, frame_rate);
 }
 
 void VideoCodecBridge::RequestKeyFrameSoon() {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_requestKeyFrameSoon(env, media_codec());
 }
 
 bool VideoCodecBridge::IsAdaptivePlaybackSupported(int width, int height) {
   if (adaptive_playback_supported_for_testing_ == 0)
     return false;
   else if (adaptive_playback_supported_for_testing_ > 0)
     return true;
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_isAdaptivePlaybackSupported(env, media_codec(),
                                                            width, height);
 }
 
 }  // namespace media