Skip to content

Xbox Cloud Gaming app for PS5 Homebrew

C
4.2 KB
Raw Blame
// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2026 RafaelNGP
// H.264 on Android via NDK AMediaCodec.
#include "media/hw_decoder.h"
#include "util/log.h"

#include <cstring>
#include <vector>

#if defined(__ANDROID__)
#include <media/NdkMediaCodec.h>
#include <media/NdkMediaFormat.h>
#endif

namespace xc::media {

HwDecoder::~HwDecoder() {
#if defined(__ANDROID__)
    if (decoder_) {
        auto* codec = static_cast<AMediaCodec*>(decoder_);
        AMediaCodec_stop(codec);
        AMediaCodec_delete(codec);
        decoder_ = nullptr;
    }
#endif
}

bool HwDecoder::init(int maxWidth, int maxHeight) {
#if defined(__ANDROID__)
    AMediaCodec* codec = AMediaCodec_createDecoderByType("video/avc");
    if (!codec) {
        XC_LOGW("hw_decoder_android: AMediaCodec_createDecoderByType failed");
        return false;
    }

    AMediaFormat* format = AMediaFormat_new();
    AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, "video/avc");
    AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_WIDTH, maxWidth > 0 ? maxWidth : 1920);
    AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_HEIGHT, maxHeight > 0 ? maxHeight : 1080);

    media_status_t status = AMediaCodec_configure(codec, format, nullptr, nullptr, 0);
    AMediaFormat_delete(format);

    if (status != AMEDIA_OK) {
        XC_LOGW("hw_decoder_android: AMediaCodec_configure failed: %d", status);
        AMediaCodec_delete(codec);
        return false;
    }

    status = AMediaCodec_start(codec);
    if (status != AMEDIA_OK) {
        XC_LOGW("hw_decoder_android: AMediaCodec_start failed: %d", status);
        AMediaCodec_delete(codec);
        return false;
    }

    decoder_ = codec;
    XC_LOGI("hw_decoder_android: initialized AMediaCodec video/avc (%dx%d)", maxWidth, maxHeight);
    return true;
#else
    (void)maxWidth;
    (void)maxHeight;
    return false;
#endif
}

bool HwDecoder::decode(const uint8_t* data, size_t len, uint64_t pts, Picture& out) {
#if defined(__ANDROID__)
    if (!decoder_ || !data || len == 0) return false;
    auto* codec = static_cast<AMediaCodec*>(decoder_);

    ssize_t inIdx = AMediaCodec_dequeueInputBuffer(codec, 2000);  // 2ms timeout
    if (inIdx >= 0) {
        size_t bufSize = 0;
        uint8_t* buf = AMediaCodec_getInputBuffer(codec, static_cast<size_t>(inIdx), &bufSize);
        if (buf && bufSize >= len) {
            std::memcpy(buf, data, len);
            AMediaCodec_queueInputBuffer(codec, static_cast<size_t>(inIdx), 0, len, pts, 0);
        } else {
            AMediaCodec_queueInputBuffer(codec, static_cast<size_t>(inIdx), 0, 0, pts, 0);
        }
    }

    AMediaCodecBufferInfo info{};
    ssize_t outIdx = AMediaCodec_dequeueOutputBuffer(codec, &info, 2000);  // 2ms timeout
    if (outIdx >= 0) {
        size_t outSize = 0;
        uint8_t* outBuf = AMediaCodec_getOutputBuffer(codec, static_cast<size_t>(outIdx), &outSize);
        if (outBuf && info.size > 0) {
            static thread_local std::vector<uint8_t> s_androidFrameBuffer;
            s_androidFrameBuffer.assign(outBuf + info.offset, outBuf + info.offset + info.size);
            out.data = s_androidFrameBuffer.data();
            out.size = s_androidFrameBuffer.size();

            AMediaFormat* outFormat = AMediaCodec_getOutputFormat(codec);
            int32_t width = 0, height = 0, stride = 0;
            if (outFormat) {
                AMediaFormat_getInt32(outFormat, AMEDIAFORMAT_KEY_WIDTH, &width);
                AMediaFormat_getInt32(outFormat, AMEDIAFORMAT_KEY_HEIGHT, &height);
                AMediaFormat_getInt32(outFormat, AMEDIAFORMAT_KEY_STRIDE, &stride);
                AMediaFormat_delete(outFormat);
            }
            out.width = width > 0 ? static_cast<uint32_t>(width) : 1920;
            out.height = height > 0 ? static_cast<uint32_t>(height) : 1080;
            out.pitch = stride > 0 ? static_cast<uint32_t>(stride) : out.width;
            out.pitchBytes = out.pitch;
            out.format = 1;  // NV12
            out.pts = static_cast<uint64_t>(info.presentationTimeUs);
            out.error = false;
        }
        AMediaCodec_releaseOutputBuffer(codec, static_cast<size_t>(outIdx), false);
        return true;
    }
    return false;
#else
    (void)data;
    (void)len;
    (void)pts;
    (void)out;
    return false;
#endif
}

}  // namespace xc::media