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

Commit 0e043b67 authored by Marco Nelissen's avatar Marco Nelissen
Browse files

C-ify MediaBuffer 

Bug: 111407253
Test: CTS, manual
Change-Id: Id20094f23d9d0dc0ec23127bbedc62c6e29944bd
parent b6670e3d

include/media/MediaExtractorPluginApi.h

+58 −0
Original line number Diff line number Diff line
@@ -69,6 +69,40 @@ struct CMediaTrackV2 { 
    bool     (*supportsNonBlockingRead)(void *data);

};



/**

 * only use CMediaBufferV3 allocated from the CMediaBufferGroupV3 that is

 * provided to CMediaTrack::start()

 */

struct CMediaBufferV3 {

    void *handle;

    void (*release)(void *handle);

    void* (*data)(void *handle);

    size_t (*size)(void *handle);

    size_t (*range_offset)(void *handle);

    size_t (*range_length)(void *handle);

    void (*set_range)(void *handle, size_t offset, size_t length);

    AMediaFormat* (*meta_data)(void *handle);

};



struct CMediaBufferGroupV3 {

    void *handle;

    bool (*init)(void *handle, size_t buffers, size_t buffer_size, size_t growthLimit);

    void (*add_buffer)(void *handle, size_t size);

    media_status_t (*acquire_buffer)(void *handle,

            CMediaBufferV3 **buffer, bool nonBlocking, size_t requestedSize);

    bool (*has_buffers)(void *handle);

};



struct CMediaTrackV3 {

    void *data;

    void (*free)(void *data);



    media_status_t (*start)(void *data, CMediaBufferGroupV3 *bufferGroup);

    media_status_t (*stop)(void *data);

    media_status_t (*getFormat)(void *data, AMediaFormat *format);

    media_status_t (*read)(void *data, CMediaBufferV3 **buffer, uint32_t options, int64_t seekPosUs);

    bool     (*supportsNonBlockingRead)(void *data);

};



struct CMediaExtractorV1 {

    void *data;
@@ -104,6 +138,23 @@ struct CMediaExtractorV2 { 
    const char * (*name)(void *data);

};



struct CMediaExtractorV3 {

    void *data;



    void (*free)(void *data);

    size_t (*countTracks)(void *data);

    CMediaTrackV3* (*getTrack)(void *data, size_t index);

    media_status_t (*getTrackMetaData)(

            void *data,

            AMediaFormat *meta,

            size_t index, uint32_t flags);



    media_status_t (*getMetaData)(void *data, AMediaFormat *meta);

    uint32_t (*flags)(void *data);

    media_status_t (*setMediaCas)(void *data, const uint8_t* casToken, size_t size);

    const char * (*name)(void *data);

};



typedef CMediaExtractorV1* (*CreatorFuncV1)(CDataSource *source, void *meta);

typedef void (*FreeMetaFunc)(void *meta);
@@ -121,6 +172,12 @@ typedef CreatorFuncV2 (*SnifferFuncV2)( 
        CDataSource *source, float *confidence,

        void **meta, FreeMetaFunc *freeMeta);



typedef CMediaExtractorV3* (*CreatorFuncV3)(CDataSource *source, void *meta);



typedef CreatorFuncV3 (*SnifferFuncV3)(

        CDataSource *source, float *confidence,

        void **meta, FreeMetaFunc *freeMeta);



typedef CMediaExtractorV1 CMediaExtractor;

typedef CreatorFuncV1 CreatorFunc;
@@ -148,6 +205,7 @@ struct ExtractorDef { 
    union {

        SnifferFuncV1 v1;

        SnifferFuncV2 v2;

        SnifferFuncV3 v3;

    } sniff;

};

include/media/MediaExtractorPluginHelper.h

+255 −1
Original line number Diff line number Diff line
@@ -20,12 +20,13 @@ 


#include <arpa/inet.h>

#include <stdio.h>

#include <vector>

#include <map>



#include <utils/Errors.h>

#include <utils/Log.h>

#include <utils/RefBase.h>

#include <media/MediaExtractorPluginApi.h>

#include <media/NdkMediaFormat.h>



namespace android {
@@ -171,6 +172,176 @@ inline CMediaTrackV2 *wrapV2(MediaTrackHelperV2 *track) { 
    return wrapper;

}



class MediaTrackHelperV3;



class MediaBufferHelperV3 {

private:

    friend CMediaTrackV3 *wrapV3(MediaTrackHelperV3 *);

    CMediaBufferV3 *mBuffer;

public:

    MediaBufferHelperV3(CMediaBufferV3 *buf) {

        mBuffer = buf;

    }



    ~MediaBufferHelperV3() {}



    void release() {

        mBuffer->release(mBuffer->handle);

    }



    void* data() {

        return mBuffer->data(mBuffer->handle);

    }



    size_t size() {

        return mBuffer->size(mBuffer->handle);

    }



    size_t range_offset() {

        return mBuffer->range_offset(mBuffer->handle);

    }



    size_t range_length() {

        return mBuffer->range_length(mBuffer->handle);

    }



    void set_range(size_t offset, size_t length) {

        mBuffer->set_range(mBuffer->handle, offset, length);

    }

    AMediaFormat *meta_data() {

        return mBuffer->meta_data(mBuffer->handle);

    }

};



class MediaBufferGroupHelperV3 {

private:

    CMediaBufferGroupV3 *mGroup;

    std::map<CMediaBufferV3*, MediaBufferHelperV3*> mBufferHelpers;

public:

    MediaBufferGroupHelperV3(CMediaBufferGroupV3 *group) {

        mGroup = group;

    }

    ~MediaBufferGroupHelperV3() {

        // delete all entries in map

        ALOGV("buffergroup %p map has %zu entries", this, mBufferHelpers.size());

        for (auto it = mBufferHelpers.begin(); it != mBufferHelpers.end(); ++it) {

            delete it->second;

        }

    }

    bool init(size_t buffers, size_t buffer_size, size_t growthLimit = 0) {

        return mGroup->init(mGroup->handle, buffers, buffer_size, growthLimit);

    }

    void add_buffer(size_t size) {

        mGroup->add_buffer(mGroup->handle, size);

    }

    media_status_t acquire_buffer(

            MediaBufferHelperV3 **buffer, bool nonBlocking = false, size_t requestedSize = 0) {

        CMediaBufferV3 *buf = nullptr;

        media_status_t ret =

                mGroup->acquire_buffer(mGroup->handle, &buf, nonBlocking, requestedSize);

        if (ret == AMEDIA_OK && buf != nullptr) {

            auto helper = mBufferHelpers.find(buf);

            if (helper == mBufferHelpers.end()) {

                MediaBufferHelperV3* newHelper = new MediaBufferHelperV3(buf);

                mBufferHelpers.insert(std::make_pair(buf, newHelper));

                *buffer = newHelper;

            } else {

                *buffer = helper->second;

            }

        } else {

            *buffer = nullptr;

        }

        return ret;

    }

    bool has_buffers() {

        return mGroup->has_buffers(mGroup->handle);

    }

};



class MediaTrackHelperV3 {

public:

    MediaTrackHelperV3() : mBufferGroup(nullptr) {

    }

    virtual ~MediaTrackHelperV3() {

        delete mBufferGroup;

    }

    virtual media_status_t start() = 0;

    virtual media_status_t stop() = 0;

    virtual media_status_t getFormat(AMediaFormat *format) = 0;



    class ReadOptions {

    public:

        enum SeekMode : int32_t {

            SEEK_PREVIOUS_SYNC,

            SEEK_NEXT_SYNC,

            SEEK_CLOSEST_SYNC,

            SEEK_CLOSEST,

            SEEK_FRAME_INDEX,

        };



        ReadOptions(uint32_t options, int64_t seekPosUs) {

            mOptions = options;

            mSeekPosUs = seekPosUs;

        }

        bool getSeekTo(int64_t *time_us, SeekMode *mode) const {

            if ((mOptions & CMediaTrackReadOptions::SEEK) == 0) {

                return false;

            }

            *time_us = mSeekPosUs;

            *mode = (SeekMode) (mOptions & 7);

            return true;

        }

        bool getNonBlocking() const {

            return mOptions & CMediaTrackReadOptions::NONBLOCKING;

        }

    private:

        uint32_t mOptions;

        int64_t mSeekPosUs;

    };



    virtual media_status_t read(

            MediaBufferHelperV3 **buffer, const ReadOptions *options = NULL) = 0;

