Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b54c728e authored by Marco Nelissen's avatar Marco Nelissen
Browse files

Convert AACExtractor to use AMediaFormat 

Bug: 111407253
Test: manual

Change-Id: I99ec13444aa6b6306507397b43be5e6e36c2713e
parent 4cc873cc

media/extractors/aac/AACExtractor.cpp

+21 −20
Original line number Diff line number Diff line
@@ -26,24 +26,23 @@ 
#include <media/stagefright/MediaBufferGroup.h>

#include <media/stagefright/MediaDefs.h>

#include <media/stagefright/MediaErrors.h>

#include <media/stagefright/MetaData.h>

#include <media/stagefright/MetaDataUtils.h>

#include <utils/String8.h>



namespace android {



class AACSource : public MediaTrackHelper {

class AACSource : public MediaTrackHelperV2 {

public:

    AACSource(

            DataSourceHelper *source,

            MetaDataBase &meta,

            AMediaFormat *meta,

            const Vector<uint64_t> &offset_vector,

            int64_t frame_duration_us);



    virtual status_t start();

    virtual status_t stop();



    virtual status_t getFormat(MetaDataBase&);

    virtual status_t getFormat(AMediaFormat*);



    virtual status_t read(

            MediaBufferBase **buffer, const ReadOptions *options = NULL);
@@ -54,7 +53,7 @@ protected: 
private:

    static const size_t kMaxFrameSize;

    DataSourceHelper *mDataSource;

    MetaDataBase mMeta;

    AMediaFormat *mMeta;



    off64_t mOffset;

    int64_t mCurrentTimeUs;
@@ -150,6 +149,7 @@ AACExtractor::AACExtractor( 
    }

    channel = (header[0] & 0x1) << 2 | (header[1] >> 6);



    mMeta = AMediaFormat_new();

    MakeAACCodecSpecificData(mMeta, profile, sf_index, channel);



    off64_t streamSize, numFrames = 0;
@@ -173,19 +173,20 @@ AACExtractor::AACExtractor( 
        // Round up and get the duration

        mFrameDurationUs = (1024 * 1000000ll + (sr - 1)) / sr;

        duration = numFrames * mFrameDurationUs;

        mMeta.setInt64(kKeyDuration, duration);

        AMediaFormat_setInt64(mMeta, AMEDIAFORMAT_KEY_DURATION, duration);

    }



    mInitCheck = OK;

}



AACExtractor::~AACExtractor() {

    AMediaFormat_delete(mMeta);

}



status_t AACExtractor::getMetaData(MetaDataBase &meta) {

    meta.clear();

status_t AACExtractor::getMetaData(AMediaFormat *meta) {

    AMediaFormat_clear(meta);

    if (mInitCheck == OK) {

        meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC_ADTS);

        AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_AAC_ADTS);

    }



