Revert of Use actual audio channel count in Spitzer audio decoder

media/base/android/sdk_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/sdk_media_codec_bridge.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
@@ skipping 296 matching lines @@
       env, j_media_codec_.obj(), 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(
-    int index,
-    size_t offset,
-    const uint8_t** addr,
-    size_t* capacity) {
+MediaCodecStatus SdkMediaCodecBridge::CopyFromOutputBuffer(int index,
+                                                           size_t offset,
+                                                           void* dst,
+                                                           size_t num) {
+  void* 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 SdkMediaCodecBridge::GetOutputBufferAddress(int index,
+                                                             size_t offset,
+                                                             void** addr,
+                                                             size_t* capacity) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(
       Java_MediaCodecBridge_getOutputBuffer(env, j_media_codec_.obj(), 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;
+  *addr =
+      reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(j_buffer.obj())) +
+      offset;
   *capacity = total_capacity - offset;
   return MEDIA_CODEC_OK;
 }
 
 // static
 bool SdkMediaCodecBridge::RegisterSdkMediaCodecBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 // static
@@ skipping 216 matching lines @@
 }
 
 MediaCodecStatus AudioCodecBridge::PlayOutputBuffer(int index,
                                                     size_t size,
                                                     size_t offset,
                                                     bool postpone,
                                                     int64_t* playback_pos) {
   DCHECK_LE(0, index);
   int numBytes = base::checked_cast<int>(size);
 
-  const uint8_t* buffer = nullptr;
+  void* buffer = nullptr;
   size_t capacity = 0;
   MediaCodecStatus status =
       GetOutputBufferAddress(index, offset, &buffer, &capacity);
   if (status == MEDIA_CODEC_ERROR)
     return status;
 
   numBytes = std::min(base::checked_cast<int>(capacity), numBytes);
   CHECK_GE(numBytes, 0);
 
   JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jbyteArray> byte_array =
-      base::android::ToJavaByteArray(env, buffer, numBytes);
+  ScopedJavaLocalRef<jbyteArray> byte_array = base::android::ToJavaByteArray(
+      env, static_cast<uint8_t*>(buffer), numBytes);
   *playback_pos = Java_MediaCodecBridge_playOutputBuffer(
       env, media_codec(), byte_array.obj(), postpone);
   return status;
 }
 
 void AudioCodecBridge::SetVolume(double volume) {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_setVolume(env, media_codec(), volume);
 }
 
@@ skipping 94 matching lines @@
   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