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

Commit 708336fe authored by Lajos Molnar's avatar Lajos Molnar
Browse files

stagefright: Remove OMXCodec object 

This is no longer used or supported.

Bug: 17108024
Change-Id: I57e5b2368e3df138645ef73121603d19cd5c59ce
parent 3ca8f9cc

include/media/stagefright/MediaSource.h

+3 −2
Original line number Diff line number Diff line
@@ -59,8 +59,9 @@ struct MediaSource : public BnMediaSource { 
            MediaBuffer **buffer, const ReadOptions *options = NULL) = 0;



    // Causes this source to suspend pulling data from its upstream source

    // until a subsequent read-with-seek. Currently only supported by

    // OMXCodec.

    // until a subsequent read-with-seek. This is currently not supported

    // as such by any source. E.g. MediaCodecSource does not suspend its

    // upstream source, and instead discard upstream data while paused.

    virtual status_t pause() {

        return ERROR_UNSUPPORTED;

    }

include/media/stagefright/OMXCodec.h

deleted100644 → 0
+0 −406
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2009 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 OMX_CODEC_H_



#define OMX_CODEC_H_



#include <android/native_window.h>

#include <media/IOMX.h>

#include <media/stagefright/MediaBuffer.h>

#include <media/stagefright/MediaSource.h>

#include <utils/threads.h>



#include <OMX_Audio.h>



namespace android {



struct MediaCodecInfo;

class MemoryDealer;

struct OMXCodecObserver;

struct CodecProfileLevel;

class SkipCutBuffer;



struct OMXCodec : public BnMediaSource,

