1/*
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
20#include <media/NdkWrapper.h>
21
22#include <android/native_window.h>
23#include <log/log.h>
24#include <media/NdkMediaCodec.h>
25#include <media/NdkMediaCrypto.h>
26#include <media/NdkMediaDrm.h>
27#include <media/NdkMediaFormat.h>
28#include <media/NdkMediaExtractor.h>
29#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
34// 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
46namespace 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,
71    AMEDIAFORMAT_KEY_GRID_COLUMNS,
72    AMEDIAFORMAT_KEY_GRID_ROWS,
73    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,
94    AMEDIAFORMAT_KEY_DISPLAY_HEIGHT,
95    AMEDIAFORMAT_KEY_DISPLAY_WIDTH,
96    AMEDIAFORMAT_KEY_TEMPORAL_LAYER_ID,
97    AMEDIAFORMAT_KEY_TILE_HEIGHT,
98    AMEDIAFORMAT_KEY_TILE_WIDTH,
99    AMEDIAFORMAT_KEY_TRACK_INDEX,
100};
101
102static const char *AMediaFormatKeyGroupInt64[] = {
103    AMEDIAFORMAT_KEY_DURATION,
104    AMEDIAFORMAT_KEY_REPEAT_PREVIOUS_FRAME_AFTER,
105    AMEDIAFORMAT_KEY_TIME_US,
106};
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,
116    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,
124};
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;
139    } 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;
143    } 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
210//////////// 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 {
335  sp<AMessage> msg;
336  writeToAMessage(msg);
337  return msg;
338}
339
340void AMediaFormatWrapper::writeToAMessage(sp<AMessage> &msg) const {
341    if (mAMediaFormat == NULL) {
342        msg = NULL;
343    }
344
345    if (msg == NULL) {
346        msg = new AMessage;
347    }
348    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    }
374    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    }
384    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    }
401}
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
522//////////// 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
547//////////// 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
623sp<AMediaCodecCryptoInfoWrapper> AMediaCodecCryptoInfoWrapper::Create(MetaDataBase &meta) {
624
625    uint32_t type;
626    const void *crypteddata;
627    size_t cryptedsize;
628
629    if (!meta.findData(kKeyEncryptedSizes, &type, &crypteddata, &cryptedsize)) {
630        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;
642    if (meta.findData(kKeyPlainSizes, &type, &cleardata, &clearsize)) {
643        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;
652    if (meta.findData(kKeyCryptoKey, &type, &key, &keysize)) {
653        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;
662    if (meta.findData(kKeyCryptoIV, &type, &iv, &ivsize)) {
663        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;
671    if (!meta.findInt32(kKeyCryptoMode, &mode)) {
672        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,
908    const sp<ANativeWindowWrapper> &nww,
909    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(),
918            (nww == NULL ? NULL : nww->getANativeWindow()),
919            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
1039status_t AMediaCodecWrapper::setOutputSurface(const sp<ANativeWindowWrapper> &nww) {
1040    if (mAMediaCodec == NULL) {
1041        return DEAD_OBJECT;
1042    }
1043    return translateErrorCode(
1044        AMediaCodec_setOutputSurface(mAMediaCodec,
1045                                     (nww == NULL ? NULL : nww->getANativeWindow())));
1046}
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
1064//////////// 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
1083status_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
1091AMediaExtractor *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
1110status_t AMediaExtractorWrapper::setDataSource(AMediaDataSource *source) {
1111    if (mAMediaExtractor == NULL) {
1112        return DEAD_OBJECT;
1113    }
1114    return translateErrorCode(AMediaExtractor_setDataSourceCustom(mAMediaExtractor, source));
1115}
1116
1117size_t AMediaExtractorWrapper::getTrackCount() {
1118    if (mAMediaExtractor == NULL) {
1119        return 0;
1120    }
1121    return AMediaExtractor_getTrackCount(mAMediaExtractor);
1122}
1123
1124sp<AMediaFormatWrapper> AMediaExtractorWrapper::getFormat() {
1125    if (mAMediaExtractor == NULL) {
1126        return NULL;
1127    }
1128    return new AMediaFormatWrapper(AMediaExtractor_getFileFormat(mAMediaExtractor));
1129}
1130
1131sp<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
1152status_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
1172ssize_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
1179ssize_t AMediaExtractorWrapper::getSampleSize() {
1180    if (mAMediaExtractor == NULL) {
1181        return 0;
1182    }
1183    return AMediaExtractor_getSampleSize(mAMediaExtractor);
1184}
1185
1186uint32_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
1207status_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
1216int64_t AMediaExtractorWrapper::getCachedDuration() {
1217    if (mAMediaExtractor == NULL) {
1218        return -1;
1219    }
1220    return AMediaExtractor_getCachedDuration(mAMediaExtractor);
1221}
1222
1223bool AMediaExtractorWrapper::advance() {
1224    if (mAMediaExtractor == NULL) {
1225        return false;
1226    }
1227    return AMediaExtractor_advance(mAMediaExtractor);
1228}
1229
1230status_t AMediaExtractorWrapper::seekTo(int64_t seekPosUs, MediaSource::ReadOptions::SeekMode mode) {
1231    if (mAMediaExtractor == NULL) {
1232        return DEAD_OBJECT;
1233    }
1234
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);
1251}
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
1267ssize_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
1306}  // namespace android
1307