Home | History | Annotate | Download | only in media 
      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 #ifndef NDK_WRAPPER_H_
     18 
     19 #define NDK_WRAPPER_H_
     20 
     21 #include <media/DataSource.h>
     22 #include <media/MediaSource.h>
     23 #include <media/NdkMediaDataSource.h>
     24 #include <media/NdkMediaError.h>
     25 #include <media/NdkMediaExtractor.h>
     26 #include <media/hardware/CryptoAPI.h>
     27 #include <media/stagefright/foundation/ABase.h>
     28 #include <media/stagefright/foundation/ABuffer.h>
     29 #include <utils/Errors.h>
     30 #include <utils/RefBase.h>
     31 
     32 struct AMediaCodec;
     33 struct AMediaCodecBufferInfo;
     34 struct AMediaCodecCryptoInfo;
     35 struct AMediaCrypto;
     36 struct AMediaDrm;
     37 struct AMediaFormat;
     38 struct AMediaExtractor;
     39 struct ANativeWindow;
     40 struct PsshInfo;
     41 
     42 namespace android {
     43 
     44 struct AMessage;
     45 class MetaData;
     46 
     47 struct AMediaFormatWrapper : public RefBase {
     48 
     49     static sp<AMediaFormatWrapper> Create(const sp<AMessage> &message);
     50 
     51     AMediaFormatWrapper();
     52     AMediaFormatWrapper(AMediaFormat *aMediaFormat);
     53 
     54     // the returned AMediaFormat is still owned by this wrapper.
     55     AMediaFormat *getAMediaFormat() const;
     56 
     57     sp<AMessage> toAMessage() const ;
     58     void writeToAMessage(sp<AMessage>&) const ;
     59     const char* toString() const ;
     60 
     61     status_t release();
     62 
     63     bool getInt32(const char *name, int32_t *out) const;
     64     bool getInt64(const char *name, int64_t *out) const;
     65     bool getFloat(const char *name, float *out) const;
     66     bool getDouble(const char *name, double *out) const;
     67     bool getSize(const char *name, size_t *out) const;
     68     bool getRect(const char *name,
     69                  int32_t *left, int32_t *top, int32_t *right, int32_t *bottom) const;
     70     bool getBuffer(const char *name, void** data, size_t *outsize) const;
     71     bool getString(const char *name, AString *out) const;
     72 
     73     void setInt32(const char* name, int32_t value);
     74     void setInt64(const char* name, int64_t value);
     75     void setFloat(const char* name, float value);
     76     void setDouble(const char *name, double value);
     77     void setSize(const char* name, size_t value);
     78     void setRect(const char* name,
     79                  int32_t left, int32_t top, int32_t right, int32_t bottom);
     80     void setString(const char* name, const AString &value);
     81     void setBuffer(const char* name, void* data, size_t size);
     82 
     83 protected:
     84     virtual ~AMediaFormatWrapper();
     85 
     86 private:
     87     AMediaFormat *mAMediaFormat;
     88 
     89     DISALLOW_EVIL_CONSTRUCTORS(AMediaFormatWrapper);
     90 };
     91 
     92 struct ANativeWindowWrapper : public RefBase {
     93     ANativeWindowWrapper(ANativeWindow *aNativeWindow);
     94 
     95     // the returned ANativeWindow is still owned by this wrapper.
     96     ANativeWindow *getANativeWindow() const;
     97 
     98     status_t release();
     99 
    100 protected:
    101     virtual ~ANativeWindowWrapper();
    102 
    103 private:
    104     ANativeWindow *mANativeWindow;
    105 
    106     DISALLOW_EVIL_CONSTRUCTORS(ANativeWindowWrapper);
    107 };
    108 
    109 struct AMediaDrmWrapper : public RefBase {
    110     AMediaDrmWrapper(const uint8_t uuid[16]);
    111     AMediaDrmWrapper(AMediaDrm *aMediaDrm);
    112 
    113     // the returned AMediaDrm is still owned by this wrapper.
    114     AMediaDrm *getAMediaDrm() const;
    115 
    116     status_t release();
    117 
    118     static bool isCryptoSchemeSupported(const uint8_t uuid[16], const char *mimeType);
    119 
    120 protected:
    121     virtual ~AMediaDrmWrapper();
    122 
    123 private:
    124     AMediaDrm *mAMediaDrm;
    125 
    126     DISALLOW_EVIL_CONSTRUCTORS(AMediaDrmWrapper);
    127 };
    128 
    129 struct AMediaCryptoWrapper : public RefBase {
    130     AMediaCryptoWrapper(const uint8_t uuid[16],
    131                         const void *initData,
    132                         size_t initDataSize);
    133     AMediaCryptoWrapper(AMediaCrypto *aMediaCrypto);
    134 
    135     // the returned AMediaCrypto is still owned by this wrapper.
    136     AMediaCrypto *getAMediaCrypto() const;
    137 
    138     status_t release();
    139 
    140     bool isCryptoSchemeSupported(const uint8_t uuid[16]);
    141 
    142     bool requiresSecureDecoderComponent(const char *mime);
    143 
    144 protected:
    145     virtual ~AMediaCryptoWrapper();
    146 
    147 private:
    148     AMediaCrypto *mAMediaCrypto;
    149 
    150     DISALLOW_EVIL_CONSTRUCTORS(AMediaCryptoWrapper);
    151 };
    152 
    153 struct AMediaCodecCryptoInfoWrapper : public RefBase {
    154     static sp<AMediaCodecCryptoInfoWrapper> Create(MetaDataBase &meta);
    155 
    156     AMediaCodecCryptoInfoWrapper(int numsubsamples,
    157                                  uint8_t key[16],
    158                                  uint8_t iv[16],
    159                                  CryptoPlugin::Mode mode,
    160                                  size_t *clearbytes,
    161                                  size_t *encryptedbytes);
    162     AMediaCodecCryptoInfoWrapper(AMediaCodecCryptoInfo *aMediaCodecCryptoInfo);
    163 
    164     // the returned AMediaCryptoInfo is still owned by this wrapper.
    165     AMediaCodecCryptoInfo *getAMediaCodecCryptoInfo() const;
    166 
    167     status_t release();
    168 
    169     void setPattern(CryptoPlugin::Pattern *pattern);
    170 
    171     size_t getNumSubSamples();
    172 
    173     status_t getKey(uint8_t *dst);
    174 
    175     status_t getIV(uint8_t *dst);
    176 
    177     CryptoPlugin::Mode getMode();
    178 
    179     status_t getClearBytes(size_t *dst);
    180 
    181     status_t getEncryptedBytes(size_t *dst);
    182 
    183 protected:
    184     virtual ~AMediaCodecCryptoInfoWrapper();
    185 
    186 private:
    187     AMediaCodecCryptoInfo *mAMediaCodecCryptoInfo;
    188 
    189     DISALLOW_EVIL_CONSTRUCTORS(AMediaCodecCryptoInfoWrapper);
    190 };
    191 
    192 struct AMediaCodecWrapper : public RefBase {
    193     enum {
    194         CB_INPUT_AVAILABLE = 1,
    195         CB_OUTPUT_AVAILABLE = 2,
    196         CB_ERROR = 3,
    197         CB_OUTPUT_FORMAT_CHANGED = 4,
    198     };
    199 
    200     static sp<AMediaCodecWrapper> CreateCodecByName(const AString &name);
    201     static sp<AMediaCodecWrapper> CreateDecoderByType(const AString &mimeType);
    202 
    203     static void OnInputAvailableCB(AMediaCodec *codec,
    204                                    void *userdata,
    205                                    int32_t index);
    206     static void OnOutputAvailableCB(AMediaCodec *codec,
    207                                     void *userdata,
    208                                     int32_t index,
    209                                     AMediaCodecBufferInfo *bufferInfo);
    210     static void OnFormatChangedCB(AMediaCodec *codec,
    211                                   void *userdata,
    212                                   AMediaFormat *format);
    213     static void OnErrorCB(AMediaCodec *codec,
    214                           void *userdata,
    215                           media_status_t err,
    216                           int32_t actionCode,
    217                           const char *detail);
    218 
    219     AMediaCodecWrapper(AMediaCodec *aMediaCodec);
    220 
    221     // the returned AMediaCodec is still owned by this wrapper.
    222     AMediaCodec *getAMediaCodec() const;
    223 
    224     status_t release();
    225 
    226     status_t getName(AString* outComponentName) const;
    227 
    228     status_t configure(
    229             const sp<AMediaFormatWrapper> &format,
    230             const sp<ANativeWindowWrapper> &nww,
    231             const sp<AMediaCryptoWrapper> &crypto,
    232             uint32_t flags);
    233 
    234     status_t setCallback(const sp<AMessage> &callback);
    235 
    236     status_t releaseCrypto();
    237 
    238     status_t start();
    239     status_t stop();
    240     status_t flush();
    241 
    242     uint8_t* getInputBuffer(size_t idx, size_t *out_size);
    243     uint8_t* getOutputBuffer(size_t idx, size_t *out_size);
    244 
    245     status_t queueInputBuffer(
    246             size_t idx,
    247             size_t offset,
    248             size_t size,
    249             uint64_t time,
    250             uint32_t flags);
    251 
    252     status_t queueSecureInputBuffer(
    253             size_t idx,
    254             size_t offset,
    255             sp<AMediaCodecCryptoInfoWrapper> &codecCryptoInfo,
    256             uint64_t time,
    257             uint32_t flags);
    258 
    259     sp<AMediaFormatWrapper> getOutputFormat();
    260     sp<AMediaFormatWrapper> getInputFormat();
    261 
    262     status_t releaseOutputBuffer(size_t idx, bool render);
    263 
    264     status_t setOutputSurface(const sp<ANativeWindowWrapper> &nww);
    265 
    266     status_t releaseOutputBufferAtTime(size_t idx, int64_t timestampNs);
    267 
    268     status_t setParameters(const sp<AMediaFormatWrapper> &params);
    269 
    270 protected:
    271     virtual ~AMediaCodecWrapper();
    272 
    273 private:
    274     AMediaCodec *mAMediaCodec;
    275 
    276     sp<AMessage> mCallback;
    277 
    278     DISALLOW_EVIL_CONSTRUCTORS(AMediaCodecWrapper);
    279 };
    280 
    281 struct AMediaExtractorWrapper : public RefBase {
    282 
    283     AMediaExtractorWrapper(AMediaExtractor *aMediaExtractor);
    284 
    285     // the returned AMediaExtractor is still owned by this wrapper.
    286     AMediaExtractor *getAMediaExtractor() const;
    287 
    288     status_t release();
    289 
    290     status_t disconnect();
    291 
    292     status_t setDataSource(int fd, off64_t offset, off64_t length);
    293 
    294     status_t setDataSource(const char *location);
    295 
    296     status_t setDataSource(AMediaDataSource *);
    297 
    298     size_t getTrackCount();
    299 
    300     sp<AMediaFormatWrapper> getFormat();
    301 
    302     sp<AMediaFormatWrapper> getTrackFormat(size_t idx);
    303 
    304     status_t selectTrack(size_t idx);
    305 
    306     status_t unselectTrack(size_t idx);
    307 
    308     status_t selectSingleTrack(size_t idx);
    309 
    310     ssize_t readSampleData(const sp<ABuffer> &buffer);
    311 
    312     ssize_t getSampleSize();
    313 
    314     uint32_t getSampleFlags();
    315 
    316     int getSampleTrackIndex();
    317 
    318     int64_t getSampleTime();
    319 
    320     status_t getSampleFormat(sp<AMediaFormatWrapper> &formatWrapper);
    321 
    322     int64_t getCachedDuration();
    323 
    324     bool advance();
    325 
    326     status_t seekTo(int64_t seekPosUs, MediaSource::ReadOptions::SeekMode mode);
    327 
    328     // the returned PsshInfo is still owned by this wrapper.
    329     PsshInfo* getPsshInfo();
    330 
    331     sp<AMediaCodecCryptoInfoWrapper> getSampleCryptoInfo();
    332 
    333 protected:
    334     virtual ~AMediaExtractorWrapper();
    335 
    336 private:
    337     AMediaExtractor *mAMediaExtractor;
    338 
    339     DISALLOW_EVIL_CONSTRUCTORS(AMediaExtractorWrapper);
    340 };
    341 
    342 struct AMediaDataSourceWrapper : public RefBase {
    343 
    344     static status_t translate_error(media_status_t err);
    345 
    346     static ssize_t AMediaDataSourceWrapper_getSize(void *userdata);
    347 
    348     static ssize_t AMediaDataSourceWrapper_readAt(void *userdata, off64_t offset, void * buf, size_t size);
    349 
    350     static void AMediaDataSourceWrapper_close(void *userdata);
    351 
    352     AMediaDataSourceWrapper(const sp<DataSource> &dataSource);
    353 
    354     AMediaDataSource *getAMediaDataSource();
    355 
    356 protected:
    357     virtual ~AMediaDataSourceWrapper();
    358 
    359 private:
    360     sp<DataSource> mDataSource;
    361 
    362     AMediaDataSource *mAMediaDataSource;
    363 
    364     DISALLOW_EVIL_CONSTRUCTORS(AMediaDataSourceWrapper);
    365 };
    366 
    367 }  // namespace android
    368 
    369 #endif  // NDK_WRAPPER_H_
    370