droidmediacodec.cpp

/*
 * Copyright (C) 2021 Open Mobile Platform LLC.
 * Copyright (C) 2014-2015 Jolla Ltd.
 *
 * 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.
 *
 * Authored by: Mohammed Hassan <mohammed.hassan@jolla.com>
 */

#if ANDROID_MAJOR >= 9
#    include <media/stagefright/omx/1.0/Omx.h>
#elif ANDROID_MAJOR >= 8
#    include <media/stagefright/omx/OMX.h>
#else
#    include <media/stagefright/OMXClient.h>
#endif

#include <media/stagefright/MediaCodecList.h>
// MediaCodecSource should be used instead of OMXCodec from Android 5
#if ANDROID_MAJOR >= 5
#    include <media/stagefright/MediaBuffer.h>
#    include <media/stagefright/MediaCodecSource.h>
#    include <media/stagefright/MediaCodec.h>
#    include <media/openmax/OMX_Video.h>
#    include <media/openmax/OMX_Audio.h>
#    include <media/stagefright/ACodec.h>
#    include <media/stagefright/foundation/ALooper.h>
#    include <media/stagefright/foundation/AMessage.h>
#endif

#include "mediabuffers.h"

#if ANDROID_MAJOR < 7
#    include <media/stagefright/OMXCodec.h>
#else
#    include <media/hardware/MetadataBufferType.h>
#    include "AsyncCodecSource.h"
#endif

#if ANDROID_MAJOR >= 9 && ANDROID_MAJOR <= 10
#    include <media/MediaSource.h>
#else
#    include <media/stagefright/MediaSource.h>
#endif
#include <media/stagefright/MetaData.h>
#include <media/stagefright/MediaDefs.h>
#include <gui/BufferQueue.h>
#include <inttypes.h>
#include "droidmediacodec.h"
#if ANDROID_MAJOR < 8
#    include "allocator.h"
#endif
#include "private.h"
#include "droidmediabuffer.h"

#undef LOG_TAG
#define LOG_TAG "DroidMediaCodec"
#define DROID_MEDIA_CODEC_MAX_INPUT_BUFFERS 5

#define SET_PARAM(k, v)                    \
    if (meta->v >= 0) {                    \
        md->setInt32(android::k, meta->v); \
    }

struct DroidMediaCodecMetaDataKey
{
    const char *mime;
    int key;
    int type;
} metaDataKeys[] = {
#if ANDROID_MAJOR >= 10
    { android::MEDIA_MIMETYPE_VIDEO_AV1, android::kKeyAV1C, android::kKeyAV1C },
#endif
#if ANDROID_MAJOR >= 5
    { android::MEDIA_MIMETYPE_VIDEO_HEVC, android::kKeyHVCC, android::kKeyHVCC },
#endif
    { android::MEDIA_MIMETYPE_VIDEO_MPEG4, android::kKeyESDS, android::kTypeESDS },
    { android::MEDIA_MIMETYPE_AUDIO_AAC, android::kKeyESDS, android::kTypeESDS },
    { android::MEDIA_MIMETYPE_VIDEO_AVC, android::kKeyAVCC, android::kTypeAVCC },
    { NULL, 0, 0 }
};

class Source : public android::MediaSource
{
public:
    Source(android::sp<android::MetaData> &metaData)
        : m_metaData(metaData), m_running(false), m_draining(false)
    {
    }

    void unlock()
    {
        m_framesReceived.lock.lock();
        m_framesReceived.cond.broadcast();
        m_framesReceived.lock.unlock();
    }

    // After this is called all new buffers will be rejected. get() will still return any already
    // queued buffers but once the queue has been emptied it will return a null buffer indicating
    // the end of the stream. There is no coming back from this.
    void drain()
    {
        m_framesReceived.lock.lock();
        m_draining = true;
        m_framesReceived.cond.broadcast();
        m_framesReceived.lock.unlock();
    }

    void add(android::MediaBuffer *buffer)
    {
        m_framesReceived.lock.lock();

        // drain buffer gets added without checking to avoid a deadlock

        while (!m_draining) {
            // TODO: I am not sure this is the right approach here.
            if (m_framesReceived.buffers.size() < DROID_MEDIA_CODEC_MAX_INPUT_BUFFERS) {
                m_framesReceived.buffers.push_back(buffer);
                m_framesReceived.cond.signal();
                m_framesReceived.lock.unlock();

                return;
            }
            // either get() will signal us or we will be signaled in case of an error
            m_framesReceived.cond.wait(m_framesReceived.lock);
        }

        m_framesReceived.lock.unlock();

        buffer->release();
    }

