1// Copyright (c) 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "media/base/android/media_codec_bridge.h"
6
7#include <jni.h>
8#include <string>
9
10#include "base/android/build_info.h"
11#include "base/android/jni_android.h"
12#include "base/android/jni_array.h"
13#include "base/android/jni_string.h"
14#include "base/basictypes.h"
15#include "base/lazy_instance.h"
16#include "base/logging.h"
17#include "base/numerics/safe_conversions.h"
18#include "base/strings/string_util.h"
19#include "base/strings/stringprintf.h"
20#include "jni/MediaCodecBridge_jni.h"
21#include "media/base/bit_reader.h"
22#include "media/base/decrypt_config.h"
23
24using base::android::AttachCurrentThread;
25using base::android::ConvertJavaStringToUTF8;
26using base::android::ConvertUTF8ToJavaString;
27using base::android::ScopedJavaLocalRef;
28
29namespace media {
30
31enum {
32  kBufferFlagSyncFrame = 1,    // BUFFER_FLAG_SYNC_FRAME
33  kBufferFlagEndOfStream = 4,  // BUFFER_FLAG_END_OF_STREAM
34  kConfigureFlagEncode = 1,    // CONFIGURE_FLAG_ENCODE
35};
36
37static const std::string AudioCodecToAndroidMimeType(const AudioCodec& codec) {
38  switch (codec) {
39    case kCodecMP3:
40      return "audio/mpeg";
41    case kCodecVorbis:
42      return "audio/vorbis";
43    case kCodecAAC:
44      return "audio/mp4a-latm";
45    default:
46      return std::string();
47  }
48}
49
50static const std::string VideoCodecToAndroidMimeType(const VideoCodec& codec) {
51  switch (codec) {
52    case kCodecH264:
53      return "video/avc";
54    case kCodecVP8:
55      return "video/x-vnd.on2.vp8";
56    case kCodecVP9:
57      return "video/x-vnd.on2.vp9";
58    default:
59      return std::string();
60  }
61}
62
63static const std::string CodecTypeToAndroidMimeType(const std::string& codec) {
64  // TODO(xhwang): Shall we handle more detailed strings like "mp4a.40.2"?
65  if (codec == "avc1")
66    return "video/avc";
67  if (codec == "mp4a")
68    return "audio/mp4a-latm";
69  if (codec == "vp8" || codec == "vp8.0")
70    return "video/x-vnd.on2.vp8";
71  if (codec == "vp9" || codec == "vp9.0")
72    return "video/x-vnd.on2.vp9";
73  if (codec == "vorbis")
74    return "audio/vorbis";
75  return std::string();
76}
77
78// TODO(qinmin): using a map to help all the conversions in this class.
79static const std::string AndroidMimeTypeToCodecType(const std::string& mime) {
80  if (mime == "video/mp4v-es")
81    return "mp4v";
82  if (mime == "video/avc")
83    return "avc1";
84  if (mime == "video/x-vnd.on2.vp8")
85    return "vp8";
86  if (mime == "video/x-vnd.on2.vp9")
87    return "vp9";
88  if (mime == "audio/mp4a-latm")
89    return "mp4a";
90  if (mime == "audio/mpeg")
91    return "mp3";
92  if (mime == "audio/vorbis")
93    return "vorbis";
94  return std::string();
95}
96
97static ScopedJavaLocalRef<jintArray>
98ToJavaIntArray(JNIEnv* env, scoped_ptr<jint[]> native_array, int size) {
99  ScopedJavaLocalRef<jintArray> j_array(env, env->NewIntArray(size));
100  env->SetIntArrayRegion(j_array.obj(), 0, size, native_array.get());
101  return j_array;
102}
103
104// static
105bool MediaCodecBridge::IsAvailable() {
106  // MediaCodec is only available on JB and greater.
107  if (base::android::BuildInfo::GetInstance()->sdk_int() < 16)
108    return false;
109  // Blacklist some devices on Jellybean as for MediaCodec support is buggy.
110  // http://crbug.com/365494.
111  if (base::android::BuildInfo::GetInstance()->sdk_int() == 16) {
112    std::string model(base::android::BuildInfo::GetInstance()->model());
113    return model != "GT-I9100" && model != "GT-I9300" && model != "GT-N7000";
114  }
115  return true;
116}
117
118// static
119bool MediaCodecBridge::SupportsSetParameters() {
120  // MediaCodec.setParameters() is only available starting with K.
121  return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
122}
123
124// static
125bool MediaCodecBridge::SupportsGetName() {
126  // MediaCodec.getName() is only available on JB MR2 and greater.
127  return base::android::BuildInfo::GetInstance()->sdk_int() >= 18;
128}
129
130// static
131std::vector<MediaCodecBridge::CodecsInfo> MediaCodecBridge::GetCodecsInfo() {
132  std::vector<CodecsInfo> codecs_info;
133  if (!IsAvailable())
134    return codecs_info;
135
136  JNIEnv* env = AttachCurrentThread();
137  std::string mime_type;
138  ScopedJavaLocalRef<jobjectArray> j_codec_info_array =
139      Java_MediaCodecBridge_getCodecsInfo(env);
140  jsize len = env->GetArrayLength(j_codec_info_array.obj());
141  for (jsize i = 0; i < len; ++i) {
142    ScopedJavaLocalRef<jobject> j_info(
143        env, env->GetObjectArrayElement(j_codec_info_array.obj(), i));
144    ScopedJavaLocalRef<jstring> j_codec_type =
145        Java_CodecInfo_codecType(env, j_info.obj());
146    ConvertJavaStringToUTF8(env, j_codec_type.obj(), &mime_type);
147    ScopedJavaLocalRef<jstring> j_codec_name =
148        Java_CodecInfo_codecName(env, j_info.obj());
149    CodecsInfo info;
150    info.codecs = AndroidMimeTypeToCodecType(mime_type);
151    ConvertJavaStringToUTF8(env, j_codec_name.obj(), &info.name);
152    info.direction = static_cast<MediaCodecDirection>(
153        Java_CodecInfo_direction(env, j_info.obj()));
154    codecs_info.push_back(info);
155  }
156  return codecs_info;
157}
158
159// static
160std::string MediaCodecBridge::GetDefaultCodecName(
161    const std::string& mime_type,
162    MediaCodecDirection direction) {
163  if (!IsAvailable())
164    return std::string();
165
166  JNIEnv* env = AttachCurrentThread();
167  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime_type);
168  ScopedJavaLocalRef<jstring> j_codec_name =
169      Java_MediaCodecBridge_getDefaultCodecName(env, j_mime.obj(), direction);
170  return ConvertJavaStringToUTF8(env, j_codec_name.obj());
171}
172
173// static
174bool MediaCodecBridge::CanDecode(const std::string& codec, bool is_secure) {
175  if (!IsAvailable())
176    return false;
177
178  JNIEnv* env = AttachCurrentThread();
179  std::string mime = CodecTypeToAndroidMimeType(codec);
180  if (mime.empty())
181    return false;
182  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
183  ScopedJavaLocalRef<jobject> j_media_codec_bridge =
184      Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure, false);
185  if (!j_media_codec_bridge.is_null()) {
186    Java_MediaCodecBridge_release(env, j_media_codec_bridge.obj());
187    return true;
188  }
189  return false;
190}
191
192// static
193bool MediaCodecBridge::IsKnownUnaccelerated(const std::string& mime_type,
194                                            MediaCodecDirection direction) {
195  if (!IsAvailable())
196    return true;
197
198  std::string codec_name;
199  if (SupportsGetName()) {
200    codec_name = GetDefaultCodecName(mime_type, direction);
201  } else {
202    std::string codec_type = AndroidMimeTypeToCodecType(mime_type);
203    std::vector<media::MediaCodecBridge::CodecsInfo> codecs_info =
204        MediaCodecBridge::GetCodecsInfo();
205    for (size_t i = 0; i < codecs_info.size(); ++i) {
206      if (codecs_info[i].codecs == codec_type &&
207          codecs_info[i].direction == direction) {
208        codec_name = codecs_info[i].name;
209        break;
210      }
211    }
212  }
213  DVLOG(1) << __PRETTY_FUNCTION__ << "Default codec for " << mime_type <<
214      " : " << codec_name;
215  // It would be nice if MediaCodecInfo externalized some notion of
216  // HW-acceleration but it doesn't. Android Media guidance is that the
217  // "OMX.google" prefix is always used for SW decoders, so that's what we
218  // use. "OMX.SEC.*" codec is Samsung software implementation - report it
219  // as unaccelerated as well.
220  if (codec_name.length() > 0) {
221    return (StartsWithASCII(codec_name, "OMX.google.", true) ||
222        StartsWithASCII(codec_name, "OMX.SEC.", true));
223  }
224  return true;
225}
226
227MediaCodecBridge::MediaCodecBridge(const std::string& mime,
228                                   bool is_secure,
229                                   MediaCodecDirection direction) {
230  JNIEnv* env = AttachCurrentThread();
231  CHECK(env);
232  DCHECK(!mime.empty());
233  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
234  j_media_codec_.Reset(
235      Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure, direction));
236}
237
238MediaCodecBridge::~MediaCodecBridge() {
239  JNIEnv* env = AttachCurrentThread();
240  CHECK(env);
241  if (j_media_codec_.obj())
242    Java_MediaCodecBridge_release(env, j_media_codec_.obj());
243}
244
245bool MediaCodecBridge::StartInternal() {
246  JNIEnv* env = AttachCurrentThread();
247  return Java_MediaCodecBridge_start(env, j_media_codec_.obj()) &&
248         GetOutputBuffers();
249}
250
251MediaCodecStatus MediaCodecBridge::Reset() {
252  JNIEnv* env = AttachCurrentThread();
253  return static_cast<MediaCodecStatus>(
254      Java_MediaCodecBridge_flush(env, j_media_codec_.obj()));
255}
256
257void MediaCodecBridge::Stop() {
258  JNIEnv* env = AttachCurrentThread();
259  Java_MediaCodecBridge_stop(env, j_media_codec_.obj());
260}
261
262void MediaCodecBridge::GetOutputFormat(int* width, int* height) {
263  JNIEnv* env = AttachCurrentThread();
264
265  *width = Java_MediaCodecBridge_getOutputWidth(env, j_media_codec_.obj());
266  *height = Java_MediaCodecBridge_getOutputHeight(env, j_media_codec_.obj());
267}
268
269MediaCodecStatus MediaCodecBridge::QueueInputBuffer(
270    int index,
271    const uint8* data,
272    size_t data_size,
273    const base::TimeDelta& presentation_time) {
274  DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
275  if (data_size > base::checked_cast<size_t>(kint32max))
276    return MEDIA_CODEC_ERROR;
277  if (data && !FillInputBuffer(index, data, data_size))
278    return MEDIA_CODEC_ERROR;
279  JNIEnv* env = AttachCurrentThread();
280  return static_cast<MediaCodecStatus>(
281      Java_MediaCodecBridge_queueInputBuffer(env,
282                                             j_media_codec_.obj(),
283                                             index,
284                                             0,
285                                             data_size,
286                                             presentation_time.InMicroseconds(),
287                                             0));
288}
289
290MediaCodecStatus MediaCodecBridge::QueueSecureInputBuffer(
291    int index,
292    const uint8* data,
293    size_t data_size,
294    const uint8* key_id,
295    int key_id_size,
296    const uint8* iv,
297    int iv_size,
298    const SubsampleEntry* subsamples,
299    int subsamples_size,
300    const base::TimeDelta& presentation_time) {
301  DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
302  if (data_size > base::checked_cast<size_t>(kint32max))
303    return MEDIA_CODEC_ERROR;
304  if (data && !FillInputBuffer(index, data, data_size))
305    return MEDIA_CODEC_ERROR;
306
307  JNIEnv* env = AttachCurrentThread();
308  ScopedJavaLocalRef<jbyteArray> j_key_id =
309      base::android::ToJavaByteArray(env, key_id, key_id_size);
310  ScopedJavaLocalRef<jbyteArray> j_iv =
311      base::android::ToJavaByteArray(env, iv, iv_size);
312
313  // MediaCodec.CryptoInfo documentations says passing NULL for |clear_array|
314  // to indicate that all data is encrypted. But it doesn't specify what
315  // |cypher_array| and |subsamples_size| should be in that case. Passing
316  // one subsample here just to be on the safe side.
317  int new_subsamples_size = subsamples_size == 0 ? 1 : subsamples_size;
318
319  scoped_ptr<jint[]> native_clear_array(new jint[new_subsamples_size]);
320  scoped_ptr<jint[]> native_cypher_array(new jint[new_subsamples_size]);
321
322  if (subsamples_size == 0) {
323    DCHECK(!subsamples);
324    native_clear_array[0] = 0;
325    native_cypher_array[0] = data_size;
326  } else {
327    DCHECK_GT(subsamples_size, 0);
328    DCHECK(subsamples);
329    for (int i = 0; i < subsamples_size; ++i) {
330      DCHECK(subsamples[i].clear_bytes <= std::numeric_limits<uint16>::max());
331      if (subsamples[i].cypher_bytes >
332          static_cast<uint32>(std::numeric_limits<jint>::max())) {
333        return MEDIA_CODEC_ERROR;
334      }
335
336      native_clear_array[i] = subsamples[i].clear_bytes;
337      native_cypher_array[i] = subsamples[i].cypher_bytes;
338    }
339  }
340
341  ScopedJavaLocalRef<jintArray> clear_array =
342      ToJavaIntArray(env, native_clear_array.Pass(), new_subsamples_size);
343  ScopedJavaLocalRef<jintArray> cypher_array =
344      ToJavaIntArray(env, native_cypher_array.Pass(), new_subsamples_size);
345
346  return static_cast<MediaCodecStatus>(
347      Java_MediaCodecBridge_queueSecureInputBuffer(
348          env,
349          j_media_codec_.obj(),
350          index,
351          0,
352          j_iv.obj(),
353          j_key_id.obj(),
354          clear_array.obj(),
355          cypher_array.obj(),
356          new_subsamples_size,
357          presentation_time.InMicroseconds()));
358}
359
360void MediaCodecBridge::QueueEOS(int input_buffer_index) {
361  DVLOG(3) << __PRETTY_FUNCTION__ << ": " << input_buffer_index;
362  JNIEnv* env = AttachCurrentThread();
363  Java_MediaCodecBridge_queueInputBuffer(env,
364                                         j_media_codec_.obj(),
365                                         input_buffer_index,
366                                         0,
367                                         0,
368                                         0,
369                                         kBufferFlagEndOfStream);
370}
371
372MediaCodecStatus MediaCodecBridge::DequeueInputBuffer(
373    const base::TimeDelta& timeout,
374    int* index) {
375  JNIEnv* env = AttachCurrentThread();
376  ScopedJavaLocalRef<jobject> result = Java_MediaCodecBridge_dequeueInputBuffer(
377      env, j_media_codec_.obj(), timeout.InMicroseconds());
378  *index = Java_DequeueInputResult_index(env, result.obj());
379  MediaCodecStatus status = static_cast<MediaCodecStatus>(
380      Java_DequeueInputResult_status(env, result.obj()));
381  DVLOG(3) << __PRETTY_FUNCTION__ << ": status: " << status
382           << ", index: " << *index;
383  return status;
384}
385
386MediaCodecStatus MediaCodecBridge::DequeueOutputBuffer(
387    const base::TimeDelta& timeout,
388    int* index,
389    size_t* offset,
390    size_t* size,
391    base::TimeDelta* presentation_time,
392    bool* end_of_stream,
393    bool* key_frame) {
394  JNIEnv* env = AttachCurrentThread();
395  ScopedJavaLocalRef<jobject> result =
396      Java_MediaCodecBridge_dequeueOutputBuffer(
397          env, j_media_codec_.obj(), timeout.InMicroseconds());
398  *index = Java_DequeueOutputResult_index(env, result.obj());
399  *offset = base::checked_cast<size_t>(
400      Java_DequeueOutputResult_offset(env, result.obj()));
401  *size = base::checked_cast<size_t>(
402      Java_DequeueOutputResult_numBytes(env, result.obj()));
403  if (presentation_time) {
404    *presentation_time = base::TimeDelta::FromMicroseconds(
405        Java_DequeueOutputResult_presentationTimeMicroseconds(env,
406                                                              result.obj()));
407  }
408  int flags = Java_DequeueOutputResult_flags(env, result.obj());
409  if (end_of_stream)
410    *end_of_stream = flags & kBufferFlagEndOfStream;
411  if (key_frame)
412    *key_frame = flags & kBufferFlagSyncFrame;
413  MediaCodecStatus status = static_cast<MediaCodecStatus>(
414      Java_DequeueOutputResult_status(env, result.obj()));
415  DVLOG(3) << __PRETTY_FUNCTION__ << ": status: " << status
416           << ", index: " << *index << ", offset: " << *offset
417           << ", size: " << *size << ", flags: " << flags;
418  return status;
419}
420
421void MediaCodecBridge::ReleaseOutputBuffer(int index, bool render) {
422  DVLOG(3) << __PRETTY_FUNCTION__ << ": " << index;
423  JNIEnv* env = AttachCurrentThread();
424  CHECK(env);
425
426  Java_MediaCodecBridge_releaseOutputBuffer(
427      env, j_media_codec_.obj(), index, render);
428}
429
430int MediaCodecBridge::GetInputBuffersCount() {
431  JNIEnv* env = AttachCurrentThread();
432  return Java_MediaCodecBridge_getInputBuffersCount(env, j_media_codec_.obj());
433}
434
435int MediaCodecBridge::GetOutputBuffersCount() {
436  JNIEnv* env = AttachCurrentThread();
437  return Java_MediaCodecBridge_getOutputBuffersCount(env, j_media_codec_.obj());
438}
439
440size_t MediaCodecBridge::GetOutputBuffersCapacity() {
441  JNIEnv* env = AttachCurrentThread();
442  return Java_MediaCodecBridge_getOutputBuffersCapacity(env,
443                                                        j_media_codec_.obj());
444}
445
446bool MediaCodecBridge::GetOutputBuffers() {
447  JNIEnv* env = AttachCurrentThread();
448  return Java_MediaCodecBridge_getOutputBuffers(env, j_media_codec_.obj());
449}
450
451void MediaCodecBridge::GetInputBuffer(int input_buffer_index,
452                                      uint8** data,
453                                      size_t* capacity) {
454  JNIEnv* env = AttachCurrentThread();
455  ScopedJavaLocalRef<jobject> j_buffer(Java_MediaCodecBridge_getInputBuffer(
456      env, j_media_codec_.obj(), input_buffer_index));
457  *data = static_cast<uint8*>(env->GetDirectBufferAddress(j_buffer.obj()));
458  *capacity = base::checked_cast<size_t>(
459      env->GetDirectBufferCapacity(j_buffer.obj()));
460}
461
462bool MediaCodecBridge::CopyFromOutputBuffer(int index,
463                                            size_t offset,
464                                            void* dst,
465                                            int dst_size) {
466  JNIEnv* env = AttachCurrentThread();
467  ScopedJavaLocalRef<jobject> j_buffer(
468      Java_MediaCodecBridge_getOutputBuffer(env, j_media_codec_.obj(), index));
469  void* src_data =
470      reinterpret_cast<uint8*>(env->GetDirectBufferAddress(j_buffer.obj())) +
471      offset;
472  int src_capacity = env->GetDirectBufferCapacity(j_buffer.obj()) - offset;
473  if (src_capacity < dst_size)
474    return false;
475  memcpy(dst, src_data, dst_size);
476  return true;
477}
478
479bool MediaCodecBridge::FillInputBuffer(int index,
480                                       const uint8* data,
481                                       size_t size) {
482  uint8* dst = NULL;
483  size_t capacity = 0;
484  GetInputBuffer(index, &dst, &capacity);
485  CHECK(dst);
486
487  if (size > capacity) {
488    LOG(ERROR) << "Input buffer size " << size
489               << " exceeds MediaCodec input buffer capacity: " << capacity;
490    return false;
491  }
492
493  memcpy(dst, data, size);
494  return true;
495}
496
497AudioCodecBridge::AudioCodecBridge(const std::string& mime)
498    // Audio codec doesn't care about security level and there is no need for
499    // audio encoding yet.
500    : MediaCodecBridge(mime, false, MEDIA_CODEC_DECODER) {}
501
502bool AudioCodecBridge::Start(const AudioCodec& codec,
503                             int sample_rate,
504                             int channel_count,
505                             const uint8* extra_data,
506                             size_t extra_data_size,
507                             bool play_audio,
508                             jobject media_crypto) {
509  JNIEnv* env = AttachCurrentThread();
510
511  if (!media_codec())
512    return false;
513
514  std::string codec_string = AudioCodecToAndroidMimeType(codec);
515  if (codec_string.empty())
516    return false;
517
518  ScopedJavaLocalRef<jstring> j_mime =
519      ConvertUTF8ToJavaString(env, codec_string);
520  ScopedJavaLocalRef<jobject> j_format(Java_MediaCodecBridge_createAudioFormat(
521      env, j_mime.obj(), sample_rate, channel_count));
522  DCHECK(!j_format.is_null());
523
524  if (!ConfigureMediaFormat(j_format.obj(), codec, extra_data, extra_data_size))
525    return false;
526
527  if (!Java_MediaCodecBridge_configureAudio(
528           env, media_codec(), j_format.obj(), media_crypto, 0, play_audio)) {
529    return false;
530  }
531
532  return StartInternal();
533}
534
535bool AudioCodecBridge::ConfigureMediaFormat(jobject j_format,
536                                            const AudioCodec& codec,
537                                            const uint8* extra_data,
538                                            size_t extra_data_size) {
539  if (extra_data_size == 0)
540    return true;
541
542  JNIEnv* env = AttachCurrentThread();
543  switch (codec) {
544    case kCodecVorbis: {
545      if (extra_data[0] != 2) {
546        LOG(ERROR) << "Invalid number of vorbis headers before the codec "
547                   << "header: " << extra_data[0];
548        return false;
549      }
550
551      size_t header_length[2];
552      // |total_length| keeps track of the total number of bytes before the last
553      // header.
554      size_t total_length = 1;
555      const uint8* current_pos = extra_data;
556      // Calculate the length of the first 2 headers.
557      for (int i = 0; i < 2; ++i) {
558        header_length[i] = 0;
559        while (total_length < extra_data_size) {
560          size_t size = *(++current_pos);
561          total_length += 1 + size;
562          if (total_length > 0x80000000) {
563            LOG(ERROR) << "Vorbis header size too large";
564            return false;
565          }
566          header_length[i] += size;
567          if (size < 0xFF)
568            break;
569        }
570        if (total_length >= extra_data_size) {
571          LOG(ERROR) << "Invalid vorbis header size in the extra data";
572          return false;
573        }
574      }
575      current_pos++;
576      // The first header is identification header.
577      ScopedJavaLocalRef<jbyteArray> first_header =
578          base::android::ToJavaByteArray(env, current_pos, header_length[0]);
579      Java_MediaCodecBridge_setCodecSpecificData(
580          env, j_format, 0, first_header.obj());
581      // The last header is codec header.
582      ScopedJavaLocalRef<jbyteArray> last_header =
583          base::android::ToJavaByteArray(
584              env, extra_data + total_length, extra_data_size - total_length);
585      Java_MediaCodecBridge_setCodecSpecificData(
586          env, j_format, 1, last_header.obj());
587      break;
588    }
589    case kCodecAAC: {
590      media::BitReader reader(extra_data, extra_data_size);
591
592      // The following code is copied from aac.cc
593      // TODO(qinmin): refactor the code in aac.cc to make it more reusable.
594      uint8 profile = 0;
595      uint8 frequency_index = 0;
596      uint8 channel_config = 0;
597      if (!reader.ReadBits(5, &profile) ||
598          !reader.ReadBits(4, &frequency_index)) {
599        LOG(ERROR) << "Unable to parse AAC header";
600        return false;
601      }
602      if (0xf == frequency_index && !reader.SkipBits(24)) {
603        LOG(ERROR) << "Unable to parse AAC header";
604        return false;
605      }
606      if (!reader.ReadBits(4, &channel_config)) {
607        LOG(ERROR) << "Unable to parse AAC header";
608        return false;
609      }
610
611      if (profile < 1 || profile > 4 || frequency_index == 0xf ||
612          channel_config > 7) {
613        LOG(ERROR) << "Invalid AAC header";
614        return false;
615      }
616      const size_t kCsdLength = 2;
617      uint8 csd[kCsdLength];
618      csd[0] = profile << 3 | frequency_index >> 1;
619      csd[1] = (frequency_index & 0x01) << 7 | channel_config << 3;
620      ScopedJavaLocalRef<jbyteArray> byte_array =
621          base::android::ToJavaByteArray(env, csd, kCsdLength);
622      Java_MediaCodecBridge_setCodecSpecificData(
623          env, j_format, 0, byte_array.obj());
624
625      // TODO(qinmin): pass an extra variable to this function to determine
626      // whether we need to call this.
627      Java_MediaCodecBridge_setFrameHasADTSHeader(env, j_format);
628      break;
629    }
630    default:
631      LOG(ERROR) << "Invalid header encountered for codec: "
632                 << AudioCodecToAndroidMimeType(codec);
633      return false;
634  }
635  return true;
636}
637
638int64 AudioCodecBridge::PlayOutputBuffer(int index, size_t size) {
639  DCHECK_LE(0, index);
640  int numBytes = base::checked_cast<int>(size);
641  JNIEnv* env = AttachCurrentThread();
642  ScopedJavaLocalRef<jobject> buf =
643      Java_MediaCodecBridge_getOutputBuffer(env, media_codec(), index);
644  uint8* buffer = static_cast<uint8*>(env->GetDirectBufferAddress(buf.obj()));
645
646  ScopedJavaLocalRef<jbyteArray> byte_array =
647      base::android::ToJavaByteArray(env, buffer, numBytes);
648  return Java_MediaCodecBridge_playOutputBuffer(
649      env, media_codec(), byte_array.obj());
650}
651
652void AudioCodecBridge::SetVolume(double volume) {
653  JNIEnv* env = AttachCurrentThread();
654  Java_MediaCodecBridge_setVolume(env, media_codec(), volume);
655}
656
657// static
658AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec& codec) {
659  if (!MediaCodecBridge::IsAvailable())
660    return NULL;
661
662  const std::string mime = AudioCodecToAndroidMimeType(codec);
663  return mime.empty() ? NULL : new AudioCodecBridge(mime);
664}
665
666// static
667bool AudioCodecBridge::IsKnownUnaccelerated(const AudioCodec& codec) {
668  return MediaCodecBridge::IsKnownUnaccelerated(
669      AudioCodecToAndroidMimeType(codec), MEDIA_CODEC_DECODER);
670}
671
672// static
673bool VideoCodecBridge::IsKnownUnaccelerated(const VideoCodec& codec,
674                                            MediaCodecDirection direction) {
675  return MediaCodecBridge::IsKnownUnaccelerated(
676      VideoCodecToAndroidMimeType(codec), direction);
677}
678
679// static
680VideoCodecBridge* VideoCodecBridge::CreateDecoder(const VideoCodec& codec,
681                                                  bool is_secure,
682                                                  const gfx::Size& size,
683                                                  jobject surface,
684                                                  jobject media_crypto) {
685  if (!MediaCodecBridge::IsAvailable())
686    return NULL;
687
688  const std::string mime = VideoCodecToAndroidMimeType(codec);
689  if (mime.empty())
690    return NULL;
691
692  scoped_ptr<VideoCodecBridge> bridge(
693      new VideoCodecBridge(mime, is_secure, MEDIA_CODEC_DECODER));
694  if (!bridge->media_codec())
695    return NULL;
696
697  JNIEnv* env = AttachCurrentThread();
698  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
699  ScopedJavaLocalRef<jobject> j_format(
700      Java_MediaCodecBridge_createVideoDecoderFormat(
701          env, j_mime.obj(), size.width(), size.height()));
702  DCHECK(!j_format.is_null());
703  if (!Java_MediaCodecBridge_configureVideo(env,
704                                            bridge->media_codec(),
705                                            j_format.obj(),
706                                            surface,
707                                            media_crypto,
708                                            0)) {
709    return NULL;
710  }
711
712  return bridge->StartInternal() ? bridge.release() : NULL;
713}
714
715// static
716VideoCodecBridge* VideoCodecBridge::CreateEncoder(const VideoCodec& codec,
717                                                  const gfx::Size& size,
718                                                  int bit_rate,
719                                                  int frame_rate,
720                                                  int i_frame_interval,
721                                                  int color_format) {
722  if (!MediaCodecBridge::IsAvailable())
723    return NULL;
724
725  const std::string mime = VideoCodecToAndroidMimeType(codec);
726  if (mime.empty())
727    return NULL;
728
729  scoped_ptr<VideoCodecBridge> bridge(
730      new VideoCodecBridge(mime, false, MEDIA_CODEC_ENCODER));
731  if (!bridge->media_codec())
732    return NULL;
733
734  JNIEnv* env = AttachCurrentThread();
735  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
736  ScopedJavaLocalRef<jobject> j_format(
737      Java_MediaCodecBridge_createVideoEncoderFormat(env,
738                                                     j_mime.obj(),
739                                                     size.width(),
740                                                     size.height(),
741                                                     bit_rate,
742                                                     frame_rate,
743                                                     i_frame_interval,
744                                                     color_format));
745  DCHECK(!j_format.is_null());
746  if (!Java_MediaCodecBridge_configureVideo(env,
747                                            bridge->media_codec(),
748                                            j_format.obj(),
749                                            NULL,
750                                            NULL,
751                                            kConfigureFlagEncode)) {
752    return NULL;
753  }
754
755  return bridge->StartInternal() ? bridge.release() : NULL;
756}
757
758VideoCodecBridge::VideoCodecBridge(const std::string& mime,
759                                   bool is_secure,
760                                   MediaCodecDirection direction)
761    : MediaCodecBridge(mime, is_secure, direction),
762      adaptive_playback_supported_for_testing_(-1) {}
763
764void VideoCodecBridge::SetVideoBitrate(int bps) {
765  JNIEnv* env = AttachCurrentThread();
766  Java_MediaCodecBridge_setVideoBitrate(env, media_codec(), bps);
767}
768
769void VideoCodecBridge::RequestKeyFrameSoon() {
770  JNIEnv* env = AttachCurrentThread();
771  Java_MediaCodecBridge_requestKeyFrameSoon(env, media_codec());
772}
773
774bool VideoCodecBridge::IsAdaptivePlaybackSupported(int width, int height) {
775  if (adaptive_playback_supported_for_testing_ == 0)
776    return false;
777  else if (adaptive_playback_supported_for_testing_ > 0)
778    return true;
779  JNIEnv* env = AttachCurrentThread();
780  return Java_MediaCodecBridge_isAdaptivePlaybackSupported(
781      env, media_codec(), width, height);
782}
783
784bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
785  return RegisterNativesImpl(env);
786}
787
788}  // namespace media
789