    return OK;
@@ -195,7 +196,7 @@ size_t AACExtractor::countTracks() { 
    return mInitCheck == OK ? 1 : 0;

}



MediaTrackHelper *AACExtractor::getTrack(size_t index) {

MediaTrackHelperV2 *AACExtractor::getTrack(size_t index) {

    if (mInitCheck != OK || index != 0) {

        return NULL;

    }
@@ -203,12 +204,12 @@ MediaTrackHelper *AACExtractor::getTrack(size_t index) { 
    return new AACSource(mDataSource, mMeta, mOffsetVector, mFrameDurationUs);

}



status_t AACExtractor::getTrackMetaData(MetaDataBase &meta, size_t index, uint32_t /* flags */) {

status_t AACExtractor::getTrackMetaData(AMediaFormat *meta, size_t index, uint32_t /* flags */) {

    if (mInitCheck != OK || index != 0) {

        return UNKNOWN_ERROR;

    }



    meta = mMeta;

    AMediaFormat_copy(meta, mMeta);

    return OK;

}
@@ -219,7 +220,7 @@ const size_t AACSource::kMaxFrameSize = 8192; 


AACSource::AACSource(

        DataSourceHelper *source,

        MetaDataBase &meta,

        AMediaFormat *meta,

        const Vector<uint64_t> &offset_vector,

        int64_t frame_duration_us)

    : mDataSource(source),
@@ -265,8 +266,8 @@ status_t AACSource::stop() { 
    return OK;

}



status_t AACSource::getFormat(MetaDataBase &meta) {

    meta = mMeta;

status_t AACSource::getFormat(AMediaFormat *meta) {

    AMediaFormat_copy(meta, mMeta);

    return OK;

}
@@ -322,14 +323,14 @@ status_t AACSource::read( 


////////////////////////////////////////////////////////////////////////////////



static CMediaExtractor* CreateExtractor(

static CMediaExtractorV2* CreateExtractor(

        CDataSource *source,

        void *meta) {

    off64_t offset = *static_cast<off64_t*>(meta);

    return wrap(new AACExtractor(new DataSourceHelper(source), offset));

    return wrapV2(new AACExtractor(new DataSourceHelper(source), offset));

}



static CreatorFunc Sniff(

static CreatorFuncV2 Sniff(

        CDataSource *source, float *confidence, void **meta,

        FreeMetaFunc *freeMeta) {

    off64_t pos = 0;
@@ -389,11 +390,11 @@ extern "C" { 
__attribute__ ((visibility ("default")))

ExtractorDef GETEXTRACTORDEF() {

    return {

        EXTRACTORDEF_VERSION,

        EXTRACTORDEF_VERSION_CURRENT,

        UUID("4fd80eae-03d2-4d72-9eb9-48fa6bb54613"),

        1, // version

        "AAC Extractor",

        { Sniff }

        { .v2 = Sniff }

    };

}

media/extractors/aac/AACExtractor.h

+6 −6
Original line number Diff line number Diff line
@@ -20,7 +20,7 @@ 


#include <media/MediaExtractorPluginApi.h>

#include <media/MediaExtractorPluginHelper.h>

#include <media/stagefright/MetaDataBase.h>

#include <media/NdkMediaFormat.h>



#include <utils/Vector.h>
@@ -29,15 +29,15 @@ namespace android { 
struct AMessage;

class String8;



class AACExtractor : public MediaExtractorPluginHelper {

class AACExtractor : public MediaExtractorPluginHelperV2 {

public:

    AACExtractor(DataSourceHelper *source, off64_t offset);



    virtual size_t countTracks();

    virtual MediaTrackHelper *getTrack(size_t index);

    virtual status_t getTrackMetaData(MetaDataBase& meta, size_t index, uint32_t flags);

    virtual MediaTrackHelperV2 *getTrack(size_t index);

    virtual status_t getTrackMetaData(AMediaFormat *meta, size_t index, uint32_t flags);



    virtual status_t getMetaData(MetaDataBase& meta);

    virtual status_t getMetaData(AMediaFormat *meta);

    virtual const char * name() { return "AACExtractor"; }



protected:
@@ -45,7 +45,7 @@ protected: 


private:

    DataSourceHelper *mDataSource;

    MetaDataBase mMeta;

    AMediaFormat *mMeta;

    status_t mInitCheck;



    Vector<uint64_t> mOffsetVector;

media/extractors/aac/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ cc_library_shared { 
    shared_libs: [

        "liblog",

        "libmediaextractor",

        "libmediandk",

    ],



    static_libs: [

media/libstagefright/Android.bp

+1 −1
Original line number Diff line number Diff line
@@ -45,7 +45,7 @@ cc_library_static { 
        },

    },



    shared_libs: ["libmedia"],

    shared_libs: ["libmedia", "libmediandk"],

}



cc_library_shared {

media/libstagefright/MetaDataUtils.cpp

+57 −11
Original line number Diff line number Diff line
@@ -23,6 +23,8 @@ 
#include <media/stagefright/foundation/ABuffer.h>

#include <media/stagefright/MediaDefs.h>

#include <media/stagefright/MetaDataUtils.h>

#include <media/stagefright/Utils.h>

#include <media/NdkMediaFormat.h>



namespace android {
@@ -91,20 +93,21 @@ bool MakeAACCodecSpecificData(MetaDataBase &meta, const uint8_t *data, size_t si 
}



bool MakeAACCodecSpecificData(

        MetaDataBase &meta,

        unsigned profile, unsigned sampling_freq_index,

        unsigned channel_configuration) {

        uint8_t *csd, /* out */

        size_t *esds_size, /* in/out */

        unsigned profile, /* in */

        unsigned sampling_freq_index, /* in */

        unsigned channel_configuration, /* in */

        int32_t *sampling_rate /* out */

) {

    if(sampling_freq_index > 11u) {

        return false;

    }

    int32_t sampleRate;

    int32_t channelCount;

    static const int32_t kSamplingFreq[] = {

        96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,

        16000, 12000, 11025, 8000

    };

    sampleRate = kSamplingFreq[sampling_freq_index];

    channelCount = channel_configuration;

    *sampling_rate = kSamplingFreq[sampling_freq_index];



    static const uint8_t kStaticESDS[] = {

        0x03, 22,
@@ -127,7 +130,9 @@ bool MakeAACCodecSpecificData( 
    };



    size_t csdSize = sizeof(kStaticESDS) + 2;

    uint8_t *csd = new uint8_t[csdSize];

    if (csdSize > *esds_size) {

        return false;

    }

    memcpy(csd, kStaticESDS, sizeof(kStaticESDS));



    csd[sizeof(kStaticESDS)] =
@@ -136,13 +141,54 @@ bool MakeAACCodecSpecificData( 
    csd[sizeof(kStaticESDS) + 1] =

        ((sampling_freq_index << 7) & 0x80) | (channel_configuration << 3);



    *esds_size = csdSize;

    return true;

}



bool MakeAACCodecSpecificData(AMediaFormat *meta, unsigned profile, unsigned sampling_freq_index,

        unsigned channel_configuration) {



    if(sampling_freq_index > 11u) {

        return false;

    }



    uint8_t csd[2];

    csd[0] = ((profile + 1) << 3) | (sampling_freq_index >> 1);

    csd[1] = ((sampling_freq_index << 7) & 0x80) | (channel_configuration << 3);



    static const int32_t kSamplingFreq[] = {

        96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,

        16000, 12000, 11025, 8000

    };

    int32_t sampleRate = kSamplingFreq[sampling_freq_index];



    AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CSD_0, csd, sizeof(csd));

    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_AAC);

    AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_SAMPLE_RATE, sampleRate);

    AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_CHANNEL_COUNT, channel_configuration);



    return true;

}



bool MakeAACCodecSpecificData(

        MetaDataBase &meta,

        unsigned profile, unsigned sampling_freq_index,

        unsigned channel_configuration) {



    uint8_t csd[24];

    size_t csdSize = sizeof(csd);

    int32_t sampleRate;



    if (!MakeAACCodecSpecificData(csd, &csdSize, profile, sampling_freq_index,

            channel_configuration, &sampleRate)) {

        return false;

    }



    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);



    meta.setInt32(kKeySampleRate, sampleRate);

    meta.setInt32(kKeyChannelCount, channelCount);



    meta.setInt32(kKeyChannelCount, channel_configuration);

    meta.setData(kKeyESDS, 0, csd, csdSize);

    delete [] csd;

    return true;

}