    android::MediaBuffer *get()
    {
        m_framesReceived.lock.lock();

        for (;;) {
            if (!m_running) {
                m_framesReceived.lock.unlock();
                return NULL;
            }

            if (!m_framesReceived.buffers.empty()) {
                android::List<android::MediaBuffer *>::iterator iter =
                        m_framesReceived.buffers.begin();
                android::MediaBuffer *buffer = *iter;

                m_framesReceived.buffers.erase(iter);

                m_framesReceived.cond.signal();

                m_framesReceived.lock.unlock();

                m_framesBeingProcessed.lock.lock();
                m_framesBeingProcessed.buffers.push_back(buffer);
                m_framesBeingProcessed.lock.unlock();

                return buffer;
            }

            if (m_draining) {
                m_framesReceived.lock.unlock();

                return NULL;
            }

            m_framesReceived.cond.wait(m_framesReceived.lock);
        }

        // unreachable
        return NULL;
    }

    void removeProcessedBuffer(android::MediaBuffer *buffer)
    {
        m_framesBeingProcessed.lock.lock();
        for (android::List<android::MediaBuffer *>::iterator iter =
                     m_framesBeingProcessed.buffers.begin();
             iter != m_framesBeingProcessed.buffers.end(); iter++) {
            if (*iter == buffer) {
                m_framesBeingProcessed.buffers.erase(iter);
                m_framesBeingProcessed.cond.signal();
                m_framesBeingProcessed.lock.unlock();
                return;
            }
        }
        m_framesBeingProcessed.lock.unlock();

        ALOGW("A buffer we don't know about is being finished!");
    }

    void flush()
    {
        m_framesReceived.lock.lock();

        while (!m_framesReceived.buffers.empty()) {
            android::List<android::MediaBuffer *>::iterator iter = m_framesReceived.buffers.begin();
            android::MediaBuffer *buffer = *iter;

            m_framesReceived.buffers.erase(iter);

            if (buffer) {
                buffer->release();
            }
        }

        m_framesReceived.lock.unlock();
    }

private:
    android::status_t start(android::MetaData *meta DM_UNUSED)
    {
        m_running = true;
        return android::OK;
    }

    android::sp<android::MetaData> getFormat()
    {
        // TODO: The only way to pass rotation is via a key here kKeyRotation
        return m_metaData;
    }

    android::status_t stop()
    {
        // Mark as not running
        m_framesReceived.lock.lock();
        m_running = false;

        // Just in case get() is waiting for a buffer
        m_framesReceived.cond.signal();
        m_framesReceived.lock.unlock();

        // Now clear all the buffers:
        flush();

        m_framesBeingProcessed.lock.lock();

        while (!m_framesBeingProcessed.buffers.empty()) {
            ALOGW("stop(): waiting for %zu frames", m_framesBeingProcessed.buffers.size());
            m_framesBeingProcessed.cond.wait(m_framesBeingProcessed.lock);
        }

        m_framesBeingProcessed.lock.unlock();

        return android::OK;
    }

#if ANDROID_MAJOR >= 9
    android::status_t read(android::MediaBufferBase **buffer,
#else
    android::status_t read(android::MediaBuffer **buffer,
#endif
                           const android::MediaSource::ReadOptions *options DM_UNUSED = NULL)
    {
        *buffer = get();

        if (*buffer) {
            return android::OK;
        } else {
            return android::NOT_ENOUGH_DATA;
        }
    }

    android::sp<android::MetaData> m_metaData;
    bool m_running;
    bool m_draining;
    Buffers<android::MediaBuffer *> m_framesReceived;
    Buffers<android::MediaBuffer *> m_framesBeingProcessed;
};

class InputBuffer : public android::MediaBuffer
{
public:
    InputBuffer(void *data, size_t size, void *cb_data, DroidMediaCallback unref)
        : android::MediaBuffer(data, size), m_cb_data(cb_data), m_unref(unref)
    {
    }

    ~InputBuffer() { }

    void *m_cb_data;
    DroidMediaCallback m_unref;
};

struct _DroidMediaCodec : public android::MediaBufferObserver
{
    _DroidMediaCodec() : m_cb_data(0), m_data_cb_data(0)
    {
        memset(&m_cb, 0x0, sizeof(m_cb));
        memset(&m_data_cb, 0x0, sizeof(m_data_cb));
    }

    ~_DroidMediaCodec()
    {
        m_codec.clear();
        m_src.clear();
        m_queue.clear();
        m_window.clear();
        m_thread.clear();
#if ANDROID_MAJOR >= 5
        m_looper->stop();
#endif
    }

#if ANDROID_MAJOR >= 9
    void signalBufferReturned(android::MediaBufferBase *buff)
#else
    void signalBufferReturned(android::MediaBuffer *buff)
#endif
    {
        InputBuffer *buffer = (InputBuffer *)buff;

        m_src->removeProcessedBuffer(buffer);

        buffer->m_unref(buffer->m_cb_data);

        // TODO: android does that
        buff->setObserver(0);
        buff->release();
    }

    bool notifySizeChanged()
    {
        android::sp<android::MetaData> meta = m_codec->getFormat();
        int32_t width = 0, height = 0;

        if (!meta->findInt32(android::kKeyWidth, &width)
            || !meta->findInt32(android::kKeyHeight, &height)) {
            ALOGW("notifySizeChanged without dimensions");
            return true;
        }

        ALOGI("notifySizeChanged: width = %d, height = %d", width, height);

        if (m_cb.size_changed) {
            return m_cb.size_changed(m_cb_data, width, height) == 0 ? true : false;
        }

        return true;
    }

