blob: 272bc303ddb55b79e99e2586dfe035ce1b77eebb [file] [log] [blame]
Wei Jia53692fa2017-12-11 10:33:46 -08001/*
2 * Copyright 2017, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "NdkWrapper"
19
Wei Jia28288fb2017-12-15 13:45:29 -080020#include <media/NdkWrapper.h>
Wei Jia53692fa2017-12-11 10:33:46 -080021
Wei Jia28288fb2017-12-15 13:45:29 -080022#include <android/native_window.h>
Wei Jia53692fa2017-12-11 10:33:46 -080023#include <log/log.h>
24#include <media/NdkMediaCodec.h>
25#include <media/NdkMediaCrypto.h>
26#include <media/NdkMediaDrm.h>
27#include <media/NdkMediaFormat.h>
Robert Shihff282cb2017-12-18 14:10:56 -080028#include <media/NdkMediaExtractor.h>
Wei Jia53692fa2017-12-11 10:33:46 -080029#include <media/stagefright/MetaData.h>
30#include <media/stagefright/foundation/ABuffer.h>
31#include <media/stagefright/foundation/AMessage.h>
32#include <utils/Errors.h>
33
Robert Shih3fd320d2018-04-26 16:21:29 -070034// TODO: remove forward declaration when AMediaExtractor_disconnect is offcially added to NDK
35
36#ifdef __cplusplus
37extern "C" {
38#endif
39
40media_status_t AMediaExtractor_disconnect(AMediaExtractor *);
41
42#ifdef __cplusplus
43} // extern "C"
44#endif
45
Wei Jia53692fa2017-12-11 10:33:46 -080046namespace android {
47
48static const size_t kAESBlockSize = 16; // AES_BLOCK_SIZE
49
50static const char *AMediaFormatKeyGroupInt32[] = {
51 AMEDIAFORMAT_KEY_AAC_DRC_ATTENUATION_FACTOR,
52 AMEDIAFORMAT_KEY_AAC_DRC_BOOST_FACTOR,
53 AMEDIAFORMAT_KEY_AAC_DRC_HEAVY_COMPRESSION,
54 AMEDIAFORMAT_KEY_AAC_DRC_TARGET_REFERENCE_LEVEL,
55 AMEDIAFORMAT_KEY_AAC_ENCODED_TARGET_LEVEL,
56 AMEDIAFORMAT_KEY_AAC_MAX_OUTPUT_CHANNEL_COUNT,
57 AMEDIAFORMAT_KEY_AAC_PROFILE,
58 AMEDIAFORMAT_KEY_AAC_SBR_MODE,
59 AMEDIAFORMAT_KEY_AUDIO_SESSION_ID,
60 AMEDIAFORMAT_KEY_BITRATE_MODE,
61 AMEDIAFORMAT_KEY_BIT_RATE,
62 AMEDIAFORMAT_KEY_CAPTURE_RATE,
63 AMEDIAFORMAT_KEY_CHANNEL_COUNT,
64 AMEDIAFORMAT_KEY_CHANNEL_MASK,
65 AMEDIAFORMAT_KEY_COLOR_FORMAT,
66 AMEDIAFORMAT_KEY_COLOR_RANGE,
67 AMEDIAFORMAT_KEY_COLOR_STANDARD,
68 AMEDIAFORMAT_KEY_COLOR_TRANSFER,
69 AMEDIAFORMAT_KEY_COMPLEXITY,
70 AMEDIAFORMAT_KEY_FLAC_COMPRESSION_LEVEL,
Chong Zhang67d5b912018-03-14 18:17:40 -070071 AMEDIAFORMAT_KEY_GRID_COLUMNS,
Wei Jia53692fa2017-12-11 10:33:46 -080072 AMEDIAFORMAT_KEY_GRID_ROWS,
Wei Jia53692fa2017-12-11 10:33:46 -080073 AMEDIAFORMAT_KEY_HEIGHT,
74 AMEDIAFORMAT_KEY_INTRA_REFRESH_PERIOD,
75 AMEDIAFORMAT_KEY_IS_ADTS,
76 AMEDIAFORMAT_KEY_IS_AUTOSELECT,
77 AMEDIAFORMAT_KEY_IS_DEFAULT,
78 AMEDIAFORMAT_KEY_IS_FORCED_SUBTITLE,
79 AMEDIAFORMAT_KEY_LATENCY,
80 AMEDIAFORMAT_KEY_LEVEL,
81 AMEDIAFORMAT_KEY_MAX_HEIGHT,
82 AMEDIAFORMAT_KEY_MAX_INPUT_SIZE,
83 AMEDIAFORMAT_KEY_MAX_WIDTH,
84 AMEDIAFORMAT_KEY_PCM_ENCODING,
85 AMEDIAFORMAT_KEY_PRIORITY,
86 AMEDIAFORMAT_KEY_PROFILE,
87 AMEDIAFORMAT_KEY_PUSH_BLANK_BUFFERS_ON_STOP,
88 AMEDIAFORMAT_KEY_ROTATION,
89 AMEDIAFORMAT_KEY_SAMPLE_RATE,
90 AMEDIAFORMAT_KEY_SLICE_HEIGHT,
91 AMEDIAFORMAT_KEY_STRIDE,
92 AMEDIAFORMAT_KEY_TRACK_ID,
93 AMEDIAFORMAT_KEY_WIDTH,
Robert Shih0cd95062018-01-21 17:41:16 -080094 AMEDIAFORMAT_KEY_DISPLAY_HEIGHT,
95 AMEDIAFORMAT_KEY_DISPLAY_WIDTH,
96 AMEDIAFORMAT_KEY_TEMPORAL_LAYER_ID,
Chong Zhang67d5b912018-03-14 18:17:40 -070097 AMEDIAFORMAT_KEY_TILE_HEIGHT,
98 AMEDIAFORMAT_KEY_TILE_WIDTH,
Robert Shih0cd95062018-01-21 17:41:16 -080099 AMEDIAFORMAT_KEY_TRACK_INDEX,
Wei Jia53692fa2017-12-11 10:33:46 -0800100};
101
102static const char *AMediaFormatKeyGroupInt64[] = {
103 AMEDIAFORMAT_KEY_DURATION,
104 AMEDIAFORMAT_KEY_REPEAT_PREVIOUS_FRAME_AFTER,
Robert Shih0cd95062018-01-21 17:41:16 -0800105 AMEDIAFORMAT_KEY_TIME_US,
Wei Jia53692fa2017-12-11 10:33:46 -0800106};
107
108static const char *AMediaFormatKeyGroupString[] = {
109 AMEDIAFORMAT_KEY_LANGUAGE,
110 AMEDIAFORMAT_KEY_MIME,
111 AMEDIAFORMAT_KEY_TEMPORAL_LAYERING,
112};
113
114static const char *AMediaFormatKeyGroupBuffer[] = {
115 AMEDIAFORMAT_KEY_HDR_STATIC_INFO,
Robert Shih0cd95062018-01-21 17:41:16 -0800116 AMEDIAFORMAT_KEY_SEI,
117 AMEDIAFORMAT_KEY_MPEG_USER_DATA,
118};
119
120static const char *AMediaFormatKeyGroupCsd[] = {
121 AMEDIAFORMAT_KEY_CSD_0,
122 AMEDIAFORMAT_KEY_CSD_1,
123 AMEDIAFORMAT_KEY_CSD_2,
Wei Jia53692fa2017-12-11 10:33:46 -0800124};
125
126static const char *AMediaFormatKeyGroupRect[] = {
127 AMEDIAFORMAT_KEY_DISPLAY_CROP,
128};
129
130static const char *AMediaFormatKeyGroupFloatInt32[] = {
131 AMEDIAFORMAT_KEY_FRAME_RATE,
132 AMEDIAFORMAT_KEY_I_FRAME_INTERVAL,
133 AMEDIAFORMAT_KEY_OPERATING_RATE,
134};
135
136static status_t translateErrorCode(media_status_t err) {
137 if (err == AMEDIA_OK) {
138 return OK;
Robert Shihd83d4f42018-02-24 19:02:46 -0800139 } else if (err == AMEDIA_ERROR_END_OF_STREAM) {
140 return ERROR_END_OF_STREAM;
141 } else if (err == AMEDIA_ERROR_IO) {
142 return ERROR_IO;
Wei Jia53692fa2017-12-11 10:33:46 -0800143 } else if (err == AMEDIACODEC_INFO_TRY_AGAIN_LATER) {
144 return -EAGAIN;
145 }
146
147 ALOGE("ndk error code: %d", err);
148 return UNKNOWN_ERROR;
149}
150
151static int32_t translateActionCode(int32_t actionCode) {
152 if (AMediaCodecActionCode_isTransient(actionCode)) {
153 return ACTION_CODE_TRANSIENT;
154 } else if (AMediaCodecActionCode_isRecoverable(actionCode)) {
155 return ACTION_CODE_RECOVERABLE;
156 }
157 return ACTION_CODE_FATAL;
158}
159
160static CryptoPlugin::Mode translateToCryptoPluginMode(cryptoinfo_mode_t mode) {
161 CryptoPlugin::Mode ret = CryptoPlugin::kMode_Unencrypted;
162 switch (mode) {
163 case AMEDIACODECRYPTOINFO_MODE_AES_CTR: {
164 ret = CryptoPlugin::kMode_AES_CTR;
165 break;
166 }
167
168 case AMEDIACODECRYPTOINFO_MODE_AES_WV: {
169 ret = CryptoPlugin::kMode_AES_WV;
170 break;
171 }
172
173 case AMEDIACODECRYPTOINFO_MODE_AES_CBC: {
174 ret = CryptoPlugin::kMode_AES_CBC;
175 break;
176 }
177
178 default:
179 break;
180 }
181
182 return ret;
183}
184
185static cryptoinfo_mode_t translateToCryptoInfoMode(CryptoPlugin::Mode mode) {
186 cryptoinfo_mode_t ret = AMEDIACODECRYPTOINFO_MODE_CLEAR;
187 switch (mode) {
188 case CryptoPlugin::kMode_AES_CTR: {
189 ret = AMEDIACODECRYPTOINFO_MODE_AES_CTR;
190 break;
191 }
192
193 case CryptoPlugin::kMode_AES_WV: {
194 ret = AMEDIACODECRYPTOINFO_MODE_AES_WV;
195 break;
196 }
197
198 case CryptoPlugin::kMode_AES_CBC: {
199 ret = AMEDIACODECRYPTOINFO_MODE_AES_CBC;
200 break;
201 }
202
203 default:
204 break;
205 }
206
207 return ret;
208}
209
Wei Jia53692fa2017-12-11 10:33:46 -0800210//////////// AMediaFormatWrapper
211// static
212sp<AMediaFormatWrapper> AMediaFormatWrapper::Create(const sp<AMessage> &message) {
213 sp<AMediaFormatWrapper> aMediaFormat = new AMediaFormatWrapper();
214
215 for (size_t i = 0; i < message->countEntries(); ++i) {
216 AMessage::Type valueType;
217 const char *key = message->getEntryNameAt(i, &valueType);
218
219 switch (valueType) {
220 case AMessage::kTypeInt32: {
221 int32_t val;
222 if (!message->findInt32(key, &val)) {
223 ALOGE("AMediaFormatWrapper::Create: error at item %zu", i);
224 continue;
225 }
226 aMediaFormat->setInt32(key, val);
227 break;
228 }
229
230 case AMessage::kTypeInt64: {
231 int64_t val;
232 if (!message->findInt64(key, &val)) {
233 ALOGE("AMediaFormatWrapper::Create: error at item %zu", i);
234 continue;
235 }
236 aMediaFormat->setInt64(key, val);
237 break;
238 }
239
240 case AMessage::kTypeFloat: {
241 float val;
242 if (!message->findFloat(key, &val)) {
243 ALOGE("AMediaFormatWrapper::Create: error at item %zu", i);
244 continue;
245 }
246 aMediaFormat->setFloat(key, val);
247 break;
248 }
249
250 case AMessage::kTypeDouble: {
251 double val;
252 if (!message->findDouble(key, &val)) {
253 ALOGE("AMediaFormatWrapper::Create: error at item %zu", i);
254 continue;
255 }
256 aMediaFormat->setDouble(key, val);
257 break;
258 }
259
260 case AMessage::kTypeSize: {
261 size_t val;
262 if (!message->findSize(key, &val)) {
263 ALOGE("AMediaFormatWrapper::Create: error at item %zu", i);
264 continue;
265 }
266 aMediaFormat->setSize(key, val);
267 break;
268 }
269
270 case AMessage::kTypeRect: {
271 int32_t left, top, right, bottom;
272 if (!message->findRect(key, &left, &top, &right, &bottom)) {
273 ALOGE("AMediaFormatWrapper::Create: error at item %zu", i);
274 continue;
275 }
276 aMediaFormat->setRect(key, left, top, right, bottom);
277 break;
278 }
279
280 case AMessage::kTypeString: {
281 AString val;
282 if (!message->findString(key, &val)) {
283 ALOGE("AMediaFormatWrapper::Create: error at item %zu", i);
284 continue;
285 }
286 aMediaFormat->setString(key, val);
287 break;
288 }
289
290 case AMessage::kTypeBuffer: {
291 sp<ABuffer> val;
292 if (!message->findBuffer(key, &val)) {
293 ALOGE("AMediaFormatWrapper::Create: error at item %zu", i);
294 continue;
295 }
296 aMediaFormat->setBuffer(key, val->data(), val->size());
297 break;
298 }
299
300 default: {
301 break;
302 }
303 }
304 }
305
306 return aMediaFormat;
307}
308
309AMediaFormatWrapper::AMediaFormatWrapper() {
310 mAMediaFormat = AMediaFormat_new();
311}
312
313AMediaFormatWrapper::AMediaFormatWrapper(AMediaFormat *aMediaFormat)
314 : mAMediaFormat(aMediaFormat) {
315}
316
317AMediaFormatWrapper::~AMediaFormatWrapper() {
318 release();
319}
320
321status_t AMediaFormatWrapper::release() {
322 if (mAMediaFormat != NULL) {
323 media_status_t err = AMediaFormat_delete(mAMediaFormat);
324 mAMediaFormat = NULL;
325 return translateErrorCode(err);
326 }
327 return OK;
328}
329
330AMediaFormat *AMediaFormatWrapper::getAMediaFormat() const {
331 return mAMediaFormat;
332}
333
334sp<AMessage> AMediaFormatWrapper::toAMessage() const {
Robert Shih0cd95062018-01-21 17:41:16 -0800335 sp<AMessage> msg;
336 writeToAMessage(msg);
337 return msg;
338}
339
340void AMediaFormatWrapper::writeToAMessage(sp<AMessage> &msg) const {
Wei Jia53692fa2017-12-11 10:33:46 -0800341 if (mAMediaFormat == NULL) {
Robert Shih0cd95062018-01-21 17:41:16 -0800342 msg = NULL;
Wei Jia53692fa2017-12-11 10:33:46 -0800343 }
344
Robert Shih0cd95062018-01-21 17:41:16 -0800345 if (msg == NULL) {
346 msg = new AMessage;
347 }
Wei Jia53692fa2017-12-11 10:33:46 -0800348 for (auto& key : AMediaFormatKeyGroupInt32) {
349 int32_t val;
350 if (getInt32(key, &val)) {
351 msg->setInt32(key, val);
352 }
353 }
354 for (auto& key : AMediaFormatKeyGroupInt64) {
355 int64_t val;
356 if (getInt64(key, &val)) {
357 msg->setInt64(key, val);
358 }
359 }
360 for (auto& key : AMediaFormatKeyGroupString) {
361 AString val;
362 if (getString(key, &val)) {
363 msg->setString(key, val);
364 }
365 }
366 for (auto& key : AMediaFormatKeyGroupBuffer) {
367 void *data;
368 size_t size;
369 if (getBuffer(key, &data, &size)) {
370 sp<ABuffer> buffer = ABuffer::CreateAsCopy(data, size);
371 msg->setBuffer(key, buffer);
372 }
373 }
Robert Shih0cd95062018-01-21 17:41:16 -0800374 for (auto& key : AMediaFormatKeyGroupCsd) {
375 void *data;
376 size_t size;
377 if (getBuffer(key, &data, &size)) {
378 sp<ABuffer> buffer = ABuffer::CreateAsCopy(data, size);
379 buffer->meta()->setInt32(AMEDIAFORMAT_KEY_CSD, 1);
380 buffer->meta()->setInt64(AMEDIAFORMAT_KEY_TIME_US, 0);
381 msg->setBuffer(key, buffer);
382 }
383 }
Wei Jia53692fa2017-12-11 10:33:46 -0800384 for (auto& key : AMediaFormatKeyGroupRect) {
385 int32_t left, top, right, bottom;
386 if (getRect(key, &left, &top, &right, &bottom)) {
387 msg->setRect(key, left, top, right, bottom);
388 }
389 }
390 for (auto& key : AMediaFormatKeyGroupFloatInt32) {
391 float valFloat;
392 if (getFloat(key, &valFloat)) {
393 msg->setFloat(key, valFloat);
394 } else {
395 int32_t valInt32;
396 if (getInt32(key, &valInt32)) {
397 msg->setFloat(key, (float)valInt32);
398 }
399 }
400 }
Wei Jia53692fa2017-12-11 10:33:46 -0800401}
402
403const char* AMediaFormatWrapper::toString() const {
404 if (mAMediaFormat == NULL) {
405 return NULL;
406 }
407 return AMediaFormat_toString(mAMediaFormat);
408}
409
410bool AMediaFormatWrapper::getInt32(const char *name, int32_t *out) const {
411 if (mAMediaFormat == NULL) {
412 return false;
413 }
414 return AMediaFormat_getInt32(mAMediaFormat, name, out);
415}
416
417bool AMediaFormatWrapper::getInt64(const char *name, int64_t *out) const {
418 if (mAMediaFormat == NULL) {
419 return false;
420 }
421 return AMediaFormat_getInt64(mAMediaFormat, name, out);
422}
423
424bool AMediaFormatWrapper::getFloat(const char *name, float *out) const {
425 if (mAMediaFormat == NULL) {
426 return false;
427 }
428 return AMediaFormat_getFloat(mAMediaFormat, name, out);
429}
430
431bool AMediaFormatWrapper::getDouble(const char *name, double *out) const {
432 if (mAMediaFormat == NULL) {
433 return false;
434 }
435 return AMediaFormat_getDouble(mAMediaFormat, name, out);
436}
437
438bool AMediaFormatWrapper::getSize(const char *name, size_t *out) const {
439 if (mAMediaFormat == NULL) {
440 return false;
441 }
442 return AMediaFormat_getSize(mAMediaFormat, name, out);
443}
444
445bool AMediaFormatWrapper::getRect(
446 const char *name, int32_t *left, int32_t *top, int32_t *right, int32_t *bottom) const {
447 if (mAMediaFormat == NULL) {
448 return false;
449 }
450 return AMediaFormat_getRect(mAMediaFormat, name, left, top, right, bottom);
451}
452
453bool AMediaFormatWrapper::getBuffer(const char *name, void** data, size_t *outSize) const {
454 if (mAMediaFormat == NULL) {
455 return false;
456 }
457 return AMediaFormat_getBuffer(mAMediaFormat, name, data, outSize);
458}
459
460bool AMediaFormatWrapper::getString(const char *name, AString *out) const {
461 if (mAMediaFormat == NULL) {
462 return false;
463 }
464 const char *outChar = NULL;
465 bool ret = AMediaFormat_getString(mAMediaFormat, name, &outChar);
466 if (ret) {
467 *out = AString(outChar);
468 }
469 return ret;
470}
471
472void AMediaFormatWrapper::setInt32(const char* name, int32_t value) {
473 if (mAMediaFormat != NULL) {
474 AMediaFormat_setInt32(mAMediaFormat, name, value);
475 }
476}
477
478void AMediaFormatWrapper::setInt64(const char* name, int64_t value) {
479 if (mAMediaFormat != NULL) {
480 AMediaFormat_setInt64(mAMediaFormat, name, value);
481 }
482}
483
484void AMediaFormatWrapper::setFloat(const char* name, float value) {
485 if (mAMediaFormat != NULL) {
486 AMediaFormat_setFloat(mAMediaFormat, name, value);
487 }
488}
489
490void AMediaFormatWrapper::setDouble(const char* name, double value) {
491 if (mAMediaFormat != NULL) {
492 AMediaFormat_setDouble(mAMediaFormat, name, value);
493 }
494}
495
496void AMediaFormatWrapper::setSize(const char* name, size_t value) {
497 if (mAMediaFormat != NULL) {
498 AMediaFormat_setSize(mAMediaFormat, name, value);
499 }
500}
501
502void AMediaFormatWrapper::setRect(
503 const char* name, int32_t left, int32_t top, int32_t right, int32_t bottom) {
504 if (mAMediaFormat != NULL) {
505 AMediaFormat_setRect(mAMediaFormat, name, left, top, right, bottom);
506 }
507}
508
509void AMediaFormatWrapper::setString(const char* name, const AString &value) {
510 if (mAMediaFormat != NULL) {
511 AMediaFormat_setString(mAMediaFormat, name, value.c_str());
512 }
513}
514
515void AMediaFormatWrapper::setBuffer(const char* name, void* data, size_t size) {
516 if (mAMediaFormat != NULL) {
517 AMediaFormat_setBuffer(mAMediaFormat, name, data, size);
518 }
519}
520
521
Wei Jia28288fb2017-12-15 13:45:29 -0800522//////////// ANativeWindowWrapper
523ANativeWindowWrapper::ANativeWindowWrapper(ANativeWindow *aNativeWindow)
524 : mANativeWindow(aNativeWindow) {
525 if (aNativeWindow != NULL) {
526 ANativeWindow_acquire(aNativeWindow);
527 }
528}
529
530ANativeWindowWrapper::~ANativeWindowWrapper() {
531 release();
532}
533
534status_t ANativeWindowWrapper::release() {
535 if (mANativeWindow != NULL) {
536 ANativeWindow_release(mANativeWindow);
537 mANativeWindow = NULL;
538 }
539 return OK;
540}
541
542ANativeWindow *ANativeWindowWrapper::getANativeWindow() const {
543 return mANativeWindow;
544}
545
546
Wei Jia53692fa2017-12-11 10:33:46 -0800547//////////// AMediaDrmWrapper
548AMediaDrmWrapper::AMediaDrmWrapper(const uint8_t uuid[16]) {
549 mAMediaDrm = AMediaDrm_createByUUID(uuid);
550}
551
552AMediaDrmWrapper::AMediaDrmWrapper(AMediaDrm *aMediaDrm)
553 : mAMediaDrm(aMediaDrm) {
554}
555
556AMediaDrmWrapper::~AMediaDrmWrapper() {
557 release();
558}
559
560status_t AMediaDrmWrapper::release() {
561 if (mAMediaDrm != NULL) {
562 AMediaDrm_release(mAMediaDrm);
563 mAMediaDrm = NULL;
564 }
565 return OK;
566}
567
568AMediaDrm *AMediaDrmWrapper::getAMediaDrm() const {
569 return mAMediaDrm;
570}
571
572// static
573bool AMediaDrmWrapper::isCryptoSchemeSupported(
574 const uint8_t uuid[16],
575 const char *mimeType) {
576 return AMediaDrm_isCryptoSchemeSupported(uuid, mimeType);
577}
578
579
580//////////// AMediaCryptoWrapper
581AMediaCryptoWrapper::AMediaCryptoWrapper(
582 const uint8_t uuid[16], const void *initData, size_t initDataSize) {
583 mAMediaCrypto = AMediaCrypto_new(uuid, initData, initDataSize);
584}
585
586AMediaCryptoWrapper::AMediaCryptoWrapper(AMediaCrypto *aMediaCrypto)
587 : mAMediaCrypto(aMediaCrypto) {
588}
589
590AMediaCryptoWrapper::~AMediaCryptoWrapper() {
591 release();
592}
593
594status_t AMediaCryptoWrapper::release() {
595 if (mAMediaCrypto != NULL) {
596 AMediaCrypto_delete(mAMediaCrypto);
597 mAMediaCrypto = NULL;
598 }
599 return OK;
600}
601
602AMediaCrypto *AMediaCryptoWrapper::getAMediaCrypto() const {
603 return mAMediaCrypto;
604}
605
606bool AMediaCryptoWrapper::isCryptoSchemeSupported(const uint8_t uuid[16]) {
607 if (mAMediaCrypto == NULL) {
608 return false;
609 }
610 return AMediaCrypto_isCryptoSchemeSupported(uuid);
611}
612
613bool AMediaCryptoWrapper::requiresSecureDecoderComponent(const char *mime) {
614 if (mAMediaCrypto == NULL) {
615 return false;
616 }
617 return AMediaCrypto_requiresSecureDecoderComponent(mime);
618}
619
620
621//////////// AMediaCodecCryptoInfoWrapper
622// static
Marco Nelissen3d21ae32018-02-16 08:24:08 -0800623sp<AMediaCodecCryptoInfoWrapper> AMediaCodecCryptoInfoWrapper::Create(MetaDataBase &meta) {
Wei Jia53692fa2017-12-11 10:33:46 -0800624
625 uint32_t type;
626 const void *crypteddata;
627 size_t cryptedsize;
628
Marco Nelissen3d21ae32018-02-16 08:24:08 -0800629 if (!meta.findData(kKeyEncryptedSizes, &type, &crypteddata, &cryptedsize)) {
Wei Jia53692fa2017-12-11 10:33:46 -0800630 return NULL;
631 }
632
633 int numSubSamples = cryptedsize / sizeof(size_t);
634
635 if (numSubSamples <= 0) {
636 ALOGE("Create: INVALID numSubSamples: %d", numSubSamples);
637 return NULL;
638 }
639
640 const void *cleardata;
641 size_t clearsize;
Marco Nelissen3d21ae32018-02-16 08:24:08 -0800642 if (meta.findData(kKeyPlainSizes, &type, &cleardata, &clearsize)) {
Wei Jia53692fa2017-12-11 10:33:46 -0800643 if (clearsize != cryptedsize) {
644 // The two must be of the same length.
645 ALOGE("Create: mismatch cryptedsize: %zu != clearsize: %zu", cryptedsize, clearsize);
646 return NULL;
647 }
648 }
649
650 const void *key;
651 size_t keysize;
Marco Nelissen3d21ae32018-02-16 08:24:08 -0800652 if (meta.findData(kKeyCryptoKey, &type, &key, &keysize)) {
Wei Jia53692fa2017-12-11 10:33:46 -0800653 if (keysize != kAESBlockSize) {
654 // Keys must be 16 bytes in length.
655 ALOGE("Create: Keys must be %zu bytes in length: %zu", kAESBlockSize, keysize);
656 return NULL;
657 }
658 }
659
660 const void *iv;
661 size_t ivsize;
Marco Nelissen3d21ae32018-02-16 08:24:08 -0800662 if (meta.findData(kKeyCryptoIV, &type, &iv, &ivsize)) {
Wei Jia53692fa2017-12-11 10:33:46 -0800663 if (ivsize != kAESBlockSize) {
664 // IVs must be 16 bytes in length.
665 ALOGE("Create: IV must be %zu bytes in length: %zu", kAESBlockSize, ivsize);
666 return NULL;
667 }
668 }
669
670 int32_t mode;
Marco Nelissen3d21ae32018-02-16 08:24:08 -0800671 if (!meta.findInt32(kKeyCryptoMode, &mode)) {
Wei Jia53692fa2017-12-11 10:33:46 -0800672 mode = CryptoPlugin::kMode_AES_CTR;
673 }
674
675 return new AMediaCodecCryptoInfoWrapper(
676 numSubSamples,
677 (uint8_t*) key,
678 (uint8_t*) iv,
679 (CryptoPlugin::Mode)mode,
680 (size_t*) cleardata,
681 (size_t*) crypteddata);
682}
683
684AMediaCodecCryptoInfoWrapper::AMediaCodecCryptoInfoWrapper(
685 int numsubsamples,
686 uint8_t key[16],
687 uint8_t iv[16],
688 CryptoPlugin::Mode mode,
689 size_t *clearbytes,
690 size_t *encryptedbytes) {
691 mAMediaCodecCryptoInfo =
692 AMediaCodecCryptoInfo_new(numsubsamples,
693 key,
694 iv,
695 translateToCryptoInfoMode(mode),
696 clearbytes,
697 encryptedbytes);
698}
699
700AMediaCodecCryptoInfoWrapper::AMediaCodecCryptoInfoWrapper(
701 AMediaCodecCryptoInfo *aMediaCodecCryptoInfo)
702 : mAMediaCodecCryptoInfo(aMediaCodecCryptoInfo) {
703}
704
705AMediaCodecCryptoInfoWrapper::~AMediaCodecCryptoInfoWrapper() {
706 release();
707}
708
709status_t AMediaCodecCryptoInfoWrapper::release() {
710 if (mAMediaCodecCryptoInfo != NULL) {
711 media_status_t err = AMediaCodecCryptoInfo_delete(mAMediaCodecCryptoInfo);
712 mAMediaCodecCryptoInfo = NULL;
713 return translateErrorCode(err);
714 }
715 return OK;
716}
717
718AMediaCodecCryptoInfo *AMediaCodecCryptoInfoWrapper::getAMediaCodecCryptoInfo() const {
719 return mAMediaCodecCryptoInfo;
720}
721
722void AMediaCodecCryptoInfoWrapper::setPattern(CryptoPlugin::Pattern *pattern) {
723 if (mAMediaCodecCryptoInfo == NULL || pattern == NULL) {
724 return;
725 }
726 cryptoinfo_pattern_t ndkPattern = {(int32_t)pattern->mEncryptBlocks,
727 (int32_t)pattern->mSkipBlocks };
728 return AMediaCodecCryptoInfo_setPattern(mAMediaCodecCryptoInfo, &ndkPattern);
729}
730
731size_t AMediaCodecCryptoInfoWrapper::getNumSubSamples() {
732 if (mAMediaCodecCryptoInfo == NULL) {
733 return 0;
734 }
735 return AMediaCodecCryptoInfo_getNumSubSamples(mAMediaCodecCryptoInfo);
736}
737
738status_t AMediaCodecCryptoInfoWrapper::getKey(uint8_t *dst) {
739 if (mAMediaCodecCryptoInfo == NULL) {
740 return DEAD_OBJECT;
741 }
742 if (dst == NULL) {
743 return BAD_VALUE;
744 }
745 return translateErrorCode(
746 AMediaCodecCryptoInfo_getKey(mAMediaCodecCryptoInfo, dst));
747}
748
749status_t AMediaCodecCryptoInfoWrapper::getIV(uint8_t *dst) {
750 if (mAMediaCodecCryptoInfo == NULL) {
751 return DEAD_OBJECT;
752 }
753 if (dst == NULL) {
754 return BAD_VALUE;
755 }
756 return translateErrorCode(
757 AMediaCodecCryptoInfo_getIV(mAMediaCodecCryptoInfo, dst));
758}
759
760CryptoPlugin::Mode AMediaCodecCryptoInfoWrapper::getMode() {
761 if (mAMediaCodecCryptoInfo == NULL) {
762 return CryptoPlugin::kMode_Unencrypted;
763 }
764 return translateToCryptoPluginMode(
765 AMediaCodecCryptoInfo_getMode(mAMediaCodecCryptoInfo));
766}
767
768status_t AMediaCodecCryptoInfoWrapper::getClearBytes(size_t *dst) {
769 if (mAMediaCodecCryptoInfo == NULL) {
770 return DEAD_OBJECT;
771 }
772 if (dst == NULL) {
773 return BAD_VALUE;
774 }
775 return translateErrorCode(
776 AMediaCodecCryptoInfo_getClearBytes(mAMediaCodecCryptoInfo, dst));
777}
778
779status_t AMediaCodecCryptoInfoWrapper::getEncryptedBytes(size_t *dst) {
780 if (mAMediaCodecCryptoInfo == NULL) {
781 return DEAD_OBJECT;
782 }
783 if (dst == NULL) {
784 return BAD_VALUE;
785 }
786 return translateErrorCode(
787 AMediaCodecCryptoInfo_getEncryptedBytes(mAMediaCodecCryptoInfo, dst));
788}
789
790
791//////////// AMediaCodecWrapper
792// static
793sp<AMediaCodecWrapper> AMediaCodecWrapper::CreateCodecByName(const AString &name) {
794 AMediaCodec *aMediaCodec = AMediaCodec_createCodecByName(name.c_str());
795 return new AMediaCodecWrapper(aMediaCodec);
796}
797
798// static
799sp<AMediaCodecWrapper> AMediaCodecWrapper::CreateDecoderByType(const AString &mimeType) {
800 AMediaCodec *aMediaCodec = AMediaCodec_createDecoderByType(mimeType.c_str());
801 return new AMediaCodecWrapper(aMediaCodec);
802}
803
804// static
805void AMediaCodecWrapper::OnInputAvailableCB(
806 AMediaCodec * /* aMediaCodec */,
807 void *userdata,
808 int32_t index) {
809 ALOGV("OnInputAvailableCB: index(%d)", index);
810 sp<AMessage> msg = sp<AMessage>((AMessage *)userdata)->dup();
811 msg->setInt32("callbackID", CB_INPUT_AVAILABLE);
812 msg->setInt32("index", index);
813 msg->post();
814}
815
816// static
817void AMediaCodecWrapper::OnOutputAvailableCB(
818 AMediaCodec * /* aMediaCodec */,
819 void *userdata,
820 int32_t index,
821 AMediaCodecBufferInfo *bufferInfo) {
822 ALOGV("OnOutputAvailableCB: index(%d), (%d, %d, %lld, 0x%x)",
823 index, bufferInfo->offset, bufferInfo->size,
824 (long long)bufferInfo->presentationTimeUs, bufferInfo->flags);
825 sp<AMessage> msg = sp<AMessage>((AMessage *)userdata)->dup();
826 msg->setInt32("callbackID", CB_OUTPUT_AVAILABLE);
827 msg->setInt32("index", index);
828 msg->setSize("offset", (size_t)(bufferInfo->offset));
829 msg->setSize("size", (size_t)(bufferInfo->size));
830 msg->setInt64("timeUs", bufferInfo->presentationTimeUs);
831 msg->setInt32("flags", (int32_t)(bufferInfo->flags));
832 msg->post();
833}
834
835// static
836void AMediaCodecWrapper::OnFormatChangedCB(
837 AMediaCodec * /* aMediaCodec */,
838 void *userdata,
839 AMediaFormat *format) {
840 sp<AMediaFormatWrapper> formatWrapper = new AMediaFormatWrapper(format);
841 sp<AMessage> outputFormat = formatWrapper->toAMessage();
842 ALOGV("OnFormatChangedCB: format(%s)", outputFormat->debugString().c_str());
843
844 sp<AMessage> msg = sp<AMessage>((AMessage *)userdata)->dup();
845 msg->setInt32("callbackID", CB_OUTPUT_FORMAT_CHANGED);
846 msg->setMessage("format", outputFormat);
847 msg->post();
848}
849
850// static
851void AMediaCodecWrapper::OnErrorCB(
852 AMediaCodec * /* aMediaCodec */,
853 void *userdata,
854 media_status_t err,
855 int32_t actionCode,
856 const char *detail) {
857 ALOGV("OnErrorCB: err(%d), actionCode(%d), detail(%s)", err, actionCode, detail);
858 sp<AMessage> msg = sp<AMessage>((AMessage *)userdata)->dup();
859 msg->setInt32("callbackID", CB_ERROR);
860 msg->setInt32("err", translateErrorCode(err));
861 msg->setInt32("actionCode", translateActionCode(actionCode));
862 msg->setString("detail", detail);
863 msg->post();
864}
865
866AMediaCodecWrapper::AMediaCodecWrapper(AMediaCodec *aMediaCodec)
867 : mAMediaCodec(aMediaCodec) {
868}
869
870AMediaCodecWrapper::~AMediaCodecWrapper() {
871 release();
872}
873
874status_t AMediaCodecWrapper::release() {
875 if (mAMediaCodec != NULL) {
876 AMediaCodecOnAsyncNotifyCallback aCB = {};
877 AMediaCodec_setAsyncNotifyCallback(mAMediaCodec, aCB, NULL);
878 mCallback = NULL;
879
880 media_status_t err = AMediaCodec_delete(mAMediaCodec);
881 mAMediaCodec = NULL;
882 return translateErrorCode(err);
883 }
884 return OK;
885}
886
887AMediaCodec *AMediaCodecWrapper::getAMediaCodec() const {
888 return mAMediaCodec;
889}
890
891status_t AMediaCodecWrapper::getName(AString *outComponentName) const {
892 if (mAMediaCodec == NULL) {
893 return DEAD_OBJECT;
894 }
895 char *name = NULL;
896 media_status_t err = AMediaCodec_getName(mAMediaCodec, &name);
897 if (err != AMEDIA_OK) {
898 return translateErrorCode(err);
899 }
900
901 *outComponentName = AString(name);
902 AMediaCodec_releaseName(mAMediaCodec, name);
903 return OK;
904}
905
906status_t AMediaCodecWrapper::configure(
907 const sp<AMediaFormatWrapper> &format,
Wei Jia28288fb2017-12-15 13:45:29 -0800908 const sp<ANativeWindowWrapper> &nww,
Wei Jia53692fa2017-12-11 10:33:46 -0800909 const sp<AMediaCryptoWrapper> &crypto,
910 uint32_t flags) {
911 if (mAMediaCodec == NULL) {
912 return DEAD_OBJECT;
913 }
914
915 media_status_t err = AMediaCodec_configure(
916 mAMediaCodec,
917 format->getAMediaFormat(),
Wei Jia28288fb2017-12-15 13:45:29 -0800918 (nww == NULL ? NULL : nww->getANativeWindow()),
Wei Jia53692fa2017-12-11 10:33:46 -0800919 crypto == NULL ? NULL : crypto->getAMediaCrypto(),
920 flags);
921
922 return translateErrorCode(err);
923}
924
925status_t AMediaCodecWrapper::setCallback(const sp<AMessage> &callback) {
926 if (mAMediaCodec == NULL) {
927 return DEAD_OBJECT;
928 }
929
930 mCallback = callback;
931
932 AMediaCodecOnAsyncNotifyCallback aCB = {
933 OnInputAvailableCB,
934 OnOutputAvailableCB,
935 OnFormatChangedCB,
936 OnErrorCB
937 };
938
939 return translateErrorCode(
940 AMediaCodec_setAsyncNotifyCallback(mAMediaCodec, aCB, callback.get()));
941}
942
943status_t AMediaCodecWrapper::releaseCrypto() {
944 if (mAMediaCodec == NULL) {
945 return DEAD_OBJECT;
946 }
947 return translateErrorCode(AMediaCodec_releaseCrypto(mAMediaCodec));
948}
949
950status_t AMediaCodecWrapper::start() {
951 if (mAMediaCodec == NULL) {
952 return DEAD_OBJECT;
953 }
954 return translateErrorCode(AMediaCodec_start(mAMediaCodec));
955}
956
957status_t AMediaCodecWrapper::stop() {
958 if (mAMediaCodec == NULL) {
959 return DEAD_OBJECT;
960 }
961 return translateErrorCode(AMediaCodec_stop(mAMediaCodec));
962}
963
964status_t AMediaCodecWrapper::flush() {
965 if (mAMediaCodec == NULL) {
966 return DEAD_OBJECT;
967 }
968 return translateErrorCode(AMediaCodec_flush(mAMediaCodec));
969}
970
971uint8_t* AMediaCodecWrapper::getInputBuffer(size_t idx, size_t *out_size) {
972 if (mAMediaCodec == NULL) {
973 return NULL;
974 }
975 return AMediaCodec_getInputBuffer(mAMediaCodec, idx, out_size);
976}
977
978uint8_t* AMediaCodecWrapper::getOutputBuffer(size_t idx, size_t *out_size) {
979 if (mAMediaCodec == NULL) {
980 return NULL;
981 }
982 return AMediaCodec_getOutputBuffer(mAMediaCodec, idx, out_size);
983}
984
985status_t AMediaCodecWrapper::queueInputBuffer(
986 size_t idx,
987 size_t offset,
988 size_t size,
989 uint64_t time,
990 uint32_t flags) {
991 if (mAMediaCodec == NULL) {
992 return DEAD_OBJECT;
993 }
994 return translateErrorCode(
995 AMediaCodec_queueInputBuffer(mAMediaCodec, idx, offset, size, time, flags));
996}
997
998status_t AMediaCodecWrapper::queueSecureInputBuffer(
999 size_t idx,
1000 size_t offset,
1001 sp<AMediaCodecCryptoInfoWrapper> &codecCryptoInfo,
1002 uint64_t time,
1003 uint32_t flags) {
1004 if (mAMediaCodec == NULL) {
1005 return DEAD_OBJECT;
1006 }
1007 return translateErrorCode(
1008 AMediaCodec_queueSecureInputBuffer(
1009 mAMediaCodec,
1010 idx,
1011 offset,
1012 codecCryptoInfo->getAMediaCodecCryptoInfo(),
1013 time,
1014 flags));
1015}
1016
1017sp<AMediaFormatWrapper> AMediaCodecWrapper::getOutputFormat() {
1018 if (mAMediaCodec == NULL) {
1019 return NULL;
1020 }
1021 return new AMediaFormatWrapper(AMediaCodec_getOutputFormat(mAMediaCodec));
1022}
1023
1024sp<AMediaFormatWrapper> AMediaCodecWrapper::getInputFormat() {
1025 if (mAMediaCodec == NULL) {
1026 return NULL;
1027 }
1028 return new AMediaFormatWrapper(AMediaCodec_getInputFormat(mAMediaCodec));
1029}
1030
1031status_t AMediaCodecWrapper::releaseOutputBuffer(size_t idx, bool render) {
1032 if (mAMediaCodec == NULL) {
1033 return DEAD_OBJECT;
1034 }
1035 return translateErrorCode(
1036 AMediaCodec_releaseOutputBuffer(mAMediaCodec, idx, render));
1037}
1038
Wei Jia28288fb2017-12-15 13:45:29 -08001039status_t AMediaCodecWrapper::setOutputSurface(const sp<ANativeWindowWrapper> &nww) {
Wei Jia53692fa2017-12-11 10:33:46 -08001040 if (mAMediaCodec == NULL) {
1041 return DEAD_OBJECT;
1042 }
1043 return translateErrorCode(
Wei Jia28288fb2017-12-15 13:45:29 -08001044 AMediaCodec_setOutputSurface(mAMediaCodec,
1045 (nww == NULL ? NULL : nww->getANativeWindow())));
Wei Jia53692fa2017-12-11 10:33:46 -08001046}
1047
1048status_t AMediaCodecWrapper::releaseOutputBufferAtTime(size_t idx, int64_t timestampNs) {
1049 if (mAMediaCodec == NULL) {
1050 return DEAD_OBJECT;
1051 }
1052 return translateErrorCode(
1053 AMediaCodec_releaseOutputBufferAtTime(mAMediaCodec, idx, timestampNs));
1054}
1055
1056status_t AMediaCodecWrapper::setParameters(const sp<AMediaFormatWrapper> &params) {
1057 if (mAMediaCodec == NULL) {
1058 return DEAD_OBJECT;
1059 }
1060 return translateErrorCode(
1061 AMediaCodec_setParameters(mAMediaCodec, params->getAMediaFormat()));
1062}
1063
Robert Shihff282cb2017-12-18 14:10:56 -08001064//////////// AMediaExtractorWrapper
1065
1066AMediaExtractorWrapper::AMediaExtractorWrapper(AMediaExtractor *aMediaExtractor)
1067 : mAMediaExtractor(aMediaExtractor) {
1068}
1069
1070AMediaExtractorWrapper::~AMediaExtractorWrapper() {
1071 release();
1072}
1073
1074status_t AMediaExtractorWrapper::release() {
1075 if (mAMediaExtractor != NULL) {
1076 media_status_t err = AMediaExtractor_delete(mAMediaExtractor);
1077 mAMediaExtractor = NULL;
1078 return translateErrorCode(err);
1079 }
1080 return OK;
1081}
1082
Robert Shih08eb9082018-03-09 13:57:26 -08001083status_t AMediaExtractorWrapper::disconnect() {
1084 if (mAMediaExtractor != NULL) {
1085 media_status_t err = AMediaExtractor_disconnect(mAMediaExtractor);
1086 return translateErrorCode(err);
1087 }
1088 return DEAD_OBJECT;
1089}
1090
Robert Shihff282cb2017-12-18 14:10:56 -08001091AMediaExtractor *AMediaExtractorWrapper::getAMediaExtractor() const {
1092 return mAMediaExtractor;
1093}
1094
1095status_t AMediaExtractorWrapper::setDataSource(int fd, off64_t offset, off64_t length) {
1096 if (mAMediaExtractor == NULL) {
1097 return DEAD_OBJECT;
1098 }
1099 return translateErrorCode(AMediaExtractor_setDataSourceFd(
1100 mAMediaExtractor, fd, offset, length));
1101}
1102
1103status_t AMediaExtractorWrapper::setDataSource(const char *location) {
1104 if (mAMediaExtractor == NULL) {
1105 return DEAD_OBJECT;
1106 }
1107 return translateErrorCode(AMediaExtractor_setDataSource(mAMediaExtractor, location));
1108}
1109
Robert Shihd4faf9e2018-01-21 17:52:25 -08001110status_t AMediaExtractorWrapper::setDataSource(AMediaDataSource *source) {
1111 if (mAMediaExtractor == NULL) {
1112 return DEAD_OBJECT;
1113 }
1114 return translateErrorCode(AMediaExtractor_setDataSourceCustom(mAMediaExtractor, source));
1115}
1116
Robert Shihff282cb2017-12-18 14:10:56 -08001117size_t AMediaExtractorWrapper::getTrackCount() {
1118 if (mAMediaExtractor == NULL) {
1119 return 0;
1120 }
1121 return AMediaExtractor_getTrackCount(mAMediaExtractor);
1122}
1123
Robert Shihd4faf9e2018-01-21 17:52:25 -08001124sp<AMediaFormatWrapper> AMediaExtractorWrapper::getFormat() {
1125 if (mAMediaExtractor == NULL) {
1126 return NULL;
1127 }
1128 return new AMediaFormatWrapper(AMediaExtractor_getFileFormat(mAMediaExtractor));
1129}
1130
Robert Shihff282cb2017-12-18 14:10:56 -08001131sp<AMediaFormatWrapper> AMediaExtractorWrapper::getTrackFormat(size_t idx) {
1132 if (mAMediaExtractor == NULL) {
1133 return NULL;
1134 }
1135 return new AMediaFormatWrapper(AMediaExtractor_getTrackFormat(mAMediaExtractor, idx));
1136}
1137
1138status_t AMediaExtractorWrapper::selectTrack(size_t idx) {
1139 if (mAMediaExtractor == NULL) {
1140 return DEAD_OBJECT;
1141 }
1142 return translateErrorCode(AMediaExtractor_selectTrack(mAMediaExtractor, idx));
1143}
1144
1145status_t AMediaExtractorWrapper::unselectTrack(size_t idx) {
1146 if (mAMediaExtractor == NULL) {
1147 return DEAD_OBJECT;
1148 }
1149 return translateErrorCode(AMediaExtractor_unselectTrack(mAMediaExtractor, idx));
1150}
1151
Robert Shihd4faf9e2018-01-21 17:52:25 -08001152status_t AMediaExtractorWrapper::selectSingleTrack(size_t idx) {
1153 if (mAMediaExtractor == NULL) {
1154 return DEAD_OBJECT;
1155 }
1156 for (size_t i = 0; i < AMediaExtractor_getTrackCount(mAMediaExtractor); ++i) {
1157 if (i == idx) {
1158 media_status_t err = AMediaExtractor_selectTrack(mAMediaExtractor, i);
1159 if (err != AMEDIA_OK) {
1160 return translateErrorCode(err);
1161 }
1162 } else {
1163 media_status_t err = AMediaExtractor_unselectTrack(mAMediaExtractor, i);
1164 if (err != AMEDIA_OK) {
1165 return translateErrorCode(err);
1166 }
1167 }
1168 }
1169 return OK;
1170}
1171
Robert Shihff282cb2017-12-18 14:10:56 -08001172ssize_t AMediaExtractorWrapper::readSampleData(const sp<ABuffer> &buffer) {
1173 if (mAMediaExtractor == NULL) {
1174 return -1;
1175 }
1176 return AMediaExtractor_readSampleData(mAMediaExtractor, buffer->data(), buffer->capacity());
1177}
1178
Robert Shihd4faf9e2018-01-21 17:52:25 -08001179ssize_t AMediaExtractorWrapper::getSampleSize() {
1180 if (mAMediaExtractor == NULL) {
1181 return 0;
1182 }
1183 return AMediaExtractor_getSampleSize(mAMediaExtractor);
1184}
1185
Robert Shihff282cb2017-12-18 14:10:56 -08001186uint32_t AMediaExtractorWrapper::getSampleFlags() {
1187 if (mAMediaExtractor == NULL) {
1188 return 0;
1189 }
1190 return AMediaExtractor_getSampleFlags(mAMediaExtractor);
1191}
1192
1193int AMediaExtractorWrapper::getSampleTrackIndex() {
1194 if (mAMediaExtractor == NULL) {
1195 return -1;
1196 }
1197 return AMediaExtractor_getSampleTrackIndex(mAMediaExtractor);
1198}
1199
1200int64_t AMediaExtractorWrapper::getSampleTime() {
1201 if (mAMediaExtractor == NULL) {
1202 return -1;
1203 }
1204 return AMediaExtractor_getSampleTime(mAMediaExtractor);
1205}
1206
Robert Shihd83d4f42018-02-24 19:02:46 -08001207status_t AMediaExtractorWrapper::getSampleFormat(sp<AMediaFormatWrapper> &formatWrapper) {
1208 if (mAMediaExtractor == NULL) {
1209 return DEAD_OBJECT;
1210 }
1211 AMediaFormat *format = AMediaFormat_new();
1212 formatWrapper = new AMediaFormatWrapper(format);
1213 return translateErrorCode(AMediaExtractor_getSampleFormat(mAMediaExtractor, format));
1214}
1215
Robert Shihd4faf9e2018-01-21 17:52:25 -08001216int64_t AMediaExtractorWrapper::getCachedDuration() {
1217 if (mAMediaExtractor == NULL) {
1218 return -1;
1219 }
1220 return AMediaExtractor_getCachedDuration(mAMediaExtractor);
1221}
1222
Robert Shihff282cb2017-12-18 14:10:56 -08001223bool AMediaExtractorWrapper::advance() {
1224 if (mAMediaExtractor == NULL) {
1225 return false;
1226 }
1227 return AMediaExtractor_advance(mAMediaExtractor);
1228}
1229
Robert Shihd4faf9e2018-01-21 17:52:25 -08001230status_t AMediaExtractorWrapper::seekTo(int64_t seekPosUs, MediaSource::ReadOptions::SeekMode mode) {
Robert Shihff282cb2017-12-18 14:10:56 -08001231 if (mAMediaExtractor == NULL) {
1232 return DEAD_OBJECT;
1233 }
Robert Shihd4faf9e2018-01-21 17:52:25 -08001234
1235 SeekMode aMode;
1236 switch (mode) {
1237 case MediaSource::ReadOptions::SEEK_PREVIOUS_SYNC: {
1238 aMode = AMEDIAEXTRACTOR_SEEK_PREVIOUS_SYNC;
1239 break;
1240 }
1241 case MediaSource::ReadOptions::SEEK_NEXT_SYNC: {
1242 aMode = AMEDIAEXTRACTOR_SEEK_NEXT_SYNC;
1243 break;
1244 }
1245 default: {
1246 aMode = AMEDIAEXTRACTOR_SEEK_CLOSEST_SYNC;
1247 break;
1248 }
1249 }
1250 return AMediaExtractor_seekTo(mAMediaExtractor, seekPosUs, aMode);
Robert Shihff282cb2017-12-18 14:10:56 -08001251}
1252
1253PsshInfo* AMediaExtractorWrapper::getPsshInfo() {
1254 if (mAMediaExtractor == NULL) {
1255 return NULL;
1256 }
1257 return AMediaExtractor_getPsshInfo(mAMediaExtractor);
1258}
1259
1260sp<AMediaCodecCryptoInfoWrapper> AMediaExtractorWrapper::getSampleCryptoInfo() {
1261 if (mAMediaExtractor == NULL) {
1262 return NULL;
1263 }
1264 return new AMediaCodecCryptoInfoWrapper(AMediaExtractor_getSampleCryptoInfo(mAMediaExtractor));
1265}
1266
Robert Shihd4faf9e2018-01-21 17:52:25 -08001267ssize_t AMediaDataSourceWrapper::AMediaDataSourceWrapper_getSize(void *userdata) {
1268 DataSource *source = static_cast<DataSource *>(userdata);
1269 off64_t size = -1;
1270 source->getSize(&size);
1271 return size;
1272}
1273
1274ssize_t AMediaDataSourceWrapper::AMediaDataSourceWrapper_readAt(void *userdata, off64_t offset, void * buf, size_t size) {
1275 DataSource *source = static_cast<DataSource *>(userdata);
1276 return source->readAt(offset, buf, size);
1277}
1278
1279void AMediaDataSourceWrapper::AMediaDataSourceWrapper_close(void *userdata) {
1280 DataSource *source = static_cast<DataSource *>(userdata);
1281 source->close();
1282}
1283
1284AMediaDataSourceWrapper::AMediaDataSourceWrapper(const sp<DataSource> &dataSource)
1285 : mDataSource(dataSource),
1286 mAMediaDataSource(AMediaDataSource_new()) {
1287 ALOGV("setDataSource (source: %p)", dataSource.get());
1288 AMediaDataSource_setUserdata(mAMediaDataSource, dataSource.get());
1289 AMediaDataSource_setReadAt(mAMediaDataSource, AMediaDataSourceWrapper_readAt);
1290 AMediaDataSource_setGetSize(mAMediaDataSource, AMediaDataSourceWrapper_getSize);
1291 AMediaDataSource_setClose(mAMediaDataSource, AMediaDataSourceWrapper_close);
1292}
1293
1294AMediaDataSourceWrapper::~AMediaDataSourceWrapper() {
1295 if (mAMediaDataSource == NULL) {
1296 return;
1297 }
1298 AMediaDataSource_delete(mAMediaDataSource);
1299 mAMediaDataSource = NULL;
1300}
1301
1302AMediaDataSource* AMediaDataSourceWrapper::getAMediaDataSource() {
1303 return mAMediaDataSource;
1304}
1305
Wei Jia53692fa2017-12-11 10:33:46 -08001306} // namespace android