FFmpeg/ffmpeg_qsv.c

/*
 * 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
 */

#include <mfx/mfxvideo.h>
#include <stdlib.h>

#include "libavutil/dict.h"
#include "libavutil/mem.h"
#include "libavutil/opt.h"
#include "libavcodec/qsv.h"

#include "ffmpeg.h"

typedef struct QSVContext {
    OutputStream *ost;

    mfxSession session;

    mfxExtOpaqueSurfaceAlloc opaque_alloc;
    AVBufferRef             *opaque_surfaces_buf;

    uint8_t           *surface_used;
    mfxFrameSurface1 **surface_ptrs;
    int nb_surfaces;

    mfxExtBuffer *ext_buffers[1];
} QSVContext;

static void buffer_release(void *opaque, uint8_t *data)
{
    *(uint8_t*)opaque = 0;
}

static int qsv_get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
{
    InputStream *ist = s->opaque;
    QSVContext  *qsv = ist->hwaccel_ctx;
    int i;

    for (i = 0; i < qsv->nb_surfaces; i++) {
        if (qsv->surface_used[i])
            continue;

        frame->buf[0] = av_buffer_create((uint8_t*)qsv->surface_ptrs[i], sizeof(*qsv->surface_ptrs[i]),
                                         buffer_release, &qsv->surface_used[i], 0);
        if (!frame->buf[0])
            return AVERROR(ENOMEM);
        frame->data[3]       = (uint8_t*)qsv->surface_ptrs[i];
        qsv->surface_used[i] = 1;
        return 0;
    }

    return AVERROR(ENOMEM);
}

static int init_opaque_surf(QSVContext *qsv)
{
    AVQSVContext *hwctx_enc = qsv->ost->enc_ctx->hwaccel_context;
    mfxFrameSurface1 *surfaces;
    int i;

    qsv->nb_surfaces = hwctx_enc->nb_opaque_surfaces;

    qsv->opaque_surfaces_buf = av_buffer_ref(hwctx_enc->opaque_surfaces);
    qsv->surface_ptrs        = av_mallocz_array(qsv->nb_surfaces, sizeof(*qsv->surface_ptrs));
    qsv->surface_used        = av_mallocz_array(qsv->nb_surfaces, sizeof(*qsv->surface_used));
    if (!qsv->opaque_surfaces_buf || !qsv->surface_ptrs || !qsv->surface_used)
        return AVERROR(ENOMEM);

    surfaces = (mfxFrameSurface1*)qsv->opaque_surfaces_buf->data;
    for (i = 0; i < qsv->nb_surfaces; i++)
        qsv->surface_ptrs[i] = surfaces + i;

    qsv->opaque_alloc.Out.Surfaces   = qsv->surface_ptrs;
    qsv->opaque_alloc.Out.NumSurface = qsv->nb_surfaces;
    qsv->opaque_alloc.Out.Type       = hwctx_enc->opaque_alloc_type;

    qsv->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
    qsv->opaque_alloc.Header.BufferSz = sizeof(qsv->opaque_alloc);
    qsv->ext_buffers[0]               = (mfxExtBuffer*)&qsv->opaque_alloc;

    return 0;
}

static void qsv_uninit(AVCodecContext *s)
{
    InputStream *ist = s->opaque;
    QSVContext  *qsv = ist->hwaccel_ctx;

    av_freep(&qsv->ost->enc_ctx->hwaccel_context);
    av_freep(&s->hwaccel_context);

    av_buffer_unref(&qsv->opaque_surfaces_buf);
    av_freep(&qsv->surface_used);
    av_freep(&qsv->surface_ptrs);

    av_freep(&qsv);
}

int qsv_init(AVCodecContext *s)
{
    InputStream *ist = s->opaque;
    QSVContext  *qsv = ist->hwaccel_ctx;
    AVQSVContext *hwctx_dec;
    int ret;

    if (!qsv) {
        av_log(NULL, AV_LOG_ERROR, "QSV transcoding is not initialized. "
               "-hwaccel qsv should only be used for one-to-one QSV transcoding "
               "with no filters.\n");
        return AVERROR_BUG;
    }

    ret = init_opaque_surf(qsv);
    if (ret < 0)
        return ret;

    hwctx_dec = av_qsv_alloc_context();
    if (!hwctx_dec)
        return AVERROR(ENOMEM);

    hwctx_dec->session        = qsv->session;
    hwctx_dec->iopattern      = MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
    hwctx_dec->ext_buffers    = qsv->ext_buffers;
    hwctx_dec->nb_ext_buffers = FF_ARRAY_ELEMS(qsv->ext_buffers);

    av_freep(&s->hwaccel_context);
    s->hwaccel_context = hwctx_dec;

    ist->hwaccel_get_buffer = qsv_get_buffer;
    ist->hwaccel_uninit     = qsv_uninit;

    return 0;
}