    android::sp<android::MediaSource> m_codec;
    android::sp<Source> m_src;
    android::sp<DroidMediaBufferQueue> m_queue;
    android::sp<ANativeWindow> m_window;
#if ANDROID_MAJOR >= 5
    android::sp<android::ALooper> m_looper;
#endif

    android::sp<android::Thread> m_thread;

    bool m_useExternalLoop;

    DroidMediaCodecCallbacks m_cb;
    void *m_cb_data;
    DroidMediaCodecDataCallbacks m_data_cb;
    void *m_data_cb_data;
};

class DroidMediaCodecLoop : public android::Thread
{
public:
    DroidMediaCodecLoop(DroidMediaCodec *codec) : Thread(false), m_codec(codec) { }

    bool threadLoop()
    {
        return droid_media_codec_loop(m_codec) == DROID_MEDIA_CODEC_LOOP_OK ? true : false;
    }

private:
    DroidMediaCodec *m_codec;
};

class DroidMediaCodecBuilder
{
public:
    DroidMediaCodecBuilder(DroidMediaCodecEncoderMetaData *meta) : m_enc(meta), m_dec(NULL) { }
    DroidMediaCodecBuilder(DroidMediaCodecDecoderMetaData *meta) : m_enc(NULL), m_dec(meta) { }

    android::sp<android::MediaSource> createCodec(android::sp<android::MediaSource> src,
                                                  android::sp<ANativeWindow> window,
#if ANDROID_MAJOR >= 5
                                                  android::sp<android::ALooper> looper = NULL,
#endif
                                                  android::sp<android::MetaData> md = NULL)
    {

        if (md == NULL) {
            md = buildMetaData();
        }

        if (md == NULL) {
            return NULL;
        }

#if ANDROID_MAJOR >= 5
        const char *mime;
        if (!md->findCString(android::kKeyMIMEType, &mime)) {
            ALOGE("No mime type declared for codec");
            return NULL;
        }

        if (isEncoder()) {
            if (!strncmp("video", mime, 5)) {
                android::sp<android::AMessage> format = new android::AMessage();

                format->setString("mime", mime);
                ALOGW("Creating video encoder for %s", mime);
                int32_t width, height, stride, sliceh, colour, frames, maxinput, bitrate, iframes;

                if (md->findInt32(android::kKeyWidth, &width)) {
                    format->setInt32("width", width);
                }

                if (md->findInt32(android::kKeyHeight, &height)) {
                    format->setInt32("height", height);
                }

                if (md->findInt32(android::kKeyStride, &stride)) {
                    format->setInt32("stride", stride);
                }

                if (md->findInt32(android::kKeySliceHeight, &sliceh)) {
                    format->setInt32("slice-height", sliceh);
                }

                if (md->findInt32(android::kKeyColorFormat, &colour)) {
                    format->setInt32("color-format", colour);
                }

                if (md->findInt32(android::kKeyFrameRate, &frames)) {
                    format->setInt32("frame-rate", frames);
                }

                if (md->findInt32(android::kKeyMaxInputSize, &maxinput)) {
                    format->setInt32("max-input-size", maxinput);
                }

                if (md->findInt32(android::kKeyBitRate, &bitrate)) {
                    format->setInt32("bitrate", bitrate);
                }

                if (md->findInt32(android::kKeyIFramesInterval, &iframes)) {
                    format->setInt32("i-frame-interval", iframes);
                }

#    if ANDROID_MAJOR >= 7
                if (m_enc->meta_data) {
                    format->setInt32("android._input-metadata-buffer-type", m_enc->meta_data);
                    format->setInt32("android._store-metadata-in-buffers-output", false);
                }
                format->setInt32("android._using-recorder", 1);
#    endif

                if (!strcmp(mime, android::MEDIA_MIMETYPE_VIDEO_AVC)) {
                    int32_t profile = m_enc->codec_specific.h264.profile;
                    int32_t level = m_enc->codec_specific.h264.level;

                    if (!profile) {
                        profile = OMX_VIDEO_AVCProfileBaseline;
                    }

                    if (!level) {
                        level = android::ACodec::getAVCLevelFor(
                                width, height, frames, bitrate,
#    if (ANDROID_MAJOR == 8 && ANDROID_MINOR >= 1) || ANDROID_MAJOR >= 9
                                (OMX_VIDEO_AVCPROFILEEXTTYPE)profile);
#    else
                                (OMX_VIDEO_AVCPROFILETYPE)profile);
#    endif
                    }

                    format->setInt32("profile", profile);
                    format->setInt32("level", level);

                    if (m_enc->codec_specific.h264.prepend_header_to_sync_frames) {
                        format->setInt32("prepend-sps-pps-to-idr-frames", 1);
                    }

                    if (m_enc->bitrate_mode != DROID_MEDIA_CODEC_BITRATE_CONTROL_DEFAULT) {
                        format->setInt32("bitrate-mode", m_enc->bitrate_mode);
                    }
                }
                // TODO: time-scale

#    if ANDROID_MAJOR > 6
                return android::AsyncCodecSource::Create(src, format, true /* isEncoder */, flags(),
                                                         window, looper);
#    elif ANDROID_MAJOR == 6
                return android::MediaCodecSource::Create(looper, format, src, NULL, flags());
#    else
                return android::MediaCodecSource::Create(looper, format, src, flags());
#    endif
            } else {
                android::sp<android::AMessage> format = new android::AMessage();
                format->setString("mime", mime);
                ALOGW("Creating audio encoder for %s", mime);
                if (!strcmp(mime, android::MEDIA_MIMETYPE_AUDIO_AAC)) {
                    format->setInt32("aac-profile", OMX_AUDIO_AACObjectLC);
                }

                int32_t maxinput, channels, samplerate, bitrate;
                if (md->findInt32(android::kKeyMaxInputSize, &maxinput)) {
                    format->setInt32("max-input-size", maxinput);
                }
                if (md->findInt32(android::kKeyChannelCount, &channels)) {
                    format->setInt32("channel-count", channels);
                }
                if (md->findInt32(android::kKeySampleRate, &samplerate)) {
                    format->setInt32("sample-rate", samplerate);
                }
                if (md->findInt32(android::kKeyBitRate, &bitrate)) {
                    format->setInt32("bitrate", bitrate);
                }

                return android::MediaCodecSource::Create(looper, format, src);
            }
        }
#endif
#if ANDROID_MAJOR < 7
        android::OMXClient omx;
        if (omx.connect() != android::OK) {
            ALOGE("Failed to connect to OMX");
            return NULL;
        }

