Merge "WIP: MediaCodec and friends NDK APIs, plain C version"

/*

 * Copyright (C) 2014 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.

 */

/*

 * This file defines an NDK API.

 * Do not remove methods.

 * Do not change method signatures.

 * Do not change the value of constants.

 * Do not change the size of any of the classes defined in here.

 * Do not reference types that are not part of the NDK.

 * Do not #include files that aren't part of the NDK.

 */

#ifndef _NDK_MEDIA_CODEC_H

#define _NDK_MEDIA_CODEC_H

#include <android/native_window.h>

#include "NdkMediaFormat.h"

#ifdef __cplusplus

extern "C" {

#endif

struct AMediaCodec;

typedef struct AMediaCodec AMediaCodec;

struct AMediaCodecBufferInfo {

    int32_t offset;

    int32_t size;

    int64_t presentationTimeUs;

    uint32_t flags;

};

typedef struct AMediaCodecBufferInfo AMediaCodecBufferInfo;

enum {

    AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM = 4,

    AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED = -3,

    AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED = -2,

    AMEDIACODEC_INFO_TRY_AGAIN_LATER = -1

};

/**

 * Create decoder by name. Use this if you know the exact codec you want to use.

 */

AMediaCodec* AMediaCodec_createByCodecName(const char *name);

/**

 * Create codec by mime type. Most applications will use this, specifying a

 * mime type obtained from media extractor.

 */

AMediaCodec* AMediaCodec_createByCodecType(const char *mime_type);

/**

 * Create encoder by name.

 */

AMediaCodec* AMediaCodec_createEncoderByName(const char *name);

/**

 * delete the codec and free its resources

 */

int AMediaCodec_delete(AMediaCodec*);

/**

 * Configure the codec. For decoding you would typically get the format from an extractor.

 */

int AMediaCodec_configure(AMediaCodec*, AMediaFormat *format, ANativeWindow* surface); // TODO: other args

/**

 * Start the codec. A codec must be configured before it can be started, and must be started

 * before buffers can be sent to it.

 */

int AMediaCodec_start(AMediaCodec*);

/**

 * Stop the codec.

 */

int AMediaCodec_stop(AMediaCodec*);

/*

 * Flush the codec's input and output. All indices previously returned from calls to

 * AMediaCodec_dequeueInputBuffer and AMediaCodec_dequeueOutputBuffer become invalid.

 */

int AMediaCodec_flush(AMediaCodec*);

/**

 * Get an input buffer. The specified buffer index must have been previously obtained from

 * dequeueInputBuffer, and not yet queued.

 */

uint8_t* AMediaCodec_getInputBuffer(AMediaCodec*, size_t idx, size_t *out_size);

/**

 * Get an output buffer. The specified buffer index must have been previously obtained from

 * dequeueOutputBuffer, and not yet queued.

 */

uint8_t* AMediaCodec_getOutputBuffer(AMediaCodec*, size_t idx, size_t *out_size);

/**

 * Get the index of the next available input buffer. An app will typically use this with

 * getInputBuffer() to get a pointer to the buffer, then copy the data to be encoded or decoded

 * into the buffer before passing it to the codec.

 */

ssize_t AMediaCodec_dequeueInputBuffer(AMediaCodec*, int64_t timeoutUs);

/**

 * Send the specified buffer to the codec for processing.

 */

int AMediaCodec_queueInputBuffer(AMediaCodec*,

        size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags);

/**

 * Get the index of the next available buffer of processed data.

 */

ssize_t AMediaCodec_dequeueOutputBuffer(AMediaCodec*, AMediaCodecBufferInfo *info, int64_t timeoutUs);

AMediaFormat* AMediaCodec_getOutputFormat(AMediaCodec*);

/**

 * Release and optionally render the specified buffer.

 */

int AMediaCodec_releaseOutputBuffer(AMediaCodec*, size_t idx, bool render);

#ifdef __cplusplus

} // extern "C"

#endif

#endif //_NDK_MEDIA_CODEC_H

/*

 * Copyright (C) 2014 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.

 */

/*

 * This file defines an NDK API.

 * Do not remove methods.

 * Do not change method signatures.

 * Do not change the value of constants.

 * Do not change the size of any of the classes defined in here.

 * Do not reference types that are not part of the NDK.

 * Do not #include files that aren't part of the NDK.

 */

#ifndef _NDK_MEDIA_EXTRACTOR_H

#define _NDK_MEDIA_EXTRACTOR_H

#include <sys/types.h>

#include "NdkMediaFormat.h"

#ifdef __cplusplus