                  public MediaBufferObserver {

    enum CreationFlags {

        kPreferSoftwareCodecs    = 1,

        kIgnoreCodecSpecificData = 2,



        // The client wants to access the output buffer's video

        // data for example for thumbnail extraction.

        kClientNeedsFramebuffer  = 4,



        // Request for software or hardware codecs. If request

        // can not be fullfilled, Create() returns NULL.

        kSoftwareCodecsOnly      = 8,

        kHardwareCodecsOnly      = 16,



        // Store meta data in video buffers

        kStoreMetaDataInVideoBuffers = 32,



        // Only submit one input buffer at one time.

        kOnlySubmitOneInputBufferAtOneTime = 64,



        // Enable GRALLOC_USAGE_PROTECTED for output buffers from native window

        kEnableGrallocUsageProtected = 128,



        // Secure decoding mode

        kUseSecureInputBuffers = 256,

    };

    static sp<IMediaSource> Create(

            const sp<IOMX> &omx,

            const sp<MetaData> &meta, bool createEncoder,

            const sp<IMediaSource> &source,

            const char *matchComponentName = NULL,

            uint32_t flags = 0,

            const sp<ANativeWindow> &nativeWindow = NULL);



    static void setComponentRole(

            const sp<IOMX> &omx, IOMX::node_id node, bool isEncoder,

            const char *mime);



    virtual status_t start(MetaData *params = NULL);

    virtual status_t stop();



    virtual sp<MetaData> getFormat();



    virtual status_t read(

            MediaBuffer **buffer, const ReadOptions *options = NULL);



    virtual status_t pause();



    // from MediaBufferObserver

    virtual void signalBufferReturned(MediaBuffer *buffer);



    enum Quirks {

        kNeedsFlushBeforeDisable              = 1,

        kWantsNALFragments                    = 2,

        kRequiresLoadedToIdleAfterAllocation  = 4,

        kRequiresAllocateBufferOnInputPorts   = 8,

        kRequiresFlushCompleteEmulation       = 16,

        kRequiresAllocateBufferOnOutputPorts  = 32,

        kRequiresFlushBeforeShutdown          = 64,

        kDefersOutputBufferAllocation         = 128,

        kDecoderLiesAboutNumberOfChannels     = 256,

        kInputBufferSizesAreBogus             = 512,

        kSupportsMultipleFramesPerInputBuffer = 1024,

        kRequiresLargerEncoderOutputBuffer    = 2048,

        kOutputBuffersAreUnreadable           = 4096,

    };



    struct CodecNameAndQuirks {

        String8 mName;

        uint32_t mQuirks;

    };



    // for use by ACodec

    static void findMatchingCodecs(

            const char *mime,

            bool createEncoder, const char *matchComponentName,

            uint32_t flags,

            Vector<CodecNameAndQuirks> *matchingCodecNamesAndQuirks);



    static uint32_t getComponentQuirks(

            const sp<MediaCodecInfo> &list);



protected:

    virtual ~OMXCodec();



private:



    // Make sure mLock is accessible to OMXCodecObserver

    friend class OMXCodecObserver;



    // Call this with mLock hold

    void on_message(const omx_message &msg);



    enum State {

        DEAD,

        LOADED,

        LOADED_TO_IDLE,

        IDLE_TO_EXECUTING,

        EXECUTING,

        EXECUTING_TO_IDLE,

        IDLE_TO_LOADED,

        RECONFIGURING,

        ERROR

    };



    enum {

        kPortIndexInput  = 0,

        kPortIndexOutput = 1

    };



    enum PortStatus {

        ENABLED,

        DISABLING,

        DISABLED,

        ENABLING,

        SHUTTING_DOWN,

    };



    enum BufferStatus {

        OWNED_BY_US,

        OWNED_BY_COMPONENT,

        OWNED_BY_NATIVE_WINDOW,

        OWNED_BY_CLIENT,

    };



    struct BufferInfo {

        IOMX::buffer_id mBuffer;

        BufferStatus mStatus;

        sp<IMemory> mMem;

        size_t mSize;

        void *mData;

        MediaBuffer *mMediaBuffer;

    };



    struct CodecSpecificData {

        size_t mSize;

        uint8_t mData[1];

    };



    sp<IOMX> mOMX;

    bool mOMXLivesLocally;

    IOMX::node_id mNode;

    uint32_t mQuirks;



    // Flags specified in the creation of the codec.

    uint32_t mFlags;



    bool mIsEncoder;

    bool mIsVideo;

    char *mMIME;

    char *mComponentName;

    sp<MetaData> mOutputFormat;

    sp<IMediaSource> mSource;

    Vector<CodecSpecificData *> mCodecSpecificData;

    size_t mCodecSpecificDataIndex;



    sp<MemoryDealer> mDealer[2];



    State mState;

    Vector<BufferInfo> mPortBuffers[2];

    PortStatus mPortStatus[2];

    bool mInitialBufferSubmit;

    bool mSignalledEOS;

    status_t mFinalStatus;

    bool mNoMoreOutputData;

    bool mOutputPortSettingsHaveChanged;

    int64_t mSeekTimeUs;

    ReadOptions::SeekMode mSeekMode;

    int64_t mTargetTimeUs;

    bool mOutputPortSettingsChangedPending;

    sp<SkipCutBuffer> mSkipCutBuffer;



    MediaBuffer *mLeftOverBuffer;



    Mutex mLock;

    Condition mAsyncCompletion;



    bool mPaused;



    sp<ANativeWindow> mNativeWindow;



    // The index in each of the mPortBuffers arrays of the buffer that will be

    // submitted to OMX next.  This only applies when using buffers from a

    // native window.

    size_t mNextNativeBufferIndex[2];



    // A list of indices into mPortStatus[kPortIndexOutput] filled with data.

    List<size_t> mFilledBuffers;

    Condition mBufferFilled;



    // Used to record the decoding time for an output picture from

    // a video encoder.

    List<int64_t> mDecodingTimeList;



    OMXCodec(const sp<IOMX> &omx, IOMX::node_id node,

             uint32_t quirks, uint32_t flags,

             bool isEncoder, const char *mime, const char *componentName,

             const sp<IMediaSource> &source,

             const sp<ANativeWindow> &nativeWindow);



    void addCodecSpecificData(const void *data, size_t size);

    void clearCodecSpecificData();



    void setComponentRole();



    void setAMRFormat(bool isWAMR, int32_t bitRate);



    status_t setAACFormat(

            int32_t numChannels, int32_t sampleRate, int32_t bitRate,

            int32_t aacProfile, bool isADTS);



    status_t setAC3Format(int32_t numChannels, int32_t sampleRate);



    void setG711Format(int32_t sampleRate, int32_t numChannels);



    status_t setVideoPortFormatType(

            OMX_U32 portIndex,

            OMX_VIDEO_CODINGTYPE compressionFormat,

            OMX_COLOR_FORMATTYPE colorFormat);



    void setVideoInputFormat(

            const char *mime, const sp<MetaData>& meta);



    status_t setupBitRate(int32_t bitRate);

    status_t setupErrorCorrectionParameters();

    status_t setupH263EncoderParameters(const sp<MetaData>& meta);

    status_t setupMPEG4EncoderParameters(const sp<MetaData>& meta);

    status_t setupAVCEncoderParameters(const sp<MetaData>& meta);

    status_t findTargetColorFormat(

            const sp<MetaData>& meta, OMX_COLOR_FORMATTYPE *colorFormat);



    status_t isColorFormatSupported(

            OMX_COLOR_FORMATTYPE colorFormat, int portIndex);



    // If profile/level is set in the meta data, its value in the meta

    // data will be used; otherwise, the default value will be used.

    status_t getVideoProfileLevel(const sp<MetaData>& meta,

            const CodecProfileLevel& defaultProfileLevel,

            CodecProfileLevel& profileLevel);



    status_t setVideoOutputFormat(

            const char *mime, const sp<MetaData>& meta);



    void setImageOutputFormat(

            OMX_COLOR_FORMATTYPE format, OMX_U32 width, OMX_U32 height);



    void setJPEGInputFormat(

            OMX_U32 width, OMX_U32 height, OMX_U32 compressedSize);



    void setMinBufferSize(OMX_U32 portIndex, OMX_U32 size);



    void setRawAudioFormat(

            OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels);



    status_t allocateBuffers();

    status_t allocateBuffersOnPort(OMX_U32 portIndex);

    status_t allocateOutputBuffersFromNativeWindow();



    status_t queueBufferToNativeWindow(BufferInfo *info);

    status_t cancelBufferToNativeWindow(BufferInfo *info);

    BufferInfo* dequeueBufferFromNativeWindow();



    status_t freeBuffersOnPort(

            OMX_U32 portIndex, bool onlyThoseWeOwn = false);



    status_t freeBuffer(OMX_U32 portIndex, size_t bufIndex);



    bool drainInputBuffer(IOMX::buffer_id buffer);

    void fillOutputBuffer(IOMX::buffer_id buffer);

    bool drainInputBuffer(BufferInfo *info);

    void fillOutputBuffer(BufferInfo *info);



    void drainInputBuffers();

    void fillOutputBuffers();



    bool drainAnyInputBuffer();

    BufferInfo *findInputBufferByDataPointer(void *ptr);

    BufferInfo *findEmptyInputBuffer();



    // Returns true iff a flush was initiated and a completion event is

    // upcoming, false otherwise (A flush was not necessary as we own all

    // the buffers on that port).

    // This method will ONLY ever return false for a component with quirk

    // "kRequiresFlushCompleteEmulation".

    bool flushPortAsync(OMX_U32 portIndex);



    void disablePortAsync(OMX_U32 portIndex);

    status_t enablePortAsync(OMX_U32 portIndex);



    static size_t countBuffersWeOwn(const Vector<BufferInfo> &buffers);

    static bool isIntermediateState(State state);



    void onEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);

