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