OLD | NEW |
---|---|
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/base/android/media_codec_bridge.h" | 5 #include "media/base/android/media_codec_bridge.h" |
6 | 6 |
7 #include <jni.h> | 7 #include <jni.h> |
8 #include <string> | 8 #include <string> |
9 | 9 |
10 #include "base/android/build_info.h" | 10 #include "base/android/build_info.h" |
(...skipping 10 matching lines...) Expand all Loading... | |
21 #include "media/base/bit_reader.h" | 21 #include "media/base/bit_reader.h" |
22 #include "media/base/decrypt_config.h" | 22 #include "media/base/decrypt_config.h" |
23 | 23 |
24 using base::android::AttachCurrentThread; | 24 using base::android::AttachCurrentThread; |
25 using base::android::ConvertJavaStringToUTF8; | 25 using base::android::ConvertJavaStringToUTF8; |
26 using base::android::ConvertUTF8ToJavaString; | 26 using base::android::ConvertUTF8ToJavaString; |
27 using base::android::ScopedJavaLocalRef; | 27 using base::android::ScopedJavaLocalRef; |
28 | 28 |
29 namespace media { | 29 namespace media { |
30 | 30 |
31 enum { kBufferFlagEndOfStream = 4 }; | 31 enum { |
32 kBufferFlagSyncFrame = 1, // BUFFER_FLAG_SYNC_FRAME | |
33 kBufferFlagEndOfStream = 4, // BUFFER_FLAG_END_OF_STREAM | |
34 kConfigureFlagEncode = 1, // CONFIGURE_FLAG_ENCODE | |
35 }; | |
32 | 36 |
33 static const std::string AudioCodecToAndroidMimeType(const AudioCodec& codec) { | 37 static const std::string AudioCodecToAndroidMimeType(const AudioCodec& codec) { |
34 switch (codec) { | 38 switch (codec) { |
35 case kCodecMP3: | 39 case kCodecMP3: |
36 return "audio/mpeg"; | 40 return "audio/mpeg"; |
37 case kCodecVorbis: | 41 case kCodecVorbis: |
38 return "audio/vorbis"; | 42 return "audio/vorbis"; |
39 case kCodecAAC: | 43 case kCodecAAC: |
40 return "audio/mp4a-latm"; | 44 return "audio/mp4a-latm"; |
41 default: | 45 default: |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
97 return j_array; | 101 return j_array; |
98 } | 102 } |
99 | 103 |
100 // static | 104 // static |
101 bool MediaCodecBridge::IsAvailable() { | 105 bool MediaCodecBridge::IsAvailable() { |
102 // MediaCodec is only available on JB and greater. | 106 // MediaCodec is only available on JB and greater. |
103 return base::android::BuildInfo::GetInstance()->sdk_int() >= 16; | 107 return base::android::BuildInfo::GetInstance()->sdk_int() >= 16; |
104 } | 108 } |
105 | 109 |
106 // static | 110 // static |
107 void MediaCodecBridge::GetCodecsInfo( | 111 bool MediaCodecBridge::SupportsSetParameters() { |
108 std::vector<CodecsInfo>* codecs_info) { | 112 // MediaCodec.setParameters() is only available starting with K, but bugs mean |
113 // we need to wait for the next release. | |
114 return base::android::BuildInfo::GetInstance()->sdk_int() > 19; | |
115 } | |
116 | |
117 // static | |
118 std::vector<MediaCodecBridge::CodecsInfo> MediaCodecBridge::GetCodecsInfo() { | |
119 std::vector<CodecsInfo> codecs_info; | |
109 JNIEnv* env = AttachCurrentThread(); | 120 JNIEnv* env = AttachCurrentThread(); |
110 if (!IsAvailable()) | 121 if (!IsAvailable()) return codecs_info; |
111 return; | |
112 | 122 |
113 std::string mime_type; | 123 std::string mime_type; |
114 std::string codec_name; | 124 std::string codec_name; |
115 ScopedJavaLocalRef<jobjectArray> j_codec_info_array = | 125 ScopedJavaLocalRef<jobjectArray> j_codec_info_array = |
116 Java_MediaCodecBridge_getCodecsInfo(env); | 126 Java_MediaCodecBridge_getCodecsInfo(env); |
117 jsize len = env->GetArrayLength(j_codec_info_array.obj()); | 127 jsize len = env->GetArrayLength(j_codec_info_array.obj()); |
118 for (jsize i = 0; i < len; ++i) { | 128 for (jsize i = 0; i < len; ++i) { |
119 ScopedJavaLocalRef<jobject> j_info( | 129 ScopedJavaLocalRef<jobject> j_info( |
120 env, env->GetObjectArrayElement(j_codec_info_array.obj(), i)); | 130 env, env->GetObjectArrayElement(j_codec_info_array.obj(), i)); |
121 ScopedJavaLocalRef<jstring> j_codec_type = | 131 ScopedJavaLocalRef<jstring> j_codec_type = |
122 Java_CodecInfo_codecType(env, j_info.obj()); | 132 Java_CodecInfo_codecType(env, j_info.obj()); |
123 ConvertJavaStringToUTF8(env, j_codec_type.obj(), &mime_type); | 133 ConvertJavaStringToUTF8(env, j_codec_type.obj(), &mime_type); |
124 ScopedJavaLocalRef<jstring> j_codec_name = | 134 ScopedJavaLocalRef<jstring> j_codec_name = |
125 Java_CodecInfo_codecName(env, j_info.obj()); | 135 Java_CodecInfo_codecName(env, j_info.obj()); |
126 CodecsInfo info; | 136 CodecsInfo info; |
127 info.codecs = AndroidMimeTypeToCodecType(mime_type); | 137 info.codecs = AndroidMimeTypeToCodecType(mime_type); |
128 ConvertJavaStringToUTF8(env, j_codec_name.obj(), &info.name); | 138 ConvertJavaStringToUTF8(env, j_codec_name.obj(), &info.name); |
129 codecs_info->push_back(info); | 139 info.is_encoder = Java_CodecInfo_isEncoder(env, j_info.obj()); |
140 codecs_info.push_back(info); | |
130 } | 141 } |
142 return codecs_info; | |
131 } | 143 } |
132 | 144 |
133 // static | 145 // static |
134 bool MediaCodecBridge::CanDecode(const std::string& codec, bool is_secure) { | 146 bool MediaCodecBridge::CanDecode(const std::string& codec, bool is_secure) { |
135 JNIEnv* env = AttachCurrentThread(); | 147 JNIEnv* env = AttachCurrentThread(); |
136 std::string mime = CodecTypeToAndroidMimeType(codec); | 148 std::string mime = CodecTypeToAndroidMimeType(codec); |
137 if (mime.empty()) | 149 if (mime.empty()) |
138 return false; | 150 return false; |
139 ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime); | 151 ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime); |
140 ScopedJavaLocalRef<jobject> j_media_codec_bridge = | 152 ScopedJavaLocalRef<jobject> j_media_codec_bridge = |
141 Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure); | 153 Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure, false); |
142 if (!j_media_codec_bridge.is_null()) { | 154 if (!j_media_codec_bridge.is_null()) { |
143 Java_MediaCodecBridge_release(env, j_media_codec_bridge.obj()); | 155 Java_MediaCodecBridge_release(env, j_media_codec_bridge.obj()); |
144 return true; | 156 return true; |
145 } | 157 } |
146 return false; | 158 return false; |
147 } | 159 } |
148 | 160 |
149 // static | 161 // static |
150 bool MediaCodecBridge::IsKnownUnaccelerated(const std::string& mime_type) { | 162 bool MediaCodecBridge::IsKnownUnaccelerated(const std::string& mime_type, |
163 bool is_encoder) { | |
151 std::string codec_type = AndroidMimeTypeToCodecType(mime_type); | 164 std::string codec_type = AndroidMimeTypeToCodecType(mime_type); |
152 std::vector<media::MediaCodecBridge::CodecsInfo> codecs_info; | 165 std::vector<media::MediaCodecBridge::CodecsInfo> codecs_info = |
153 media::MediaCodecBridge::GetCodecsInfo(&codecs_info); | 166 MediaCodecBridge::GetCodecsInfo(); |
154 for (size_t i = 0; i < codecs_info.size(); ++i) { | 167 for (size_t i = 0; i < codecs_info.size(); ++i) { |
155 if (codecs_info[i].codecs == codec_type) { | 168 if (codecs_info[i].codecs == codec_type && |
169 codecs_info[i].is_encoder == is_encoder) { | |
156 // It would be nice if MediaCodecInfo externalized some notion of | 170 // It would be nice if MediaCodecInfo externalized some notion of |
157 // HW-acceleration but it doesn't. Android Media guidance is that the | 171 // HW-acceleration but it doesn't. Android Media guidance is that the |
158 // prefix below is always used for SW decoders, so that's what we use. | 172 // prefix below is always used for SW decoders, so that's what we use. |
159 return StartsWithASCII(codecs_info[i].name, "OMX.google.", true); | 173 return StartsWithASCII(codecs_info[i].name, "OMX.google.", true); |
160 } | 174 } |
161 } | 175 } |
162 return true; | 176 return true; |
163 } | 177 } |
164 | 178 |
165 MediaCodecBridge::MediaCodecBridge(const std::string& mime, bool is_secure) { | 179 MediaCodecBridge::MediaCodecBridge(const std::string& mime, bool is_secure, |
180 bool is_encoder) { | |
166 JNIEnv* env = AttachCurrentThread(); | 181 JNIEnv* env = AttachCurrentThread(); |
167 CHECK(env); | 182 CHECK(env); |
168 DCHECK(!mime.empty()); | 183 DCHECK(!mime.empty()); |
169 ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime); | 184 ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime); |
170 j_media_codec_.Reset( | 185 j_media_codec_.Reset( |
171 Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure)); | 186 Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure, is_encoder)); |
172 } | 187 } |
173 | 188 |
174 MediaCodecBridge::~MediaCodecBridge() { | 189 MediaCodecBridge::~MediaCodecBridge() { |
175 JNIEnv* env = AttachCurrentThread(); | 190 JNIEnv* env = AttachCurrentThread(); |
176 CHECK(env); | 191 CHECK(env); |
177 if (j_media_codec_.obj()) | 192 if (j_media_codec_.obj()) |
178 Java_MediaCodecBridge_release(env, j_media_codec_.obj()); | 193 Java_MediaCodecBridge_release(env, j_media_codec_.obj()); |
179 } | 194 } |
180 | 195 |
181 bool MediaCodecBridge::StartInternal() { | 196 bool MediaCodecBridge::StartInternal() { |
(...skipping 14 matching lines...) Expand all Loading... | |
196 } | 211 } |
197 | 212 |
198 void MediaCodecBridge::GetOutputFormat(int* width, int* height) { | 213 void MediaCodecBridge::GetOutputFormat(int* width, int* height) { |
199 JNIEnv* env = AttachCurrentThread(); | 214 JNIEnv* env = AttachCurrentThread(); |
200 | 215 |
201 *width = Java_MediaCodecBridge_getOutputWidth(env, j_media_codec_.obj()); | 216 *width = Java_MediaCodecBridge_getOutputWidth(env, j_media_codec_.obj()); |
202 *height = Java_MediaCodecBridge_getOutputHeight(env, j_media_codec_.obj()); | 217 *height = Java_MediaCodecBridge_getOutputHeight(env, j_media_codec_.obj()); |
203 } | 218 } |
204 | 219 |
205 MediaCodecStatus MediaCodecBridge::QueueInputBuffer( | 220 MediaCodecStatus MediaCodecBridge::QueueInputBuffer( |
206 int index, const uint8* data, int data_size, | 221 int index, const uint8* data, int orig_data_size, |
xhwang
2013/11/19 00:11:25
Also update the header file.
Ami GONE FROM CHROMIUM
2013/11/21 22:59:07
Done.
| |
207 const base::TimeDelta& presentation_time) { | 222 const base::TimeDelta& presentation_time) { |
208 if (!FillInputBuffer(index, data, data_size)) | 223 DVLOG(3) << "MediaCodecBridge::QueueInputBuffer: " << index << ": " |
224 << orig_data_size; | |
225 size_t data_size = base::checked_numeric_cast<size_t>(orig_data_size); | |
226 if (data && !FillInputBuffer(index, data, data_size)) | |
209 return MEDIA_CODEC_ERROR; | 227 return MEDIA_CODEC_ERROR; |
210 JNIEnv* env = AttachCurrentThread(); | 228 JNIEnv* env = AttachCurrentThread(); |
211 return static_cast<MediaCodecStatus>(Java_MediaCodecBridge_queueInputBuffer( | 229 return static_cast<MediaCodecStatus>(Java_MediaCodecBridge_queueInputBuffer( |
212 env, j_media_codec_.obj(), | 230 env, j_media_codec_.obj(), |
213 index, 0, data_size, presentation_time.InMicroseconds(), 0)); | 231 index, 0, data_size, presentation_time.InMicroseconds(), 0)); |
214 } | 232 } |
215 | 233 |
216 MediaCodecStatus MediaCodecBridge::QueueSecureInputBuffer( | 234 MediaCodecStatus MediaCodecBridge::QueueSecureInputBuffer( |
217 int index, const uint8* data, int data_size, const uint8* key_id, | 235 int index, const uint8* data, int orig_data_size, const uint8* key_id, |
xhwang
2013/11/19 00:11:25
ditto
Ami GONE FROM CHROMIUM
2013/11/21 22:59:07
Done.
| |
218 int key_id_size, const uint8* iv, int iv_size, | 236 int key_id_size, const uint8* iv, int iv_size, |
219 const SubsampleEntry* subsamples, int subsamples_size, | 237 const SubsampleEntry* subsamples, int subsamples_size, |
220 const base::TimeDelta& presentation_time) { | 238 const base::TimeDelta& presentation_time) { |
221 if (!FillInputBuffer(index, data, data_size)) | 239 DVLOG(3) << "MediaCodecBridge::QueueSecureInputBuffer: " << index << ": " |
240 << orig_data_size; | |
241 size_t data_size = base::checked_numeric_cast<size_t>(orig_data_size); | |
242 if (data && !FillInputBuffer(index, data, data_size)) | |
222 return MEDIA_CODEC_ERROR; | 243 return MEDIA_CODEC_ERROR; |
223 | 244 |
224 JNIEnv* env = AttachCurrentThread(); | 245 JNIEnv* env = AttachCurrentThread(); |
225 ScopedJavaLocalRef<jbyteArray> j_key_id = | 246 ScopedJavaLocalRef<jbyteArray> j_key_id = |
226 base::android::ToJavaByteArray(env, key_id, key_id_size); | 247 base::android::ToJavaByteArray(env, key_id, key_id_size); |
227 ScopedJavaLocalRef<jbyteArray> j_iv = | 248 ScopedJavaLocalRef<jbyteArray> j_iv = |
228 base::android::ToJavaByteArray(env, iv, iv_size); | 249 base::android::ToJavaByteArray(env, iv, iv_size); |
229 | 250 |
230 // MediaCodec.CryptoInfo documentations says passing NULL for |clear_array| | 251 // MediaCodec.CryptoInfo documentations says passing NULL for |clear_array| |
231 // to indicate that all data is encrypted. But it doesn't specify what | 252 // to indicate that all data is encrypted. But it doesn't specify what |
(...skipping 23 matching lines...) Expand all Loading... | |
255 ToJavaIntArray(env, native_cypher_array.Pass(), new_subsamples_size); | 276 ToJavaIntArray(env, native_cypher_array.Pass(), new_subsamples_size); |
256 | 277 |
257 return static_cast<MediaCodecStatus>( | 278 return static_cast<MediaCodecStatus>( |
258 Java_MediaCodecBridge_queueSecureInputBuffer( | 279 Java_MediaCodecBridge_queueSecureInputBuffer( |
259 env, j_media_codec_.obj(), index, 0, j_iv.obj(), j_key_id.obj(), | 280 env, j_media_codec_.obj(), index, 0, j_iv.obj(), j_key_id.obj(), |
260 clear_array.obj(), cypher_array.obj(), new_subsamples_size, | 281 clear_array.obj(), cypher_array.obj(), new_subsamples_size, |
261 presentation_time.InMicroseconds())); | 282 presentation_time.InMicroseconds())); |
262 } | 283 } |
263 | 284 |
264 void MediaCodecBridge::QueueEOS(int input_buffer_index) { | 285 void MediaCodecBridge::QueueEOS(int input_buffer_index) { |
286 DVLOG(3) << "MediaCodecBridge::QueueEOS: " << input_buffer_index; | |
265 JNIEnv* env = AttachCurrentThread(); | 287 JNIEnv* env = AttachCurrentThread(); |
266 Java_MediaCodecBridge_queueInputBuffer( | 288 Java_MediaCodecBridge_queueInputBuffer( |
267 env, j_media_codec_.obj(), | 289 env, j_media_codec_.obj(), |
268 input_buffer_index, 0, 0, 0, kBufferFlagEndOfStream); | 290 input_buffer_index, 0, 0, 0, kBufferFlagEndOfStream); |
269 } | 291 } |
270 | 292 |
271 MediaCodecStatus MediaCodecBridge::DequeueInputBuffer( | 293 MediaCodecStatus MediaCodecBridge::DequeueInputBuffer( |
272 const base::TimeDelta& timeout, int* index) { | 294 const base::TimeDelta& timeout, int* index) { |
273 JNIEnv* env = AttachCurrentThread(); | 295 JNIEnv* env = AttachCurrentThread(); |
274 ScopedJavaLocalRef<jobject> result = Java_MediaCodecBridge_dequeueInputBuffer( | 296 ScopedJavaLocalRef<jobject> result = Java_MediaCodecBridge_dequeueInputBuffer( |
275 env, j_media_codec_.obj(), timeout.InMicroseconds()); | 297 env, j_media_codec_.obj(), timeout.InMicroseconds()); |
276 *index = Java_DequeueInputResult_index(env, result.obj()); | 298 *index = Java_DequeueInputResult_index(env, result.obj()); |
277 return static_cast<MediaCodecStatus>( | 299 MediaCodecStatus status = static_cast<MediaCodecStatus>( |
278 Java_DequeueInputResult_status(env, result.obj())); | 300 Java_DequeueInputResult_status(env, result.obj())); |
301 DVLOG(3) << "MediaCodecBridge::DequeueInputBuffer: status: " << status | |
302 << ", index: " << *index; | |
303 return status; | |
279 } | 304 } |
280 | 305 |
281 MediaCodecStatus MediaCodecBridge::DequeueOutputBuffer( | 306 MediaCodecStatus MediaCodecBridge::DequeueOutputBuffer( |
282 const base::TimeDelta& timeout, int* index, size_t* offset, size_t* size, | 307 const base::TimeDelta& timeout, int* index, size_t* offset, size_t* size, |
283 base::TimeDelta* presentation_time, bool* end_of_stream) { | 308 base::TimeDelta* presentation_time, bool* end_of_stream, bool* key_frame) { |
284 JNIEnv* env = AttachCurrentThread(); | 309 JNIEnv* env = AttachCurrentThread(); |
285 ScopedJavaLocalRef<jobject> result = | 310 ScopedJavaLocalRef<jobject> result = |
286 Java_MediaCodecBridge_dequeueOutputBuffer(env, j_media_codec_.obj(), | 311 Java_MediaCodecBridge_dequeueOutputBuffer(env, j_media_codec_.obj(), |
287 timeout.InMicroseconds()); | 312 timeout.InMicroseconds()); |
288 *index = Java_DequeueOutputResult_index(env, result.obj());; | 313 *index = Java_DequeueOutputResult_index(env, result.obj());; |
289 *offset = base::checked_numeric_cast<size_t>( | 314 *offset = base::checked_numeric_cast<size_t>( |
290 Java_DequeueOutputResult_offset(env, result.obj())); | 315 Java_DequeueOutputResult_offset(env, result.obj())); |
291 *size = base::checked_numeric_cast<size_t>( | 316 *size = base::checked_numeric_cast<size_t>( |
292 Java_DequeueOutputResult_numBytes(env, result.obj())); | 317 Java_DequeueOutputResult_numBytes(env, result.obj())); |
293 *presentation_time = base::TimeDelta::FromMicroseconds( | 318 if (presentation_time) { |
294 Java_DequeueOutputResult_presentationTimeMicroseconds(env, result.obj())); | 319 *presentation_time = base::TimeDelta::FromMicroseconds( |
320 Java_DequeueOutputResult_presentationTimeMicroseconds(env, | |
321 result.obj())); | |
322 } | |
295 int flags = Java_DequeueOutputResult_flags(env, result.obj()); | 323 int flags = Java_DequeueOutputResult_flags(env, result.obj()); |
296 *end_of_stream = flags & kBufferFlagEndOfStream; | 324 if (end_of_stream) *end_of_stream = flags & kBufferFlagEndOfStream; |
297 return static_cast<MediaCodecStatus>( | 325 if (key_frame) *key_frame = flags & kBufferFlagSyncFrame; |
326 MediaCodecStatus status = static_cast<MediaCodecStatus>( | |
298 Java_DequeueOutputResult_status(env, result.obj())); | 327 Java_DequeueOutputResult_status(env, result.obj())); |
328 DVLOG(3) << "MediaCodecBridge::DequeueOutputBuffer: status: " << status | |
329 << ", index: " << *index << ", offset: " << *offset | |
330 << ", size: " << *size << ", flags: " << flags; | |
331 return status; | |
299 } | 332 } |
300 | 333 |
301 void MediaCodecBridge::ReleaseOutputBuffer(int index, bool render) { | 334 void MediaCodecBridge::ReleaseOutputBuffer(int index, bool render) { |
335 DVLOG(3) << "MediaCodecBridge::ReleaseOutputBuffer: " << index; | |
302 JNIEnv* env = AttachCurrentThread(); | 336 JNIEnv* env = AttachCurrentThread(); |
303 CHECK(env); | 337 CHECK(env); |
304 | 338 |
305 Java_MediaCodecBridge_releaseOutputBuffer( | 339 Java_MediaCodecBridge_releaseOutputBuffer( |
306 env, j_media_codec_.obj(), index, render); | 340 env, j_media_codec_.obj(), index, render); |
307 } | 341 } |
308 | 342 |
343 int MediaCodecBridge::GetInputBuffersCount() { | |
344 JNIEnv* env = AttachCurrentThread(); | |
345 return Java_MediaCodecBridge_getInputBuffersCount(env, j_media_codec_.obj()); | |
346 } | |
347 | |
348 int MediaCodecBridge::GetOutputBuffersCount() { | |
349 JNIEnv* env = AttachCurrentThread(); | |
350 return Java_MediaCodecBridge_getOutputBuffersCount(env, j_media_codec_.obj()); | |
351 } | |
352 | |
353 size_t MediaCodecBridge::GetOutputBuffersCapacity() { | |
354 JNIEnv* env = AttachCurrentThread(); | |
355 return Java_MediaCodecBridge_getOutputBuffersCapacity(env, | |
356 j_media_codec_.obj()); | |
357 } | |
358 | |
309 bool MediaCodecBridge::GetOutputBuffers() { | 359 bool MediaCodecBridge::GetOutputBuffers() { |
310 JNIEnv* env = AttachCurrentThread(); | 360 JNIEnv* env = AttachCurrentThread(); |
311 return Java_MediaCodecBridge_getOutputBuffers(env, j_media_codec_.obj()); | 361 return Java_MediaCodecBridge_getOutputBuffers(env, j_media_codec_.obj()); |
312 } | 362 } |
313 | 363 |
314 bool MediaCodecBridge::FillInputBuffer(int index, const uint8* data, int size) { | 364 void MediaCodecBridge::GetInputBuffer(int input_buffer_index, uint8** data, |
365 size_t* capacity) { | |
315 JNIEnv* env = AttachCurrentThread(); | 366 JNIEnv* env = AttachCurrentThread(); |
367 ScopedJavaLocalRef<jobject> j_buffer(Java_MediaCodecBridge_getInputBuffer( | |
368 env, j_media_codec_.obj(), input_buffer_index)); | |
369 *data = static_cast<uint8*>(env->GetDirectBufferAddress(j_buffer.obj())); | |
370 *capacity = base::checked_numeric_cast<size_t>( | |
371 env->GetDirectBufferCapacity(j_buffer.obj())); | |
372 } | |
316 | 373 |
374 bool MediaCodecBridge::CopyFromOutputBuffer(int index, size_t offset, void* dst, | |
375 int dst_size) { | |
376 JNIEnv* env = AttachCurrentThread(); | |
317 ScopedJavaLocalRef<jobject> j_buffer( | 377 ScopedJavaLocalRef<jobject> j_buffer( |
318 Java_MediaCodecBridge_getInputBuffer(env, j_media_codec_.obj(), index)); | 378 Java_MediaCodecBridge_getOutputBuffer(env, j_media_codec_.obj(), index)); |
319 jlong capacity = env->GetDirectBufferCapacity(j_buffer.obj()); | 379 void* src_data = |
380 reinterpret_cast<uint8*>(env->GetDirectBufferAddress(j_buffer.obj())) + | |
381 offset; | |
382 int src_capacity = env->GetDirectBufferCapacity(j_buffer.obj()) - offset; | |
383 if (src_capacity < dst_size) return false; | |
384 memcpy(dst, src_data, dst_size); | |
385 return true; | |
386 } | |
387 | |
388 bool MediaCodecBridge::FillInputBuffer(int index, const uint8* data, | |
389 size_t size) { | |
390 uint8* dst = NULL; | |
391 size_t capacity = 0; | |
392 GetInputBuffer(index, &dst, &capacity); | |
393 CHECK(dst); | |
394 | |
320 if (size > capacity) { | 395 if (size > capacity) { |
321 LOG(ERROR) << "Input buffer size " << size | 396 LOG(ERROR) << "Input buffer size " << size |
322 << " exceeds MediaCodec input buffer capacity: " << capacity; | 397 << " exceeds MediaCodec input buffer capacity: " << capacity; |
323 return false; | 398 return false; |
324 } | 399 } |
325 | 400 |
326 uint8* direct_buffer = | 401 memcpy(dst, data, size); |
327 static_cast<uint8*>(env->GetDirectBufferAddress(j_buffer.obj())); | |
328 memcpy(direct_buffer, data, size); | |
329 return true; | 402 return true; |
330 } | 403 } |
331 | 404 |
332 AudioCodecBridge::AudioCodecBridge(const std::string& mime) | 405 AudioCodecBridge::AudioCodecBridge(const std::string& mime) |
333 // Audio codec doesn't care about security level. | 406 // Audio codec doesn't care about security level and there is no need for |
334 : MediaCodecBridge(mime, false) { | 407 // audio encoding yet. |
335 } | 408 : MediaCodecBridge(mime, false, false) {} |
336 | 409 |
337 bool AudioCodecBridge::Start( | 410 bool AudioCodecBridge::Start( |
338 const AudioCodec& codec, int sample_rate, int channel_count, | 411 const AudioCodec& codec, int sample_rate, int channel_count, |
339 const uint8* extra_data, size_t extra_data_size, bool play_audio, | 412 const uint8* extra_data, size_t extra_data_size, bool play_audio, |
340 jobject media_crypto) { | 413 jobject media_crypto) { |
341 JNIEnv* env = AttachCurrentThread(); | 414 JNIEnv* env = AttachCurrentThread(); |
342 | 415 |
343 if (!media_codec()) | 416 if (!media_codec()) |
344 return false; | 417 return false; |
345 | 418 |
(...skipping 135 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
481 base::android::ToJavaByteArray(env, buffer, numBytes); | 554 base::android::ToJavaByteArray(env, buffer, numBytes); |
482 Java_MediaCodecBridge_playOutputBuffer( | 555 Java_MediaCodecBridge_playOutputBuffer( |
483 env, media_codec(), byte_array.obj()); | 556 env, media_codec(), byte_array.obj()); |
484 } | 557 } |
485 | 558 |
486 void AudioCodecBridge::SetVolume(double volume) { | 559 void AudioCodecBridge::SetVolume(double volume) { |
487 JNIEnv* env = AttachCurrentThread(); | 560 JNIEnv* env = AttachCurrentThread(); |
488 Java_MediaCodecBridge_setVolume(env, media_codec(), volume); | 561 Java_MediaCodecBridge_setVolume(env, media_codec(), volume); |
489 } | 562 } |
490 | 563 |
491 VideoCodecBridge::VideoCodecBridge(const std::string& mime, bool is_secure) | |
492 : MediaCodecBridge(mime, is_secure) { | |
493 } | |
494 | |
495 bool VideoCodecBridge::Start( | |
496 const VideoCodec& codec, const gfx::Size& size, jobject surface, | |
497 jobject media_crypto) { | |
498 JNIEnv* env = AttachCurrentThread(); | |
499 | |
500 if (!media_codec()) | |
501 return false; | |
502 | |
503 std::string codec_string = VideoCodecToAndroidMimeType(codec); | |
504 if (codec_string.empty()) | |
505 return false; | |
506 | |
507 ScopedJavaLocalRef<jstring> j_mime = | |
508 ConvertUTF8ToJavaString(env, codec_string); | |
509 ScopedJavaLocalRef<jobject> j_format( | |
510 Java_MediaCodecBridge_createVideoFormat( | |
511 env, j_mime.obj(), size.width(), size.height())); | |
512 DCHECK(!j_format.is_null()); | |
513 if (!Java_MediaCodecBridge_configureVideo( | |
514 env, media_codec(), j_format.obj(), surface, media_crypto, 0)) { | |
515 return false; | |
516 } | |
517 | |
518 return StartInternal(); | |
519 } | |
520 | |
521 AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec& codec) { | 564 AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec& codec) { |
522 const std::string mime = AudioCodecToAndroidMimeType(codec); | 565 const std::string mime = AudioCodecToAndroidMimeType(codec); |
523 return mime.empty() ? NULL : new AudioCodecBridge(mime); | 566 return mime.empty() ? NULL : new AudioCodecBridge(mime); |
524 } | 567 } |
525 | 568 |
526 // static | 569 // static |
527 bool AudioCodecBridge::IsKnownUnaccelerated(const AudioCodec& codec) { | 570 bool AudioCodecBridge::IsKnownUnaccelerated(const AudioCodec& codec) { |
528 return MediaCodecBridge::IsKnownUnaccelerated( | 571 return MediaCodecBridge::IsKnownUnaccelerated( |
529 AudioCodecToAndroidMimeType(codec)); | 572 AudioCodecToAndroidMimeType(codec), false); |
530 } | |
531 | |
532 VideoCodecBridge* VideoCodecBridge::Create(const VideoCodec& codec, | |
533 bool is_secure) { | |
534 const std::string mime = VideoCodecToAndroidMimeType(codec); | |
535 return mime.empty() ? NULL : new VideoCodecBridge(mime, is_secure); | |
536 } | 573 } |
537 | 574 |
538 // static | 575 // static |
539 bool VideoCodecBridge::IsKnownUnaccelerated(const VideoCodec& codec) { | 576 bool VideoCodecBridge::IsKnownUnaccelerated(const VideoCodec& codec, |
577 bool is_encoder) { | |
540 return MediaCodecBridge::IsKnownUnaccelerated( | 578 return MediaCodecBridge::IsKnownUnaccelerated( |
541 VideoCodecToAndroidMimeType(codec)); | 579 VideoCodecToAndroidMimeType(codec), is_encoder); |
580 } | |
581 | |
582 VideoCodecBridge* VideoCodecBridge::CreateDecoder(const VideoCodec& codec, | |
583 bool is_secure, | |
584 const gfx::Size& size, | |
585 jobject surface, | |
586 jobject media_crypto) { | |
587 JNIEnv* env = AttachCurrentThread(); | |
588 const std::string mime = VideoCodecToAndroidMimeType(codec); | |
589 if (mime.empty()) return NULL; | |
590 | |
591 scoped_ptr<VideoCodecBridge> bridge( | |
592 new VideoCodecBridge(mime, is_secure, false)); | |
593 | |
594 ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime); | |
595 ScopedJavaLocalRef<jobject> j_format( | |
596 Java_MediaCodecBridge_createVideoDecoderFormat( | |
597 env, j_mime.obj(), size.width(), size.height())); | |
598 DCHECK(!j_format.is_null()); | |
599 if (!Java_MediaCodecBridge_configureVideo(env, bridge->media_codec(), | |
600 j_format.obj(), surface, | |
601 media_crypto, 0)) { | |
602 return NULL; | |
603 } | |
604 | |
605 return bridge->StartInternal() ? bridge.release() : NULL; | |
606 } | |
607 | |
608 VideoCodecBridge* VideoCodecBridge::CreateEncoder(const VideoCodec& codec, | |
609 const gfx::Size& size, | |
610 int bit_rate, int frame_rate, | |
611 int i_frame_interval, | |
612 int color_format) { | |
613 JNIEnv* env = AttachCurrentThread(); | |
614 const std::string mime = VideoCodecToAndroidMimeType(codec); | |
615 if (mime.empty()) return NULL; | |
616 | |
617 scoped_ptr<VideoCodecBridge> bridge(new VideoCodecBridge(mime, false, true)); | |
618 | |
619 ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime); | |
620 ScopedJavaLocalRef<jobject> j_format( | |
621 Java_MediaCodecBridge_createVideoEncoderFormat( | |
622 env, j_mime.obj(), size.width(), size.height(), bit_rate, frame_rate, | |
623 i_frame_interval, color_format)); | |
624 DCHECK(!j_format.is_null()); | |
625 if (!Java_MediaCodecBridge_configureVideo(env, bridge->media_codec(), | |
626 j_format.obj(), NULL, NULL, | |
627 kConfigureFlagEncode)) { | |
628 return NULL; | |
629 } | |
630 | |
631 return bridge->StartInternal() ? bridge.release() : NULL; | |
632 } | |
633 | |
634 VideoCodecBridge::VideoCodecBridge(const std::string& mime, bool is_secure, | |
635 bool is_encoder) | |
636 : MediaCodecBridge(mime, is_secure, is_encoder) {} | |
637 | |
638 void VideoCodecBridge::SetVideoBitrate(int bps) { | |
639 JNIEnv* env = AttachCurrentThread(); | |
640 Java_MediaCodecBridge_setVideoBitrate(env, media_codec(), bps); | |
641 } | |
642 | |
643 void VideoCodecBridge::RequestKeyFrameSoon() { | |
644 JNIEnv* env = AttachCurrentThread(); | |
645 Java_MediaCodecBridge_requestKeyFrameSoon(env, media_codec()); | |
542 } | 646 } |
543 | 647 |
544 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) { | 648 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) { |
545 return RegisterNativesImpl(env); | 649 return RegisterNativesImpl(env); |
546 } | 650 } |
547 | 651 |
548 } // namespace media | 652 } // namespace media |
OLD | NEW |