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

Commit d48b9c77 authored by Marco Nelissen's avatar Marco Nelissen Committed by Android (Google) Code Review
Browse files

Merge "Convert AACExtractor to use AMediaFormat"

parents f78b4960 b54c728e

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;

}