    virtual bool supportsNonBlockingRead() { return false; }

protected:

    friend CMediaTrackV3 *wrapV3(MediaTrackHelperV3 *track);

    MediaBufferGroupHelperV3 *mBufferGroup;

};



inline CMediaTrackV3 *wrapV3(MediaTrackHelperV3 *track) {

    CMediaTrackV3 *wrapper = (CMediaTrackV3*) malloc(sizeof(CMediaTrackV3));

    wrapper->data = track;

    wrapper->free = [](void *data) -> void {

        delete (MediaTrackHelperV3*)(data);

    };

    wrapper->start = [](void *data, CMediaBufferGroupV3 *bufferGroup) -> media_status_t {

        if (((MediaTrackHelperV3*)data)->mBufferGroup) {

            // this shouldn't happen, but handle it anyway

            delete ((MediaTrackHelperV3*)data)->mBufferGroup;

        }

        ((MediaTrackHelperV3*)data)->mBufferGroup = new MediaBufferGroupHelperV3(bufferGroup);

        return ((MediaTrackHelperV3*)data)->start();

    };

    wrapper->stop = [](void *data) -> media_status_t {

        return ((MediaTrackHelperV3*)data)->stop();

    };

    wrapper->getFormat = [](void *data, AMediaFormat *meta) -> media_status_t {

        return ((MediaTrackHelperV3*)data)->getFormat(meta);

    };

    wrapper->read = [](void *data, CMediaBufferV3 **buffer,  uint32_t options, int64_t seekPosUs)

            -> media_status_t {

        MediaTrackHelperV3::ReadOptions opts(options, seekPosUs);

        MediaBufferHelperV3 *buf = NULL;

        media_status_t ret = ((MediaTrackHelperV3*)data)->read(&buf, &opts);

        if (ret == AMEDIA_OK && buf != nullptr) {

            *buffer = buf->mBuffer;

        }

        return ret;

    };

    wrapper->supportsNonBlockingRead = [](void *data) -> bool {

                return ((MediaTrackHelperV3*)data)->supportsNonBlockingRead();

    };

    return wrapper;

}





// extractor plugins can derive from this class which looks remarkably
@@ -341,6 +512,89 @@ inline CMediaExtractorV2 *wrapV2(MediaExtractorPluginHelperV2 *extractor) { 
    return wrapper;

}



class MediaExtractorPluginHelperV3

{

public:

    virtual ~MediaExtractorPluginHelperV3() {}

    virtual size_t countTracks() = 0;

    virtual MediaTrackHelperV3 *getTrack(size_t index) = 0;



    enum GetTrackMetaDataFlags {

        kIncludeExtensiveMetaData = 1

    };

    virtual media_status_t getTrackMetaData(

            AMediaFormat *meta,

            size_t index, uint32_t flags = 0) = 0;



    // Return container specific meta-data. The default implementation

    // returns an empty metadata object.

    virtual media_status_t getMetaData(AMediaFormat *meta) = 0;



    enum Flags {

        CAN_SEEK_BACKWARD  = 1,  // the "seek 10secs back button"

        CAN_SEEK_FORWARD   = 2,  // the "seek 10secs forward button"

        CAN_PAUSE          = 4,

        CAN_SEEK           = 8,  // the "seek bar"

    };



    // If subclasses do _not_ override this, the default is

    // CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK | CAN_PAUSE

    virtual uint32_t flags() const {

        return CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK | CAN_PAUSE;

    };



    virtual media_status_t setMediaCas(const uint8_t* /*casToken*/, size_t /*size*/) {

        return AMEDIA_ERROR_INVALID_OPERATION;

    }



    virtual const char * name() { return "<unspecified>"; }



protected:

    MediaExtractorPluginHelperV3() {}



private:

    MediaExtractorPluginHelperV3(const MediaExtractorPluginHelperV2 &);