extern "C" {

#endif

struct AMediaExtractor;

typedef struct AMediaExtractor AMediaExtractor;

/**

 * Create new media extractor

 */

AMediaExtractor* AMediaExtractor_new();

/**

 * Delete a previously created media extractor

 */

int AMediaExtractor_delete(AMediaExtractor*);

/**

 *  Set the file descriptor from which the extractor will read.

 */

int AMediaExtractor_setDataSourceFd(AMediaExtractor*, int fd, off64_t offset, off64_t length);

/**

 * Set the URI from which the extractor will read.

 */

int AMediaExtractor_setDataSource(AMediaExtractor*, const char *location); // TODO support headers

/**

 * Return the number of tracks in the previously specified media file

 */

int AMediaExtractor_getTrackCount(AMediaExtractor*);

/**

 * Return the format of the specified track. The caller must free the returned format

 */

AMediaFormat* AMediaExtractor_getTrackFormat(AMediaExtractor*, size_t idx);

/**

 * Select the specified track. Subsequent calls to readSampleData, getSampleTrackIndex and

 * getSampleTime only retrieve information for the subset of tracks selected.

 * Selecting the same track multiple times has no effect, the track is

 * only selected once.

 */

int AMediaExtractor_selectTrack(AMediaExtractor*, size_t idx);

/**

 * Unselect the specified track. Subsequent calls to readSampleData, getSampleTrackIndex and

 * getSampleTime only retrieve information for the subset of tracks selected..

 */

int AMediaExtractor_unselectTrack(AMediaExtractor*, size_t idx);

/**

 * Read the current sample.

 */

int AMediaExtractor_readSampleData(AMediaExtractor*, uint8_t *buffer, size_t capacity);

/**

 * Read the current sample's flags.

 */

int AMediaExtractor_getSampleFlags(AMediaExtractor*); // see definitions below

/**

 * Returns the track index the current sample originates from (or -1

 * if no more samples are available)

 */

int AMediaExtractor_getSampleTrackIndex(AMediaExtractor*);

/**

 * Returns the current sample's presentation time in microseconds.

 * or -1 if no more samples are available.

 */

int64_t AMediaExtractor_getSampletime(AMediaExtractor*);

/**

 * Advance to the next sample. Returns false if no more sample data

 * is available (end of stream).

 */

bool AMediaExtractor_advance(AMediaExtractor*);

enum {

    AMEDIAEXTRACTOR_SAMPLE_FLAG_SYNC = 1,

    AMEDIAEXTRACTOR_SAMPLE_FLAG_ENCRYPTED = 2,

};

#ifdef __cplusplus

} // extern "C"

#endif

#endif // _NDK_MEDIA_EXTRACTOR_H

/*

 * Copyright (C) 2014 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.

 */

/*

 * This file defines an NDK API.

 * Do not remove methods.

 * Do not change method signatures.

 * Do not change the value of constants.

 * Do not change the size of any of the classes defined in here.

 * Do not reference types that are not part of the NDK.

 * Do not #include files that aren't part of the NDK.

 */

#ifndef _NDK_MEDIA_FORMAT_H

#define _NDK_MEDIA_FORMAT_H

#include <sys/types.h>

#ifdef __cplusplus

extern "C" {

#endif

struct AMediaFormat;

typedef struct AMediaFormat AMediaFormat;

AMediaFormat *AMediaFormat_new();

int AMediaFormat_delete(AMediaFormat*);

/**

 * Debug string. Caller must free.

 */

const char* AMediaFormat_toString(AMediaFormat*);

bool AMediaFormat_getInt32(AMediaFormat*, const char *name, int32_t *out);

bool AMediaFormat_getInt64(AMediaFormat*, const char *name, int64_t *out);

bool AMediaFormat_getFloat(AMediaFormat*, const char *name, float *out);

bool AMediaFormat_getDouble(AMediaFormat*, const char *name, double *out);

bool AMediaFormat_getSize(AMediaFormat*, const char *name, size_t *out);

/**

 * Caller must free the returned string

 */

bool AMediaFormat_getString(AMediaFormat*, const char *name, const char **out);

/**

 * XXX should these be ints/enums that we look up in a table as needed?

 */

extern const char* AMEDIAFORMAT_KEY_AAC_PROFILE;

extern const char* AMEDIAFORMAT_KEY_BIT_RATE;

extern const char* AMEDIAFORMAT_KEY_CHANNEL_COUNT;

extern const char* AMEDIAFORMAT_KEY_CHANNEL_MASK;

extern const char* AMEDIAFORMAT_KEY_COLOR_FORMAT;

extern const char* AMEDIAFORMAT_KEY_DURATION;

extern const char* AMEDIAFORMAT_KEY_FLAC_COMPRESSION_LEVEL;

extern const char* AMEDIAFORMAT_KEY_FRAME_RATE;

extern const char* AMEDIAFORMAT_KEY_HEIGHT;

extern const char* AMEDIAFORMAT_KEY_IS_ADTS;

extern const char* AMEDIAFORMAT_KEY_IS_AUTOSELECT;

extern const char* AMEDIAFORMAT_KEY_IS_DEFAULT;

extern const char* AMEDIAFORMAT_KEY_IS_FORCED_SUBTITLE;

extern const char* AMEDIAFORMAT_KEY_I_FRAME_INTERVAL;

extern const char* AMEDIAFORMAT_KEY_LANGUAGE;

extern const char* AMEDIAFORMAT_KEY_MAX_HEIGHT;

extern const char* AMEDIAFORMAT_KEY_MAX_INPUT_SIZE;

extern const char* AMEDIAFORMAT_KEY_MAX_WIDTH;

extern const char* AMEDIAFORMAT_KEY_MIME;

extern const char* AMEDIAFORMAT_KEY_PUSH_BLANK_BUFFERS_ON_STOP;

extern const char* AMEDIAFORMAT_KEY_REPEAT_PREVIOUS_FRAME_AFTER;

extern const char* AMEDIAFORMAT_KEY_SAMPLE_RATE;

extern const char* AMEDIAFORMAT_KEY_WIDTH;

extern const char* AMEDIAFORMAT_KEY_STRIDE;

#ifdef __cplusplus

} // extern "C"