        return android::OMXCodec::Create(omx.interface(), md, isEncoder(), src, NULL, flags(),
                                         window);
#else
        return android::AsyncCodecSource::Create(src, nullptr, false /* isEncoder */, flags(),
                                                 window, looper, nullptr,
                                                 (OMX_COLOR_FORMATTYPE)m_dec->color_format);
#endif
    }

    bool isEncoder() { return m_enc != NULL; }

    DroidMediaCodecMetaData *meta()
    {
        if (m_enc) {
            return (DroidMediaCodecMetaData *)m_enc;
        } else if (m_dec) {
            return (DroidMediaCodecMetaData *)m_dec;
        } else {
            return NULL;
        }
    }

    android::sp<android::MetaData> buildMetaData()
    {
        if (isEncoder()) {
            return buildMetaData(m_enc);
        } else {
            return buildMetaData(m_dec);
        }
    }

    uint32_t flags()
    {
        if (isEncoder()) {
            return flags(m_enc);
        } else {
            return flags(m_dec);
        }
    }

    static uint32_t flags(DroidMediaCodecMetaData *meta, uint32_t currentFlags)
    {
        // We will not do any validation for the flags. Stagefright should take
        // care of that.
        if (meta->flags & DROID_MEDIA_CODEC_SW_ONLY) {
#if ANDROID_MAJOR < 7
            currentFlags |= android::OMXCodec::kSoftwareCodecsOnly;
#else
            currentFlags |= android::MediaCodecList::kPreferSoftwareCodecs;
#endif
        }

        if (meta->flags & DROID_MEDIA_CODEC_HW_ONLY) {
#if ANDROID_MAJOR < 7
            currentFlags |= android::OMXCodec::kHardwareCodecsOnly;
#else
            currentFlags |= android::MediaCodecList::kHardwareCodecsOnly;
#endif
        }

        return currentFlags;
    }

private:
    android::sp<android::MetaData> buildMetaData(DroidMediaCodecEncoderMetaData *meta)
    {
        android::sp<android::MetaData> md(new android::MetaData);
        SET_PARAM(kKeyMaxInputSize, max_input_size);
        SET_PARAM(kKeyBitRate, bitrate);
        SET_PARAM(kKeyStride, stride);
        SET_PARAM(kKeySliceHeight, slice_height);
        SET_PARAM(kKeyColorFormat, color_format);

        // TODO: This is hardcoded for now. Fix it.
        md->setInt32(android::kKeyIFramesInterval, 2);

        // TODO: kKeyHFR

        return buildMetaData((DroidMediaCodecMetaData *)meta, md);
    }

    android::sp<android::MetaData> buildMetaData(DroidMediaCodecDecoderMetaData *meta)
    {
        android::sp<android::MetaData> md(new android::MetaData);

        if (meta->codec_data.size > 0) {
            const char *mime = ((DroidMediaCodecMetaData *)meta)->type;
            DroidMediaCodecMetaDataKey *key = metaDataKeys;

            while (key->mime) {
                if (!strcmp(key->mime, mime)) {
                    md->setData(key->key, key->type, meta->codec_data.data, meta->codec_data.size);
                    return buildMetaData((DroidMediaCodecMetaData *)meta, md);
                }
                ++key;
            }

            ALOGE("No handler for codec data for %s", ((DroidMediaCodecMetaData *)meta)->type);
            return NULL;
        }

        return buildMetaData((DroidMediaCodecMetaData *)meta, md);
    }

