Catch CodecException in MediaCodecBridge and return MEDIA_CODEC_ERROR

media/base/android/ndk_media_codec_bridge.cc

 // Copyright 2015 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/ndk_media_codec_bridge.h"
 
 #include <media/NdkMediaError.h>
 #include <media/NdkMediaFormat.h>
 
 #include <limits>
@@ skipping 49 matching lines @@
 }
 
 bool NdkMediaCodecBridge::Start() {
   return AMEDIA_OK == AMediaCodec_start(media_codec_.get());
 }
 
 void NdkMediaCodecBridge::Stop() {
   AMediaCodec_stop(media_codec_.get());
 }
 
-void NdkMediaCodecBridge::GetOutputFormat(int* width, int* height) {
+MediaCodecStatus NdkMediaCodecBridge::GetOutputSize(gfx::Size* size) {
   AMediaFormat* format = AMediaCodec_getOutputFormat(media_codec_.get());
   int left, right, bottom, top;
   bool has_left = AMediaFormat_getInt32(format, kMediaFormatKeyCropLeft, &left);
   bool has_right =
       AMediaFormat_getInt32(format, kMediaFormatKeyCropRight, &right);
   bool has_bottom =
       AMediaFormat_getInt32(format, kMediaFormatKeyCropBottom, &bottom);
   bool has_top = AMediaFormat_getInt32(format, kMediaFormatKeyCropTop, &top);
+  int width, height;
   if (has_left && has_right && has_bottom && has_top) {
     // Use crop size as it is more accurate. right and bottom are inclusive.
-    *width = right - left + 1;
-    *height = top - bottom + 1;
+    width = right - left + 1;
+    height = top - bottom + 1;
   } else {
-    AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, width);
-    AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, height);
+    AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, &width);
+    AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, &height);
   }
+  size->SetSize(width, height);
+  return MEDIA_CODEC_OK;
 }
 
-int NdkMediaCodecBridge::GetOutputSamplingRate() {
+MediaCodecStatus NdkMediaCodecBridge::GetOutputSamplingRate(
+    int* sampling_rate) {
   AMediaFormat* format = AMediaCodec_getOutputFormat(media_codec_.get());
-  int sample_rate = 0;
-  AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, &sample_rate);
-  DCHECK(sample_rate != 0);
-  return sample_rate;
+  *sampling_rate = 0;
+  AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, sampling_rate);
+  DCHECK_NE(*sampling_rate, 0);
+  return MEDIA_CODEC_OK;
 }
 
 MediaCodecStatus NdkMediaCodecBridge::QueueInputBuffer(
     int index,
     const uint8_t* data,
     size_t data_size,
     const base::TimeDelta& presentation_time) {
   if (data_size >
       base::checked_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return MEDIA_CODEC_ERROR;
@@ skipping 101 matching lines @@
   else if (*index == AMEDIACODEC_INFO_TRY_AGAIN_LATER)
     return MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER;
   else
     return MEDIA_CODEC_ERROR;
 }
 
 void NdkMediaCodecBridge::ReleaseOutputBuffer(int index, bool render) {
   AMediaCodec_releaseOutputBuffer(media_codec_.get(), index, render);
 }
 
-void NdkMediaCodecBridge::GetInputBuffer(int input_buffer_index,
-                                         uint8_t** data,
-                                         size_t* capacity) {
+MediaCodecStatus NdkMediaCodecBridge::GetInputBuffer(int input_buffer_index,
+                                                     uint8_t** data,
+                                                     size_t* capacity) {
   *data = AMediaCodec_getInputBuffer(media_codec_.get(), input_buffer_index,
                                      capacity);
+  return MEDIA_CODEC_OK;
 }
 
-void NdkMediaCodecBridge::CopyFromOutputBuffer(int index,
-                                               size_t offset,
-                                               void* dst,
-                                               size_t num) {
+MediaCodecStatus NdkMediaCodecBridge::CopyFromOutputBuffer(int index,
+                                                           size_t offset,
+                                                           void* dst,
+                                                           size_t num) {
   size_t capacity;
   const uint8_t* src_data =
       AMediaCodec_getOutputBuffer(media_codec_.get(), index, &capacity);
   CHECK_GE(capacity, offset + num);
   memcpy(dst, src_data + offset, num);
+  return MEDIA_CODEC_OK;
 }
 
 }  // namespace media