#endif

#endif // _NDK_MEDIA_FORMAT_H

#

# Copyright (C) 2010 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.

#

LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)

LOCAL_SRC_FILES:=                                       \

                  NdkMediaCodec.cpp                     \

                  NdkMediaExtractor.cpp                 \

                  NdkMediaFormat.cpp                    \

LOCAL_MODULE:= libmediandk

LOCAL_C_INCLUDES := \

    bionic/libc/private \

    frameworks/base/core/jni \

    frameworks/av/include/ndk

LOCAL_SHARED_LIBRARIES := \

    libmedia \

    libstagefright \

    libstagefright_foundation \

    liblog \

    libutils \

    libandroid_runtime \

include $(BUILD_SHARED_LIBRARY)

/*

 * Copyright (C) 2014 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.

 */

#define LOG_NDEBUG 0

#define LOG_TAG "NdkMediaCodec"

#include "NdkMediaCodec.h"

#include "NdkMediaFormatPriv.h"

#include <utils/Log.h>

#include <utils/StrongPointer.h>

#include <gui/Surface.h>

#include <media/ICrypto.h>

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

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

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

#include <media/stagefright/MediaCodec.h>

#include <media/stagefright/MediaErrors.h>

using namespace android;

static int translate_error(status_t err) {

    if (err == OK) {

        return OK;

    } else if (err == -EAGAIN) {

        return AMEDIACODEC_INFO_TRY_AGAIN_LATER;

    }

    ALOGE("sf error code: %d", err);

    return -1000;

}

class CodecHandler: public AHandler {

public:

    CodecHandler(sp<android::MediaCodec>);

    virtual void onMessageReceived(const sp<AMessage> &msg);

};

CodecHandler::CodecHandler(sp<android::MediaCodec>) {

}

void CodecHandler::onMessageReceived(const sp<AMessage> &msg) {

    ALOGI("handler got message %d", msg->what());

}

struct AMediaCodec {

    sp<android::MediaCodec> mCodec;

    sp<ALooper> mLooper;

    sp<CodecHandler> mHandler;

};