    uint32_t flags(DroidMediaCodecEncoderMetaData *meta)
    {
#if ANDROID_MAJOR >= 7
        return flags((DroidMediaCodecMetaData *)meta, 0);
#else
        return flags((DroidMediaCodecMetaData *)meta,
                     meta->meta_data ?
#    if ANDROID_MAJOR >= 5
                                     android::MediaCodecSource::FLAG_USE_METADATA_INPUT
#    else
                                     android::OMXCodec::kStoreMetaDataInVideoBuffers
#    endif
                                     : 0);
#endif
    }

    uint32_t flags(DroidMediaCodecDecoderMetaData *meta)
    {
        return flags((DroidMediaCodecMetaData *)meta, 0);
    }

    android::sp<android::MetaData> buildMetaData(DroidMediaCodecMetaData *meta,
                                                 android::sp<android::MetaData> md)
    {
        md->setCString(android::kKeyMIMEType, meta->type);
        SET_PARAM(kKeyWidth, width);
        SET_PARAM(kKeyHeight, height);
        SET_PARAM(kKeyDisplayWidth, width);
        SET_PARAM(kKeyDisplayHeight, height);
        SET_PARAM(kKeyFrameRate, fps);
        SET_PARAM(kKeyChannelCount, channels);
        SET_PARAM(kKeySampleRate, sample_rate);

        return md;
    }

    DroidMediaCodecEncoderMetaData *m_enc;
    DroidMediaCodecDecoderMetaData *m_dec;
};

android::sp<android::MediaSource>
droid_media_codec_create_encoder_raw(DroidMediaCodecEncoderMetaData *meta,
#if ANDROID_MAJOR >= 5
                                     android::sp<android::ALooper> looper,
#endif
                                     android::sp<android::MediaSource> src)
{
    DroidMediaCodecBuilder builder(meta);
#if ANDROID_MAJOR >= 5
    return builder.createCodec(src, NULL, looper);
#else
    return builder.createCodec(src, NULL);
#endif
}