    void onCmdComplete(OMX_COMMANDTYPE cmd, OMX_U32 data);

    void onStateChange(OMX_STATETYPE newState);

    void onPortSettingsChanged(OMX_U32 portIndex);



    void setState(State newState);



    status_t init();

    void initOutputFormat(const sp<MetaData> &inputFormat);

    status_t initNativeWindow();



    void initNativeWindowCrop();



    void dumpPortStatus(OMX_U32 portIndex);



    status_t configureCodec(const sp<MetaData> &meta);



    status_t waitForBufferFilled_l();



    int64_t getDecodingTimeUs();



    status_t parseHEVCCodecSpecificData(

            const void *data, size_t size,

            unsigned *profile, unsigned *level);

    status_t parseAVCCodecSpecificData(

            const void *data, size_t size,

            unsigned *profile, unsigned *level);



    status_t stopOmxComponent_l();



    OMXCodec(const OMXCodec &);

    OMXCodec &operator=(const OMXCodec &);

};



struct CodecCapabilities {

    enum {

        kFlagSupportsAdaptivePlayback = 1 << 0,

    };



    String8 mComponentName;

    Vector<CodecProfileLevel> mProfileLevels;

    Vector<OMX_U32> mColorFormats;

    uint32_t mFlags;

};



// Return a vector of componentNames with supported profile/level pairs

// supporting the given mime type, if queryDecoders==true, returns components

// that decode content of the given type, otherwise returns components

// that encode content of the given type.

// profile and level indications only make sense for h.263, mpeg4 and avc

// video.

// If hwCodecOnly==true, only returns hardware-based components, software and

// hardware otherwise.

// The profile/level values correspond to

// OMX_VIDEO_H263PROFILETYPE, OMX_VIDEO_MPEG4PROFILETYPE,

// OMX_VIDEO_AVCPROFILETYPE, OMX_VIDEO_H263LEVELTYPE, OMX_VIDEO_MPEG4LEVELTYPE

// and OMX_VIDEO_AVCLEVELTYPE respectively.



status_t QueryCodecs(

        const sp<IOMX> &omx,

        const char *mimeType, bool queryDecoders, bool hwCodecOnly,

        Vector<CodecCapabilities> *results);



status_t QueryCodecs(

        const sp<IOMX> &omx,

        const char *mimeType, bool queryDecoders,

        Vector<CodecCapabilities> *results);



status_t QueryCodec(

        const sp<IOMX> &omx,

        const char *componentName, const char *mime,

        bool isEncoder,

        CodecCapabilities *caps);



}  // namespace android



#endif  // OMX_CODEC_H_

media/libstagefright/Android.mk

+0 −1
Original line number Diff line number Diff line
@@ -45,7 +45,6 @@ LOCAL_SRC_FILES:= \ 
        NuCachedSource2.cpp               \

        NuMediaExtractor.cpp              \

        OMXClient.cpp                     \

        OMXCodec.cpp                      \

        OggExtractor.cpp                  \

        ProcessInfo.cpp                   \

        SampleIterator.cpp                \