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

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

Merge "C-ify MediaTrack"

parents b5adce51 2a3363ad

include/media/MediaExtractorPluginApi.h

+23 −1
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ namespace android { 


struct MediaTrack;

class MetaDataBase;

class MediaBufferBase;



extern "C" {
@@ -34,12 +35,33 @@ struct CDataSource { 
    void *handle;

};



enum CMediaTrackReadOptions : uint32_t {

    SEEK_PREVIOUS_SYNC = 0,

    SEEK_NEXT_SYNC = 1,

    SEEK_CLOSEST_SYNC = 2,

    SEEK_CLOSEST = 3,

    SEEK_FRAME_INDEX = 4,

    SEEK = 8,

    NONBLOCKING = 16

};



struct CMediaTrack {

    void *data;

    void (*free)(void *data);



    status_t (*start)(void *data, MetaDataBase *params);

    status_t (*stop)(void *data);

    status_t (*getFormat)(void *data, MetaDataBase &format);

    status_t (*read)(void *data, MediaBufferBase **buffer, uint32_t options, int64_t seekPosUs);

    bool     (*supportsNonBlockingRead)(void *data);

};



struct CMediaExtractor {

    void *data;



    void (*free)(void *data);

    size_t (*countTracks)(void *data);

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

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

    status_t (*getTrackMetaData)(

            void *data,

            MetaDataBase& meta,

include/media/MediaExtractorPluginHelper.h

+72 −3
Original line number Diff line number Diff line
@@ -33,6 +33,75 @@ class DataSourceBase; 
class MetaDataBase;

struct MediaTrack;





class MediaTrackHelper {

public:

    virtual ~MediaTrackHelper() {};

    virtual status_t start(MetaDataBase *params = NULL) = 0;

    virtual status_t stop() = 0;

    virtual status_t getFormat(MetaDataBase& 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 status_t read(

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

    virtual bool supportsNonBlockingRead() { return false; }

};



inline CMediaTrack *wrap(MediaTrackHelper *track) {

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

    wrapper->data = track;

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

        delete (MediaTrackHelper*)(data);

    };

    wrapper->start = [](void *data, MetaDataBase *params) -> status_t {

        return ((MediaTrackHelper*)data)->start(params);

    };

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

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

    };

    wrapper->getFormat = [](void *data, MetaDataBase &meta) -> status_t {

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

    };

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

            -> status_t {

        MediaTrackHelper::ReadOptions opts(options, seekPosUs);

        return ((MediaTrackHelper*)data)->read(buffer, &opts);

    };

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

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

    };

    return wrapper;

}



// extractor plugins can derive from this class which looks remarkably

// like MediaExtractor and can be easily wrapped in the required C API

class MediaExtractorPluginHelper
@@ -40,7 +109,7 @@ class MediaExtractorPluginHelper 
public:

    virtual ~MediaExtractorPluginHelper() {}

    virtual size_t countTracks() = 0;

    virtual MediaTrack *getTrack(size_t index) = 0;

    virtual MediaTrackHelper *getTrack(size_t index) = 0;



    enum GetTrackMetaDataFlags {

        kIncludeExtensiveMetaData = 1
@@ -89,8 +158,8 @@ inline CMediaExtractor *wrap(MediaExtractorPluginHelper *extractor) { 
    wrapper->countTracks = [](void *data) -> size_t {

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

    };

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

        return ((MediaExtractorPluginHelper*)data)->getTrack(index);

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

        return wrap(((MediaExtractorPluginHelper*)data)->getTrack(index));

    };

    wrapper->getTrackMetaData = [](

            void *data,

include/media/MediaTrack.h

deleted120000 → 0
+151 −1
Original line number Diff line number Diff line 
../../media/libmediaextractor/include/media/MediaTrack.h
 
 No newline at end of file

include/media/MediaTrack.h

0 → 100644
+151 −1
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef MEDIA_SOURCE_BASE_H_



#define MEDIA_SOURCE_BASE_H_



#include <sys/types.h>



#include <binder/IMemory.h>

#include <binder/MemoryDealer.h>

#include <media/stagefright/MediaErrors.h>

#include <media/stagefright/MetaData.h>

#include <media/MediaExtractorPluginApi.h>

#include <utils/Log.h>

#include <utils/RefBase.h>

#include <utils/Vector.h>



namespace android {



class MediaBufferBase;

struct CMediaTrack;



class SourceBaseAllocTracker {

public:

    SourceBaseAllocTracker() {

        ALOGD("sourcebase allocated: %p", this);

    }

    virtual ~SourceBaseAllocTracker() {

        ALOGD("sourcebase freed: %p", this);

    }

};



struct MediaTrack

//    : public SourceBaseAllocTracker

{

    MediaTrack();



    // To be called before any other methods on this object, except

    // getFormat().

    virtual status_t start(MetaDataBase *params = NULL) = 0;



    // Any blocking read call returns immediately with a result of NO_INIT.

    // It is an error to call any methods other than start after this call

    // returns. Any buffers the object may be holding onto at the time of

    // the stop() call are released.

    // Also, it is imperative that any buffers output by this object and

    // held onto by callers be released before a call to stop() !!!

    virtual status_t stop() = 0;



    // Returns the format of the data output by this media track.

    virtual status_t getFormat(MetaDataBase& format) = 0;



    // Options that modify read() behaviour. The default is to

    // a) not request a seek

    // b) not be late, i.e. lateness_us = 0

    struct ReadOptions {

        enum SeekMode : int32_t {

            SEEK_PREVIOUS_SYNC = CMediaTrackReadOptions::SEEK_PREVIOUS_SYNC,

            SEEK_NEXT_SYNC = CMediaTrackReadOptions::SEEK_NEXT_SYNC,

            SEEK_CLOSEST_SYNC = CMediaTrackReadOptions::SEEK_CLOSEST_SYNC,

            SEEK_CLOSEST = CMediaTrackReadOptions::SEEK_CLOSEST,

            SEEK_FRAME_INDEX = CMediaTrackReadOptions::SEEK_FRAME_INDEX,

        };



        ReadOptions();



        // Reset everything back to defaults.

        void reset();



        void setSeekTo(int64_t time_us, SeekMode mode = SEEK_CLOSEST_SYNC);

        void clearSeekTo();

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



        void setNonBlocking();

        void clearNonBlocking();

        bool getNonBlocking() const;



        // Used to clear all non-persistent options for multiple buffer reads.

        void clearNonPersistent() {

            clearSeekTo();

        }



    private:

        enum Options {

            kSeekTo_Option      = 1,

        };



        uint32_t mOptions;

        int64_t mSeekTimeUs;

        SeekMode mSeekMode;

        bool mNonBlocking;

    } __attribute__((packed)); // sent through Binder



    // Returns a new buffer of data. Call blocks until a

    // buffer is available, an error is encountered of the end of the stream

    // is reached.

    // End of stream is signalled by a result of ERROR_END_OF_STREAM.

    // A result of INFO_FORMAT_CHANGED indicates that the format of this

    // MediaSource has changed mid-stream, the client can continue reading

    // but should be prepared for buffers of the new configuration.

    virtual status_t read(

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



    // Returns true if |read| supports nonblocking option, otherwise false.

    // |readMultiple| if supported, always allows the nonblocking option.

    virtual bool supportNonblockingRead() {

        return false;

    }



    virtual ~MediaTrack();



private:

    MediaTrack(const MediaTrack &);

    MediaTrack &operator=(const MediaTrack &);

};



class MediaTrackCUnwrapper : public MediaTrack {

public:

    explicit MediaTrackCUnwrapper(CMediaTrack *wrapper);



    virtual status_t start(MetaDataBase *params = NULL);

    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 ~MediaTrackCUnwrapper();



private:

    CMediaTrack *wrapper;

};



}  // namespace android



#endif  // MEDIA_SOURCE_BASE_H_

media/extractors/aac/AACExtractor.cpp

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


#include "AACExtractor.h"

#include <media/MediaExtractorPluginApi.h>

#include <media/MediaTrack.h>

#include <media/stagefright/foundation/ABuffer.h>

#include <media/stagefright/foundation/AMessage.h>

#include <media/stagefright/foundation/ADebug.h>
@@ -33,7 +32,7 @@ 


namespace android {



class AACSource : public MediaTrack {

class AACSource : public MediaTrackHelper {

public:

    AACSource(

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

}



MediaTrack *AACExtractor::getTrack(size_t index) {

MediaTrackHelper *AACExtractor::getTrack(size_t index) {

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

        return NULL;

    }