extern "C" {

DroidMediaBufferQueue *droid_media_codec_get_buffer_queue(DroidMediaCodec *codec)
{
    return codec->m_queue.get();
}

DroidMediaCodec *droid_media_codec_create(DroidMediaCodecBuilder &builder)
{
    android::sp<android::MetaData> md(builder.buildMetaData());
    if (md == NULL) {
        return NULL;
    }

    android::sp<Source> src(new Source(md));
    android::sp<DroidMediaBufferQueue> queue;
    android::sp<ANativeWindow> window = NULL;
    DroidMediaCodecMetaData *meta = builder.meta();

    if (builder.isEncoder() || meta->flags & DROID_MEDIA_CODEC_SW_ONLY
        || meta->flags & DROID_MEDIA_CODEC_NO_MEDIA_BUFFER) {
        // Nothing
    } else {
        queue = new DroidMediaBufferQueue("DroidMediaCodecBufferQueue");
        window = queue->window();
#if ANDROID_MAJOR >= 7
        if (!queue->connectListener()) {
            ALOGE("Failed to connect buffer queue listener");
            return NULL;
        }
#endif
    }

#if ANDROID_MAJOR >= 5
    android::sp<android::ALooper> looper = new android::ALooper;
    looper->setName("DroidMediaCodecLoop");
    looper->start();

    android::sp<android::MediaSource> codec = builder.createCodec(src, window, looper, md);
#else
    android::sp<android::MediaSource> codec = builder.createCodec(src, window, md);
#endif

    if (codec == NULL) {
        ALOGE("Failed to create codec");
        return NULL;
    }

    DroidMediaCodec *mediaCodec = new DroidMediaCodec;
    mediaCodec->m_codec = codec;
    mediaCodec->m_src = src;
    mediaCodec->m_queue = queue;
    mediaCodec->m_window = window;
#if ANDROID_MAJOR >= 5
    mediaCodec->m_looper = looper;
#endif
    mediaCodec->m_useExternalLoop =
            (meta->flags & DROID_MEDIA_CODEC_USE_EXTERNAL_LOOP) ? true : false;

    return mediaCodec;
}

DroidMediaCodec *droid_media_codec_create_decoder(DroidMediaCodecDecoderMetaData *meta)
{
    DroidMediaCodecBuilder builder(meta);

    return droid_media_codec_create(builder);
}

DroidMediaCodec *droid_media_codec_create_encoder(DroidMediaCodecEncoderMetaData *meta)
{
    DroidMediaCodecBuilder builder(meta);

    return droid_media_codec_create(builder);
}

bool droid_media_codec_is_supported(DroidMediaCodecMetaData *meta, bool encoder)
{
#if ANDROID_MAJOR == 4 && ANDROID_MINOR < 2
    android::Vector<android::String8> matchingCodecs;
#elif ANDROID_MAJOR < 7
    android::Vector<android::OMXCodec::CodecNameAndQuirks> matchingCodecs;
#else
    android::Vector<android::AString> matchingCodecs;
#endif

#if ANDROID_MAJOR < 7
    android::OMXCodec::findMatchingCodecs(meta->type, encoder, NULL,
#else
    android::MediaCodecList::findMatchingCodecs(
            meta->type, encoder,
#endif
                                          DroidMediaCodecBuilder::flags(meta, 0), &matchingCodecs);

    return matchingCodecs.size() > 0;
}

unsigned int droid_media_codec_get_supported_color_formats(DroidMediaCodecMetaData *meta,
                                                           int encoder, uint32_t *formats,
                                                           unsigned int maxFormats)
{
#if ANDROID_MAJOR >= 5
    android::sp<android::MediaCodecList::IMediaCodecList> list =
            android::MediaCodecList::getInstance();
#else
    const android::MediaCodecList *list = android::MediaCodecList::getInstance();
#endif

#if ANDROID_MAJOR == 4 && ANDROID_MINOR < 2
    android::Vector<android::String8> matchingCodecs;
#elif ANDROID_MAJOR < 7
    android::Vector<android::OMXCodec::CodecNameAndQuirks> matchingCodecs;
#else
    android::Vector<android::AString> matchingCodecs;
#endif

#if ANDROID_MAJOR < 7
    android::OMXCodec::findMatchingCodecs(meta->type, encoder, NULL,
#else
    android::MediaCodecList::findMatchingCodecs(
            meta->type, encoder,
#endif
                                          DroidMediaCodecBuilder::flags(meta, 0), &matchingCodecs);

    if (matchingCodecs.size() > 0) {
        const char *matchName;
#if ANDROID_MAJOR == 4 && ANDROID_MINOR < 2
        matchName = matchingCodecs.itemAt(0).string();
#elif ANDROID_MAJOR < 7
        matchName = matchingCodecs.itemAt(0).mName.string();
#else
                                              matchName = matchingCodecs.itemAt(0).c_str();
#endif
        ssize_t matchIndex = list->findCodecByName(matchName);
#if ANDROID_MAJOR >= 5
        const android::sp<android::MediaCodecInfo> info = list->getCodecInfo(matchIndex);
        if (info != NULL) {
            const android::sp<android::MediaCodecInfo::Capabilities> caps =
                    info->getCapabilitiesFor(meta->type);
            if (caps != NULL) {
                android::Vector<uint32_t> colorFormats;
                caps->getSupportedColorFormats(&colorFormats);
                if (maxFormats > colorFormats.size()) {
                    maxFormats = colorFormats.size();
                }
                for (unsigned int i = 0; i < maxFormats; i++) {
                    formats[i] = colorFormats.itemAt(i);
                }
                return maxFormats;
            }
        }
#else
        android::Vector<android::MediaCodecList::ProfileLevel> profileLevels;
        android::Vector<uint32_t> colorFormats;
        uint32_t flags;

        android::status_t err = android::MediaCodecList::getInstance()->getCodecCapabilities(
                matchIndex, meta->type, &profileLevels, &colorFormats, &flags);

        if (err == android::OK) {
            if (maxFormats > colorFormats.size()) {
                maxFormats = colorFormats.size();
            }
            for (unsigned int i = 0; i < maxFormats; i++) {
                formats[i] = colorFormats.itemAt(i);
            }
            return maxFormats;
        }
#endif
    }
    return 0;
}

bool droid_media_codec_start(DroidMediaCodec *codec)
{
#if ANDROID_MAJOR < 7
    if (codec->m_queue.get() != NULL) {
        if (!codec->m_queue->connectListener()) {
            ALOGE("Failed to connect buffer queue listener");
            return false;
        }
        android::status_t err =
                native_window_api_connect(codec->m_window.get(), NATIVE_WINDOW_API_MEDIA);
        if (err != android::NO_ERROR) {
            ALOGE("Failed to connect window");
            return false;
        }
    }
#endif

    int err = codec->m_codec->start();
    if (err != android::OK) {
        ALOGE("error 0x%x starting codec", -err);
        return false;
    }

    return true;
}

void droid_media_codec_stop(DroidMediaCodec *codec)
{
    if (codec->m_queue.get()) {
        codec->m_queue->disconnectListener();
    }

    if (codec->m_thread != NULL) {
        codec->m_thread->requestExit();
        // in case the thread is waiting in ->read()
        droid_media_codec_drain(codec);
    }

#if ANDROID_MAJOR < 7
    // On older devices the reader thread must be stopped first.
    if (codec->m_thread != NULL) {
        int err = codec->m_thread->requestExitAndWait();

        if (err != android::NO_ERROR) {
            ALOGE("Error 0x%x stopping thread", -err);
        }

        codec->m_thread.clear();
    }

    // All buffers are returned to HAL, it is safe to stop now.
    int err = codec->m_codec->stop();
    if (err != android::OK) {
        ALOGE("error 0x%x stopping codec", -err);
    }
#else
    // Wake up AsyncCodecSource and send EOS to it.
    int err = codec->m_codec->stop();
    if (err != android::OK) {
        ALOGE("error 0x%x stopping codec", -err);
    }

    if (codec->m_thread != NULL) {
        int err = codec->m_thread->requestExitAndWait();

        if (err != android::NO_ERROR) {
            ALOGE("Error 0x%x stopping thread", -err);
        }

        codec->m_thread.clear();
    }
#endif

    if (codec->m_queue.get()) {
        codec->m_queue->buffersReleased();
    }
}

void droid_media_codec_destroy(DroidMediaCodec *codec)
{
    delete codec;
}

void droid_media_codec_queue(DroidMediaCodec *codec, DroidMediaCodecData *data,
                             DroidMediaBufferCallbacks *cb)
{
    InputBuffer *buffer = new InputBuffer(data->data.data, data->data.size, cb->data, cb->unref);
#if ANDROID_MAJOR >= 9
    buffer->meta_data().setInt32(android::kKeyIsSyncFrame, data->sync ? 1 : 0);
    buffer->meta_data().setInt64(android::kKeyTime, data->ts);
#else
    buffer->meta_data()->setInt32(android::kKeyIsSyncFrame, data->sync ? 1 : 0);
    buffer->meta_data()->setInt64(android::kKeyTime, data->ts);
#endif
    buffer->setObserver(codec);
    buffer->set_range(0, data->data.size);
    buffer->add_ref();
    codec->m_src->add(buffer);

    if (codec->m_useExternalLoop) {
        return;
    }

    // Now start our looping thread
    if (codec->m_thread == NULL) {
        codec->m_thread = new DroidMediaCodecLoop(codec);

        int err = codec->m_thread->run("DroidMediaCodecLoop");
        if (err != android::NO_ERROR) {
            ALOGE("Error 0x%x starting thread", -err);
            if (codec->m_cb.error) {
                codec->m_cb.error(codec->m_cb_data, err);
            }

            codec->m_thread.clear();
        }
    }
}

DroidMediaCodecLoopReturn droid_media_codec_loop(DroidMediaCodec *codec)
{
    int err;
    android::MediaBuffer *buffer = NULL;

#if ANDROID_MAJOR >= 9
    err = codec->m_codec->read((android::MediaBufferBase **)&buffer);
#else
    err = codec->m_codec->read(&buffer);
#endif
    if (err == android::INFO_FORMAT_CHANGED) {
        ALOGI("Format changed from codec");
        if (codec->notifySizeChanged()) {
            return DROID_MEDIA_CODEC_LOOP_OK;
        } else {
            return DROID_MEDIA_CODEC_LOOP_ERROR;
        }
    }
    if (err == -EWOULDBLOCK
#if ANDROID_MAJOR >= 7
        || err == -ENODATA
#endif
    ) {
        ALOGI("retry reading again. error: 0x%x", -err);
        return DROID_MEDIA_CODEC_LOOP_OK;
    }

    if (err != android::OK) {
        if (err == android::ERROR_END_OF_STREAM
#if ANDROID_MAJOR < 7
            || err == -ENODATA
#endif
        ) {
            ALOGE("Got EOS");

            if (codec->m_cb.signal_eos) {
                codec->m_cb.signal_eos(codec->m_cb_data);
            }

            // Prevent new frames from being queued.
            codec->m_src->drain();

            return DROID_MEDIA_CODEC_LOOP_EOS;
        } else {
            ALOGE("Error 0x%x reading from codec", -err);

            if (codec->m_cb.error) {
                codec->m_cb.error(codec->m_cb_data, err);
            }

            codec->m_src->unlock();

            return DROID_MEDIA_CODEC_LOOP_ERROR;
        }
    }

    if (buffer->range_length() == 0) {
        buffer->release();
        buffer = NULL;
        return DROID_MEDIA_CODEC_LOOP_OK;
    }

#if ANDROID_MAJOR >= 9
    // Obtaining graphic buffer currently disabled because of API changes
    android::sp<android::GraphicBuffer> buff = NULL;
#else
    android::sp<android::GraphicBuffer> buff = buffer->graphicBuffer();
#endif
    if (buff == NULL) {
        if (codec->m_data_cb.data_available) {
            DroidMediaCodecData data;
            data.data.data = (uint8_t *)buffer->data() + buffer->range_offset();
            data.data.size = buffer->range_length();
            data.ts = 0;
            data.decoding_ts = 0;

#if ANDROID_MAJOR >= 9
            if (!buffer->meta_data().findInt64(android::kKeyTime, &data.ts)) {
#else
            if (!buffer->meta_data()->findInt64(android::kKeyTime, &data.ts)) {
#endif
                // I really don't know what to do here and I doubt we will
                // reach that anyway.
                ALOGE("Received a buffer without a timestamp!");
            } else {
                // Convert timestamp from useconds to nseconds
                data.ts *= 1000;
            }

#if ANDROID_MAJOR >= 9
            buffer->meta_data().findInt64(android::kKeyDecodingTime, &data.decoding_ts);
#else
            buffer->meta_data()->findInt64(android::kKeyDecodingTime, &data.decoding_ts);
#endif
            if (data.decoding_ts) {
                // Convert from usec to nsec.
                data.decoding_ts *= 1000;
            }

            int32_t sync = 0;
            data.sync = false;
#if ANDROID_MAJOR >= 9
            buffer->meta_data().findInt32(android::kKeyIsSyncFrame, &sync);
#else
            buffer->meta_data()->findInt32(android::kKeyIsSyncFrame, &sync);
#endif
            if (sync) {
                data.sync = true;
            }

            int32_t codecConfig = 0;
            data.codec_config = false;
#if ANDROID_MAJOR >= 9
            if (buffer->meta_data().findInt32(android::kKeyIsCodecConfig, &codecConfig)
#else
            if (buffer->meta_data()->findInt32(android::kKeyIsCodecConfig, &codecConfig)
#endif
                && codecConfig) {
                data.codec_config = true;
            }

            ALOGV("sync? %i, codec config? %i, ts = %" PRId64, sync, codecConfig, data.ts);

            codec->m_data_cb.data_available(codec->m_data_cb_data, &data);
        } else {
            ALOGE("non graphic buffer received. Skipping");
        }
    } else {
        int64_t timestamp = 0;
#if ANDROID_MAJOR >= 9
        if (!buffer->meta_data().findInt64(android::kKeyTime, &timestamp)) {
#else
        if (!buffer->meta_data()->findInt64(android::kKeyTime, &timestamp)) {
#endif
            // I really don't know what to do here and I doubt we will reach
            // that anyway.
            ALOGE("Received a buffer without a timestamp!");
        } else {
            // Convert timestamp from useconds to nseconds
            native_window_set_buffers_timestamp(codec->m_window.get(), timestamp * 1000);
        }

        int err = codec->m_window->queueBuffer(codec->m_window.get(), buff.get()
#if (ANDROID_MAJOR == 4 && ANDROID_MINOR >= 2) || ANDROID_MAJOR >= 5
                                                                              ,
                                               -1 /* TODO: Where do we get the fence from? */
#endif
        );
        if (err != android::NO_ERROR) {
            ALOGE("queueBuffer failed with error 0x%d", -err);
        } else {
#if ANDROID_MAJOR >= 9
            buffer->meta_data().setInt32(android::kKeyRendered, 1);
#else
            buffer->meta_data()->setInt32(android::kKeyRendered, 1);
#endif
        }
    }

    buffer->release();
    buffer = NULL;

    return DROID_MEDIA_CODEC_LOOP_OK;
}

void droid_media_codec_set_callbacks(DroidMediaCodec *codec, DroidMediaCodecCallbacks *cb,
                                     void *data)
{
    memcpy(&codec->m_cb, cb, sizeof(codec->m_cb));
    codec->m_cb_data = data;
}

void droid_media_codec_set_data_callbacks(DroidMediaCodec *codec, DroidMediaCodecDataCallbacks *cb,
                                          void *data)
{
    memcpy(&codec->m_data_cb, cb, sizeof(codec->m_data_cb));
    codec->m_data_cb_data = data;
}

void droid_media_codec_flush(DroidMediaCodec *codec)
{
    codec->m_src->flush();
}

void droid_media_codec_drain(DroidMediaCodec *codec)
{
    codec->m_src->drain();
}

void droid_media_codec_get_output_info(DroidMediaCodec *codec, DroidMediaCodecMetaData *info,
                                       DroidMediaRect *crop)
{
    android::sp<android::MetaData> md(codec->m_codec->getFormat());
    // TODO: is there a way to set info->flags?
    info->fps = 0; // TODO: is there a way to get that?

    md->findInt32(android::kKeyWidth, &info->width);
    md->findInt32(android::kKeyHeight, &info->height);
    md->findInt32(android::kKeyChannelCount, &info->channels);
    md->findInt32(android::kKeySampleRate, &info->sample_rate);
    md->findInt32(android::kKeyColorFormat, &info->hal_format);

    if (!md->findRect(android::kKeyCropRect, &crop->left, &crop->top, &crop->right,
                      &crop->bottom)) {
        crop->left = crop->top = 0;
        crop->right = info->width;
        crop->bottom = info->height;
    } else {
        // No idea why but OMXCodec.cpp deducts 1 from right and bottom
        crop->right += 1;
        crop->bottom += 1;
    }
}

bool droid_media_codec_set_video_encoder_bitrate(DroidMediaCodec *codec, int32_t bitrate)
{
#if ANDROID_MAJOR >= 7
    ALOGI("Setting video encoder bitrate to %d bps", bitrate);
    android::sp<android::AMessage> params = new android::AMessage();
    params->setInt32("video-bitrate", bitrate);
    android::sp<android::AsyncCodecSource> src =
            static_cast<android::AsyncCodecSource *>(codec->m_codec.get());
    android::status_t err = src->setParameters(params);
    return err == android::NO_ERROR;
#else
    return false;
#endif
}
};