static mfxIMPL choose_implementation(const InputStream *ist)
{
    static const struct {
        const char *name;
        mfxIMPL     impl;
    } impl_map[] = {
        { "auto",     MFX_IMPL_AUTO         },
        { "sw",       MFX_IMPL_SOFTWARE     },
        { "hw",       MFX_IMPL_HARDWARE     },
        { "auto_any", MFX_IMPL_AUTO_ANY     },
        { "hw_any",   MFX_IMPL_HARDWARE_ANY },
        { "hw2",      MFX_IMPL_HARDWARE2    },
        { "hw3",      MFX_IMPL_HARDWARE3    },
        { "hw4",      MFX_IMPL_HARDWARE4    },
    };

    mfxIMPL impl = MFX_IMPL_AUTO_ANY;
    int i;

    if (ist->hwaccel_device) {
        for (i = 0; i < FF_ARRAY_ELEMS(impl_map); i++)
            if (!strcmp(ist->hwaccel_device, impl_map[i].name)) {
                impl = impl_map[i].impl;
                break;
            }
        if (i == FF_ARRAY_ELEMS(impl_map))
            impl = strtol(ist->hwaccel_device, NULL, 0);
    }

    return impl;
}

int qsv_transcode_init(OutputStream *ost)
{
    InputStream *ist;
    const enum AVPixelFormat *pix_fmt;

    AVDictionaryEntry *e;
    const AVOption *opt;
    int flags = 0;

    int err, i;

    QSVContext *qsv = NULL;
    AVQSVContext *hwctx = NULL;
    mfxIMPL impl;
    mfxVersion ver = { { 3, 1 } };

    /* check if the encoder supports QSV */
    if (!ost->enc->pix_fmts)
        return 0;
    for (pix_fmt = ost->enc->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++)
        if (*pix_fmt == AV_PIX_FMT_QSV)
            break;
    if (*pix_fmt == AV_PIX_FMT_NONE)
        return 0;

    if (strcmp(ost->avfilter, "null") || ost->source_index < 0)
        return 0;

    /* check if the decoder supports QSV and the output only goes to this stream */
    ist = input_streams[ost->source_index];
    if (ist->hwaccel_id != HWACCEL_QSV || !ist->dec || !ist->dec->pix_fmts)
        return 0;
    for (pix_fmt = ist->dec->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++)
        if (*pix_fmt == AV_PIX_FMT_QSV)
            break;
    if (*pix_fmt == AV_PIX_FMT_NONE)
        return 0;

    for (i = 0; i < nb_output_streams; i++)
        if (output_streams[i] != ost &&
            output_streams[i]->source_index == ost->source_index)
            return 0;

    av_log(NULL, AV_LOG_VERBOSE, "Setting up QSV transcoding\n");

    qsv   = av_mallocz(sizeof(*qsv));
    hwctx = av_qsv_alloc_context();
    if (!qsv || !hwctx)
        goto fail;

    impl = choose_implementation(ist);

    err = MFXInit(impl, &ver, &qsv->session);
    if (err != MFX_ERR_NONE) {
        av_log(NULL, AV_LOG_ERROR, "Error initializing an MFX session: %d\n", err);
        goto fail;
    }

    e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
    opt = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
    if (e && opt)
        av_opt_eval_flags(ost->enc_ctx, opt, e->value, &flags);

    qsv->ost = ost;

    hwctx->session                = qsv->session;
    hwctx->iopattern              = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
    hwctx->opaque_alloc           = 1;
    hwctx->nb_opaque_surfaces     = 16;

    ost->hwaccel_ctx              = qsv;
    ost->enc_ctx->hwaccel_context = hwctx;
    ost->enc_ctx->pix_fmt         = AV_PIX_FMT_QSV;

    ist->hwaccel_ctx              = qsv;
    ist->dec_ctx->pix_fmt         = AV_PIX_FMT_QSV;
    ist->resample_pix_fmt         = AV_PIX_FMT_QSV;

    return 0;

fail:
    av_freep(&hwctx);
    av_freep(&qsv);
    return AVERROR_UNKNOWN;
}