extern "C" {

static AMediaCodec * createAMediaCodec(const char *name, bool name_is_type, bool encoder) {

    AMediaCodec *mData = new AMediaCodec();

    mData->mLooper = new ALooper;

    mData->mLooper->setName("NDK MediaCodec_looper");

    status_t ret = mData->mLooper->start(

            false,      // runOnCallingThread

            true,       // canCallJava XXX

            PRIORITY_FOREGROUND);

    ALOGV("looper start: %d", ret);

    if (name_is_type) {

        mData->mCodec = android::MediaCodec::CreateByType(mData->mLooper, name, encoder);

    } else {

        mData->mCodec = android::MediaCodec::CreateByComponentName(mData->mLooper, name);

    }

    mData->mHandler = new CodecHandler(mData->mCodec);

    mData->mLooper->registerHandler(mData->mHandler);

    return mData;

}

AMediaCodec* AMediaCodec_createByCodecName(const char *name) {

    return createAMediaCodec(name, false, false);

}

AMediaCodec* AMediaCodec_createByCodecType(const char *mime_type) {

    return createAMediaCodec(mime_type, true, false);

}

AMediaCodec* AMediaCodec_createEncoderByName(const char *name) {

    return createAMediaCodec(name, false, true);

}

int AMediaCodec_delete(AMediaCodec *mData) {

    if (mData->mCodec != NULL) {

        mData->mCodec->release();

        mData->mCodec.clear();

    }

    if (mData->mLooper != NULL) {

        mData->mLooper->unregisterHandler(mData->mHandler->id());

        mData->mLooper->stop();

        mData->mLooper.clear();

    }

    delete mData;

    return OK;

}

int AMediaCodec_configure(AMediaCodec *mData, AMediaFormat *format, ANativeWindow* window) {

    sp<AMessage> nativeFormat;

    AMediaFormat_getFormat(format, &nativeFormat);

    ALOGV("configure with format: %s", nativeFormat->debugString(0).c_str());

    sp<Surface> surface = NULL;

    if (window != NULL) {

        surface = (Surface*) window;

    }

    return translate_error(mData->mCodec->configure(nativeFormat, surface, NULL, 0));

}

int AMediaCodec_start(AMediaCodec *mData) {

    return translate_error(mData->mCodec->start());

}

int AMediaCodec_stop(AMediaCodec *mData) {

    return translate_error(mData->mCodec->stop());

}

int AMediaCodec_flush(AMediaCodec *mData) {

    return translate_error(mData->mCodec->flush());

}

ssize_t AMediaCodec_dequeueInputBuffer(AMediaCodec *mData, int64_t timeoutUs) {

    size_t idx;

    status_t ret = mData->mCodec->dequeueInputBuffer(&idx, timeoutUs);

    if (ret == OK) {

        return idx;

    }

    return translate_error(ret);

}

uint8_t* AMediaCodec_getInputBuffer(AMediaCodec *mData, size_t idx, size_t *out_size) {

    android::Vector<android::sp<android::ABuffer> > abufs;

    if (mData->mCodec->getInputBuffers(&abufs) == 0) {

        size_t n = abufs.size();

        if (idx >= n) {

            ALOGE("buffer index %d out of range", idx);

            return NULL;

        }

        if (out_size != NULL) {

            *out_size = abufs[idx]->capacity();

        }

        return abufs[idx]->data();

    }

    ALOGE("couldn't get input buffers");

    return NULL;

}

uint8_t* AMediaCodec_getOutputBuffer(AMediaCodec *mData, size_t idx, size_t *out_size) {

    android::Vector<android::sp<android::ABuffer> > abufs;

    if (mData->mCodec->getOutputBuffers(&abufs) == 0) {

        size_t n = abufs.size();

        if (idx >= n) {

            ALOGE("buffer index %d out of range", idx);

            return NULL;

        }

        if (out_size != NULL) {

            *out_size = abufs[idx]->capacity();

        }

        return abufs[idx]->data();

    }

    ALOGE("couldn't get output buffers");

    return NULL;

}

int AMediaCodec_queueInputBuffer(AMediaCodec *mData,

        size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags) {

    AString errorMsg;

    status_t ret = mData->mCodec->queueInputBuffer(idx, offset, size, time, flags, &errorMsg);

    return translate_error(ret);

}

ssize_t AMediaCodec_dequeueOutputBuffer(AMediaCodec *mData,

        AMediaCodecBufferInfo *info, int64_t timeoutUs) {

    size_t idx;

    size_t offset;

    size_t size;

    uint32_t flags;

    int64_t presentationTimeUs;

    status_t ret = mData->mCodec->dequeueOutputBuffer(&idx, &offset, &size, &presentationTimeUs,

            &flags, timeoutUs);

    switch (ret) {

        case OK:

            info->offset = offset;

            info->size = size;

            info->flags = flags;

            info->presentationTimeUs = presentationTimeUs;

            return idx;

        case -EAGAIN:

            return AMEDIACODEC_INFO_TRY_AGAIN_LATER;

        case android::INFO_FORMAT_CHANGED:

            return AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED;

        case INFO_OUTPUT_BUFFERS_CHANGED:

            return AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED;

        default:

            break;

    }

    return translate_error(ret);

}

AMediaFormat* AMediaCodec_getOutputFormat(AMediaCodec *mData) {

    sp<AMessage> format;

    mData->mCodec->getOutputFormat(&format);

    return AMediaFormat_fromMsg(&format);

}

int AMediaCodec_releaseOutputBuffer(AMediaCodec *mData, size_t idx, bool render) {

    if (render) {

        return translate_error(mData->mCodec->renderOutputBufferAndRelease(idx));

    } else {

        return translate_error(mData->mCodec->releaseOutputBuffer(idx));

    }

}

} // extern "C"