FFmpeg/libavcodec/libsvtjpegxsdec.c

/*
 * Copyright(c) 2024 Intel Corporation
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/*
* Copyright(c) 2024 Intel Corporation
* SPDX - License - Identifier: BSD - 2 - Clause - Patent
*/

#include <SvtJpegxsDec.h>

#include "libavutil/mem.h"
#include "libavutil/common.h"
#include "libavutil/cpu.h"
#include "libavutil/imgutils.h"
#include "libavutil/avassert.h"

#include "avcodec.h"
#include "codec_internal.h"
#include "decode.h"
#include "profiles.h"

typedef struct SvtJpegXsDecodeContext {
    svt_jpeg_xs_image_config_t config;
    svt_jpeg_xs_decoder_api_t decoder;
    svt_jpeg_xs_frame_t input;
    svt_jpeg_xs_frame_t output;
    uint32_t decoder_initialized;

    int proxy_mode;
} SvtJpegXsDecodeContext;

static int set_pix_fmt(void *logctx, const svt_jpeg_xs_image_config_t *config)
{
    int ret = AVERROR_BUG;

    switch (config->format) {
    case COLOUR_FORMAT_PLANAR_YUV420:
        if (config->bit_depth == 8)
            return AV_PIX_FMT_YUV420P;
        else if (config->bit_depth == 10)
            return AV_PIX_FMT_YUV420P10LE;
        else if (config->bit_depth == 12)
            return AV_PIX_FMT_YUV420P12LE;
        else
            return AV_PIX_FMT_YUV420P14LE;
        break;
    case COLOUR_FORMAT_PLANAR_YUV422:
        if (config->bit_depth == 8)
            return AV_PIX_FMT_YUV422P;
        else if (config->bit_depth == 10)
            return AV_PIX_FMT_YUV422P10LE;
        else if (config->bit_depth == 12)
            return AV_PIX_FMT_YUV422P12LE;
        else
            return AV_PIX_FMT_YUV422P14LE;
        break;
    case COLOUR_FORMAT_PLANAR_YUV444_OR_RGB:
        if (config->bit_depth == 8)
            return AV_PIX_FMT_YUV444P;
        else if (config->bit_depth == 10)
            return AV_PIX_FMT_YUV444P10LE;
        else if (config->bit_depth == 12)
            return AV_PIX_FMT_YUV444P12LE;
        else
            return AV_PIX_FMT_YUV444P14LE;
        break;
    default:
        av_log(logctx, AV_LOG_ERROR, "Unsupported pixel format.\n");
        ret = AVERROR_INVALIDDATA;
        break;
    }

    return ret;
}