    MediaExtractorPluginHelperV3 &operator=(const MediaExtractorPluginHelperV2 &);

};



inline CMediaExtractorV3 *wrapV3(MediaExtractorPluginHelperV3 *extractor) {

    CMediaExtractorV3 *wrapper = (CMediaExtractorV3*) malloc(sizeof(CMediaExtractorV3));

    wrapper->data = extractor;

    wrapper->free = [](void *data) -> void {

        delete (MediaExtractorPluginHelperV3*)(data);

    };

    wrapper->countTracks = [](void *data) -> size_t {

        return ((MediaExtractorPluginHelperV3*)data)->countTracks();

    };

    wrapper->getTrack = [](void *data, size_t index) -> CMediaTrackV3* {

        return wrapV3(((MediaExtractorPluginHelperV3*)data)->getTrack(index));

    };

    wrapper->getTrackMetaData = [](

            void *data,

            AMediaFormat *meta,

            size_t index, uint32_t flags) -> media_status_t {

        return ((MediaExtractorPluginHelperV3*)data)->getTrackMetaData(meta, index, flags);

    };

    wrapper->getMetaData = [](

            void *data,

            AMediaFormat *meta) -> media_status_t {

        return ((MediaExtractorPluginHelperV3*)data)->getMetaData(meta);

    };

    wrapper->flags = [](

            void *data) -> uint32_t {

        return ((MediaExtractorPluginHelperV3*)data)->flags();

    };

    wrapper->setMediaCas = [](

            void *data, const uint8_t *casToken, size_t size) -> media_status_t {

        return ((MediaExtractorPluginHelperV3*)data)->setMediaCas(casToken, size);

    };

    wrapper->name = [](

            void *data) -> const char * {

        return ((MediaExtractorPluginHelperV3*)data)->name();

    };

    return wrapper;

}



/* adds some convience methods */

class DataSourceHelper {

public:

include/media/MediaTrack.h

+20 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
#include <binder/IMemory.h>

#include <binder/MemoryDealer.h>

#include <media/MediaExtractorPluginApi.h>

#include <media/stagefright/MediaBufferGroup.h>

#include <media/stagefright/MediaErrors.h>

#include <media/stagefright/MetaData.h>

#include <media/MediaExtractorPluginApi.h>
@@ -175,6 +176,25 @@ private: 
    CMediaTrackV2 *wrapper;

};



class MediaTrackCUnwrapperV3 : public MediaTrack {

public:

    explicit MediaTrackCUnwrapperV3(CMediaTrackV3 *wrapper);



    virtual status_t start();

    virtual status_t stop();

    virtual status_t getFormat(MetaDataBase& format);

    virtual status_t read(MediaBufferBase **buffer, const ReadOptions *options = NULL);



    virtual bool supportNonblockingRead();



protected:

    virtual ~MediaTrackCUnwrapperV3();



private:

    CMediaTrackV3 *wrapper;

    MediaBufferGroup *bufferGroup;

};



}  // namespace android



#endif  // MEDIA_SOURCE_BASE_H_

include/media/NdkMediaErrorPriv.h

+2 −4
Original line number Diff line number Diff line
@@ -20,10 +20,8 @@ 
#include <media/NdkMediaError.h>

#include <utils/Errors.h>



using namespace android;

media_status_t translate_error(android::status_t);



media_status_t translate_error(status_t);



status_t reverse_translate_error(media_status_t);

android::status_t reverse_translate_error(media_status_t);



#endif // _NDK_MEDIA_ERROR_PRIV_H

include/media/NdkMediaFormatPriv.h

+11 −8
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 
#ifndef _NDK_MEDIA_FORMAT_PRIV_H

#define _NDK_MEDIA_FORMAT_PRIV_H



#include <utils/KeyedVector.h>

#include <utils/String8.h>

#include <utils/StrongPointer.h>

#include <media/stagefright/foundation/AMessage.h>
@@ -35,20 +36,22 @@ 
extern "C" {

#endif



using namespace android;



struct AMediaFormat {

    sp<AMessage> mFormat;

    String8 mDebug;

    KeyedVector<String8, String8> mStringCache;

    android::sp<android::AMessage> mFormat;

    android::String8 mDebug;

    android::KeyedVector<android::String8, android::String8> mStringCache;

};



AMediaFormat* AMediaFormat_fromMsg(const void*);

void AMediaFormat_getFormat(const AMediaFormat* mData, void* dest);



#ifdef __cplusplus

} // extern "C"

#endif



namespace android {



AMediaFormat* AMediaFormat_fromMsg(sp<AMessage> *);

void AMediaFormat_getFormat(const AMediaFormat* mData, sp<AMessage> *dest);



} // namespace android



#endif // _NDK_MEDIA_FORMAT_PRIV_H