static int svt_jpegxs_dec_decode(AVCodecContext* avctx, AVFrame* picture, int* got_frame, AVPacket* avpkt)
{
    SvtJpegXsDecodeContext* svt_dec = avctx->priv_data;
    SvtJxsErrorType_t err = SvtJxsErrorNone;
    uint32_t frame_size;
    int ret;

    err = svt_jpeg_xs_decoder_get_single_frame_size_with_proxy(
        avpkt->data, avpkt->size, &svt_dec->config, &frame_size, 1 /*quick search*/, svt_dec->decoder.proxy_mode);
    if (err) {
        av_log(avctx, AV_LOG_ERROR, "svt_jpeg_xs_decoder_get_single_frame_size_with_proxy failed, err=%d\n", err);
        return AVERROR_EXTERNAL;
    }
    if (avpkt->size < frame_size) {
        av_log(avctx, AV_LOG_ERROR, "Not enough data in a packet.\n");
        return AVERROR(EINVAL);
    }
    if (avpkt->size > frame_size) {
        av_log(avctx, AV_LOG_ERROR, "Single packet have data for more than one frame.\n");
        return AVERROR(EINVAL);
    }

    ret = set_pix_fmt(avctx, &svt_dec->config);
    if (ret < 0)
        return ret;

    if (!svt_dec->decoder_initialized || ret != avctx->pix_fmt ||
        avctx->width != svt_dec->config.width || avctx->height != svt_dec->config.height) {
        if (svt_dec->decoder_initialized)
            svt_jpeg_xs_decoder_close(&svt_dec->decoder);
        err = svt_jpeg_xs_decoder_init(SVT_JPEGXS_API_VER_MAJOR, SVT_JPEGXS_API_VER_MINOR,
                                       &svt_dec->decoder, avpkt->data, avpkt->size, &svt_dec->config);
        if (err) {
            av_log(avctx, AV_LOG_ERROR, "svt_jpeg_xs_decoder_init failed, err=%d\n", err);
            return AVERROR_EXTERNAL;
        }

        avctx->pix_fmt = ret;

        ret = ff_set_dimensions(avctx, svt_dec->config.width, svt_dec->config.height);
        if (ret < 0) {
            av_log(avctx, AV_LOG_ERROR, "ff_set_dimensions failed, err=%d\n", ret);
            return ret;
        }

        svt_dec->decoder_initialized = 1;
    }

    if (avctx->skip_frame == AVDISCARD_ALL)
        return 0;

    svt_dec->input.bitstream.buffer = avpkt->data;
    svt_dec->input.bitstream.allocation_size = avpkt->size;
    svt_dec->input.bitstream.used_size = avpkt->size;
    svt_dec->input.user_prv_ctx_ptr = avpkt;

    ret = ff_get_buffer(avctx, picture, 0);
    if (ret < 0)
        return ret;

    unsigned pixel_shift = svt_dec->config.bit_depth <= 8 ? 0 : 1;
    for (int comp = 0; comp < svt_dec->config.components_num; comp++) {
        svt_dec->input.image.data_yuv[comp] = picture->data[comp];
        svt_dec->input.image.stride[comp] = picture->linesize[comp] >> pixel_shift;
        svt_dec->input.image.alloc_size[comp] = picture->linesize[comp] * svt_dec->config.components[comp].height;
    }

    err = svt_jpeg_xs_decoder_send_frame(&svt_dec->decoder, &svt_dec->input, 1 /*blocking*/);
    if (err) {
        av_log(avctx, AV_LOG_ERROR, "svt_jpeg_xs_decoder_send_frame failed, err=%d\n", err);
        return AVERROR_EXTERNAL;
    }

    err = svt_jpeg_xs_decoder_get_frame(&svt_dec->decoder, &svt_dec->output, 1 /*blocking*/);
    if (err) {
        av_log(avctx, AV_LOG_ERROR, "svt_jpeg_xs_decoder_get_frame failed, err=%d\n", err);
        return AVERROR_EXTERNAL;
    }

    if (svt_dec->output.user_prv_ctx_ptr != avpkt) {
        av_log(avctx, AV_LOG_ERROR, "Returned different user_prv_ctx_ptr than expected\n");
        return AVERROR_EXTERNAL;
    }

    *got_frame = 1;

    return avpkt->size;
}

static av_cold int svt_jpegxs_dec_free(AVCodecContext* avctx)
{
    SvtJpegXsDecodeContext* svt_dec = avctx->priv_data;

    svt_jpeg_xs_decoder_close(&svt_dec->decoder);

    return 0;
}

static av_cold int svt_jpegxs_dec_init(AVCodecContext* avctx)
{
    SvtJpegXsDecodeContext* svt_dec = avctx->priv_data;

    int log_level = av_log_get_level();
    svt_dec->decoder.verbose = log_level < AV_LOG_DEBUG ? VERBOSE_ERRORS :
                                  log_level == AV_LOG_DEBUG ? VERBOSE_SYSTEM_INFO : VERBOSE_WARNINGS;

    if (avctx->lowres == 1)
        svt_dec->decoder.proxy_mode = proxy_mode_half;
    else if (avctx->lowres == 2)
        svt_dec->decoder.proxy_mode = proxy_mode_quarter;
    else
        svt_dec->decoder.proxy_mode = proxy_mode_full;

    int thread_count = avctx->thread_count ? avctx->thread_count : av_cpu_count();
    svt_dec->decoder.threads_num = FFMIN(thread_count, 64);
    svt_dec->decoder.use_cpu_flags = CPU_FLAGS_ALL;

    return 0;
}

const FFCodec ff_libsvtjpegxs_decoder = {
    .p.name         = "libsvtjpegxs",
    CODEC_LONG_NAME("SVT JPEG XS(Scalable Video Technology for JPEG XS) decoder"),
    .p.type         = AVMEDIA_TYPE_VIDEO,
    .p.id           = AV_CODEC_ID_JPEGXS,
    .priv_data_size = sizeof(SvtJpegXsDecodeContext),
    .init           = svt_jpegxs_dec_init,
    .close          = svt_jpegxs_dec_free,
    FF_CODEC_DECODE_CB(svt_jpegxs_dec_decode),
    .p.capabilities = AV_CODEC_CAP_OTHER_THREADS | AV_CODEC_CAP_DR1,
    .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                      FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM |
                      FF_CODEC_CAP_AUTO_THREADS,
    .p.max_lowres   = 2,
    .p.wrapper_name = "libsvtjpegxs",
};