[libav.git] / doc / examples / qsvdec.c

/*
 * Copyright (c) 2015 Anton Khirnov
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/**
 * @file
 * Intel QSV-accelerated H.264 decoding example.
 *
 * @example qsvdec.c
 * This example shows how to do QSV-accelerated H.264 decoding with output
 * frames in the VA-API video surfaces.
 */

#include "config.h"

#include <stdio.h>

#include <mfx/mfxvideo.h>

#include <va/va.h>
#include <va/va_x11.h>
#include <X11/Xlib.h>

#include "libavformat/avformat.h"
#include "libavformat/avio.h"

#include "libavcodec/avcodec.h"
#include "libavcodec/qsv.h"

#include "libavutil/error.h"
#include "libavutil/mem.h"

typedef struct DecodeContext {
    mfxSession mfx_session;
    VADisplay va_dpy;

    VASurfaceID *surfaces;
    mfxMemId    *surface_ids;
    int         *surface_used;
    int       nb_surfaces;

    mfxFrameInfo frame_info;
} DecodeContext;

static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
                             mfxFrameAllocResponse *resp)
{
    DecodeContext *decode = pthis;
    int err, i;

    if (decode->surfaces) {
        fprintf(stderr, "Multiple allocation requests.\n");
        return MFX_ERR_MEMORY_ALLOC;
    }
    if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)) {
        fprintf(stderr, "Unsupported surface type: %d\n", req->Type);
        return MFX_ERR_UNSUPPORTED;
    }
    if (req->Info.BitDepthLuma != 8 || req->Info.BitDepthChroma != 8 ||
        req->Info.Shift || req->Info.FourCC != MFX_FOURCC_NV12 ||
        req->Info.ChromaFormat != MFX_CHROMAFORMAT_YUV420) {
        fprintf(stderr, "Unsupported surface properties.\n");
        return MFX_ERR_UNSUPPORTED;
    }

    decode->surfaces     = av_malloc_array (req->NumFrameSuggested, sizeof(*decode->surfaces));
    decode->surface_ids  = av_malloc_array (req->NumFrameSuggested, sizeof(*decode->surface_ids));
    decode->surface_used = av_mallocz_array(req->NumFrameSuggested, sizeof(*decode->surface_used));
    if (!decode->surfaces || !decode->surface_ids || !decode->surface_used)
        goto fail;

    err = vaCreateSurfaces(decode->va_dpy, VA_RT_FORMAT_YUV420,
                           req->Info.Width, req->Info.Height,
                           decode->surfaces, req->NumFrameSuggested,
                           NULL, 0);
    if (err != VA_STATUS_SUCCESS) {
        fprintf(stderr, "Error allocating VA surfaces\n");
        goto fail;
    }
    decode->nb_surfaces = req->NumFrameSuggested;

    for (i = 0; i < decode->nb_surfaces; i++)
        decode->surface_ids[i] = &decode->surfaces[i];

    resp->mids           = decode->surface_ids;
    resp->NumFrameActual = decode->nb_surfaces;

    decode->frame_info = req->Info;

    return MFX_ERR_NONE;
fail:
    av_freep(&decode->surfaces);
    av_freep(&decode->surface_ids);
    av_freep(&decode->surface_used);

    return MFX_ERR_MEMORY_ALLOC;
}

static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
{
    DecodeContext *decode = pthis;

    if (decode->surfaces)
        vaDestroySurfaces(decode->va_dpy, decode->surfaces, decode->nb_surfaces);
    av_freep(&decode->surfaces);
    av_freep(&decode->surface_ids);
    av_freep(&decode->surface_used);
    decode->nb_surfaces = 0;

    return MFX_ERR_NONE;
}

static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
{
    return MFX_ERR_UNSUPPORTED;
}

static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
{
    return MFX_ERR_UNSUPPORTED;
}

static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
{
    *hdl = mid;
    return MFX_ERR_NONE;
}

static void free_buffer(void *opaque, uint8_t *data)
{
    int *used = opaque;
    *used = 0;
    av_freep(&data);
}

static int get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
{
    DecodeContext *decode = avctx->opaque;

    mfxFrameSurface1 *surf;
    AVBufferRef *surf_buf;
    int idx;

    for (idx = 0; idx < decode->nb_surfaces; idx++) {
        if (!decode->surface_used[idx])
            break;
    }
    if (idx == decode->nb_surfaces) {
        fprintf(stderr, "No free surfaces\n");
        return AVERROR(ENOMEM);
    }

    surf = av_mallocz(sizeof(*surf));
    if (!surf)
        return AVERROR(ENOMEM);
    surf_buf = av_buffer_create((uint8_t*)surf, sizeof(*surf), free_buffer,
                                &decode->surface_used[idx], AV_BUFFER_FLAG_READONLY);
    if (!surf_buf) {
        av_freep(&surf);
        return AVERROR(ENOMEM);
    }

    surf->Info       = decode->frame_info;
    surf->Data.MemId = &decode->surfaces[idx];

    frame->buf[0]  = surf_buf;
    frame->data[3] = (uint8_t*)surf;

    decode->surface_used[idx] = 1;

    return 0;
}

static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
{
    while (*pix_fmts != AV_PIX_FMT_NONE) {
        if (*pix_fmts == AV_PIX_FMT_QSV) {
            if (!avctx->hwaccel_context) {
                DecodeContext *decode = avctx->opaque;
                AVQSVContext *qsv = av_qsv_alloc_context();
                if (!qsv)
                    return AV_PIX_FMT_NONE;

                qsv->session   = decode->mfx_session;
                qsv->iopattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY;

                avctx->hwaccel_context = qsv;
            }

            return AV_PIX_FMT_QSV;
        }

        pix_fmts++;
    }

    fprintf(stderr, "The QSV pixel format not offered in get_format()\n");

    return AV_PIX_FMT_NONE;
}

static int decode_packet(DecodeContext *decode, AVCodecContext *decoder_ctx,
                         AVFrame *frame, AVPacket *pkt,
                         AVIOContext *output_ctx)
{
    int ret = 0;
    int got_frame = 1;

    while (pkt->size > 0 || (!pkt->data && got_frame)) {
        ret = avcodec_decode_video2(decoder_ctx, frame, &got_frame, pkt);
        if (ret < 0) {
            fprintf(stderr, "Error during decoding\n");
            return ret;
        }

        pkt->data += ret;
        pkt->size -= ret;

        /* A real program would do something useful with the decoded frame here.
         * We just retrieve the raw data and write it to a file, which is rather
         * useless but pedagogic. */
        if (got_frame) {
            mfxFrameSurface1 *surf = (mfxFrameSurface1*)frame->data[3];
            VASurfaceID    surface = *(VASurfaceID*)surf->Data.MemId;

            VAImageFormat img_fmt = {
                .fourcc         = VA_FOURCC_NV12,
                .byte_order     = VA_LSB_FIRST,
                .bits_per_pixel = 8,
                .depth          = 8,
            };

            VAImage img;

            VAStatus err;
            uint8_t *data;
            int i, j;

            img.buf      = VA_INVALID_ID;
            img.image_id = VA_INVALID_ID;

            err = vaCreateImage(decode->va_dpy, &img_fmt,
                                frame->width, frame->height, &img);
            if (err != VA_STATUS_SUCCESS) {
                fprintf(stderr, "Error creating an image: %s\n",
                        vaErrorStr(err));
                ret = AVERROR_UNKNOWN;
                goto fail;
            }

            err = vaGetImage(decode->va_dpy, surface, 0, 0,
                             frame->width, frame->height,
                             img.image_id);
            if (err != VA_STATUS_SUCCESS) {
                fprintf(stderr, "Error getting an image: %s\n",
                        vaErrorStr(err));
                ret = AVERROR_UNKNOWN;
                goto fail;
            }

            err = vaMapBuffer(decode->va_dpy, img.buf, (void**)&data);
            if (err != VA_STATUS_SUCCESS) {
                fprintf(stderr, "Error mapping the image buffer: %s\n",
                        vaErrorStr(err));
                ret = AVERROR_UNKNOWN;
                goto fail;
            }

            for (i = 0; i < img.num_planes; i++)
                for (j = 0; j < (img.height >> (i > 0)); j++)
                    avio_write(output_ctx, data + img.offsets[i] + j * img.pitches[i], img.width);

fail:
            if (img.buf != VA_INVALID_ID)
                vaUnmapBuffer(decode->va_dpy, img.buf);
            if (img.image_id != VA_INVALID_ID)
                vaDestroyImage(decode->va_dpy, img.image_id);
            av_frame_unref(frame);

            if (ret < 0)
                return ret;
        }
    }

    return 0;
}

int main(int argc, char **argv)
{
    AVFormatContext *input_ctx = NULL;
    AVStream *video_st = NULL;
    AVCodecContext *decoder_ctx = NULL;
    const AVCodec *decoder;

    AVPacket pkt = { 0 };
    AVFrame *frame = NULL;

    DecodeContext decode = { NULL };

    Display *dpy = NULL;
    int va_ver_major, va_ver_minor;

    mfxIMPL mfx_impl = MFX_IMPL_AUTO_ANY;
    mfxVersion mfx_ver = { { 1, 1 } };

    mfxFrameAllocator frame_allocator = {
        .pthis = &decode,
        .Alloc = frame_alloc,
        .Lock  = frame_lock,
        .Unlock = frame_unlock,
        .GetHDL = frame_get_hdl,
        .Free   = frame_free,
    };

    AVIOContext *output_ctx = NULL;

    int ret, i, err;

    av_register_all();

    if (argc < 3) {
        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
        return 1;
    }

    /* open the input file */
    ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
        goto finish;
    }

    /* find the first H.264 video stream */
    for (i = 0; i < input_ctx->nb_streams; i++) {
        AVStream *st = input_ctx->streams[i];

        if (st->codec->codec_id == AV_CODEC_ID_H264 && !video_st)
            video_st = st;
        else
            st->discard = AVDISCARD_ALL;
    }
    if (!video_st) {
        fprintf(stderr, "No H.264 video stream in the input file\n");
        goto finish;
    }

    /* initialize VA-API */
    dpy = XOpenDisplay(NULL);
    if (!dpy) {
        fprintf(stderr, "Cannot open the X display\n");
        goto finish;
    }
    decode.va_dpy = vaGetDisplay(dpy);
    if (!decode.va_dpy) {
        fprintf(stderr, "Cannot open the VA display\n");
        goto finish;
    }

    err = vaInitialize(decode.va_dpy, &va_ver_major, &va_ver_minor);
    if (err != VA_STATUS_SUCCESS) {
        fprintf(stderr, "Cannot initialize VA: %s\n", vaErrorStr(err));
        goto finish;
    }
    fprintf(stderr, "Initialized VA v%d.%d\n", va_ver_major, va_ver_minor);

    /* initialize an MFX session */
    err = MFXInit(mfx_impl, &mfx_ver, &decode.mfx_session);
    if (err != MFX_ERR_NONE) {
        fprintf(stderr, "Error initializing an MFX session\n");
        goto finish;
    }

    MFXVideoCORE_SetHandle(decode.mfx_session, MFX_HANDLE_VA_DISPLAY, decode.va_dpy);
    MFXVideoCORE_SetFrameAllocator(decode.mfx_session, &frame_allocator);

    /* initialize the decoder */
    decoder = avcodec_find_decoder_by_name("h264_qsv");
    if (!decoder) {
        fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
        goto finish;
    }

    decoder_ctx = avcodec_alloc_context3(decoder);
    if (!decoder_ctx) {
        ret = AVERROR(ENOMEM);
        goto finish;
    }
    decoder_ctx->codec_id = AV_CODEC_ID_H264;
    if (video_st->codec->extradata_size) {
        decoder_ctx->extradata = av_mallocz(video_st->codec->extradata_size +
                                            AV_INPUT_BUFFER_PADDING_SIZE);
        if (!decoder_ctx->extradata) {
            ret = AVERROR(ENOMEM);
            goto finish;
        }
        memcpy(decoder_ctx->extradata, video_st->codec->extradata,
               video_st->codec->extradata_size);
        decoder_ctx->extradata_size = video_st->codec->extradata_size;
    }
    decoder_ctx->refcounted_frames = 1;

    decoder_ctx->opaque      = &decode;
    decoder_ctx->get_buffer2 = get_buffer;
    decoder_ctx->get_format  = get_format;

    ret = avcodec_open2(decoder_ctx, NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Error opening the decoder: ");
        goto finish;
    }

    /* open the output stream */
    ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
    if (ret < 0) {
        fprintf(stderr, "Error opening the output context: ");
        goto finish;
    }

    frame = av_frame_alloc();
    if (!frame) {
        ret = AVERROR(ENOMEM);
        goto finish;
    }

    /* actual decoding */
    while (ret >= 0) {
        ret = av_read_frame(input_ctx, &pkt);
        if (ret < 0)
            break;

        if (pkt.stream_index == video_st->index)
            ret = decode_packet(&decode, decoder_ctx, frame, &pkt, output_ctx);

        av_packet_unref(&pkt);
    }

    /* flush the decoder */
    pkt.data = NULL;
    pkt.size = 0;
    ret = decode_packet(&decode, decoder_ctx, frame, &pkt, output_ctx);

finish:
    if (ret < 0) {
        char buf[1024];
        av_strerror(ret, buf, sizeof(buf));
        fprintf(stderr, "%s\n", buf);
    }

    avformat_close_input(&input_ctx);

    av_frame_free(&frame);

    if (decode.mfx_session)
        MFXClose(decode.mfx_session);
    if (decode.va_dpy)
        vaTerminate(decode.va_dpy);
    if (dpy)
        XCloseDisplay(dpy);

    if (decoder_ctx)
        av_freep(&decoder_ctx->hwaccel_context);
    avcodec_free_context(&decoder_ctx);

    avio_close(output_ctx);

    return ret;
}
Commit	Line	Data
990e4a66 AK	1	/*
	2	* Copyright (c) 2015 Anton Khirnov
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a copy
	5	* of this software and associated documentation files (the "Software"), to deal
	6	* in the Software without restriction, including without limitation the rights
	7	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	8	* copies of the Software, and to permit persons to whom the Software is
	9	* furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*
	14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	17	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	18	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	19	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	20	* THE SOFTWARE.
	21	*/
	22
	23	/**
	24	* @file
	25	* Intel QSV-accelerated H.264 decoding example.
	26	*
	27	* @example qsvdec.c
	28	* This example shows how to do QSV-accelerated H.264 decoding with output
	29	* frames in the VA-API video surfaces.
	30	*/
	31
	32	#include "config.h"
	33
	34	#include <stdio.h>
	35
	36	#include <mfx/mfxvideo.h>
	37
	38	#include <va/va.h>
	39	#include <va/va_x11.h>
	40	#include <X11/Xlib.h>
	41
	42	#include "libavformat/avformat.h"
	43	#include "libavformat/avio.h"
	44
	45	#include "libavcodec/avcodec.h"
	46	#include "libavcodec/qsv.h"
	47
	48	#include "libavutil/error.h"
	49	#include "libavutil/mem.h"
	50
	51	typedef struct DecodeContext {
	52	mfxSession mfx_session;
	53	VADisplay va_dpy;
	54
	55	VASurfaceID *surfaces;
	56	mfxMemId *surface_ids;
	57	int *surface_used;
	58	int nb_surfaces;
	59
	60	mfxFrameInfo frame_info;
	61	} DecodeContext;
	62
	63	static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
	64	mfxFrameAllocResponse *resp)
65	{
66	DecodeContext *decode = pthis;
67	int err, i;
68
69	if (decode->surfaces) {
70	fprintf(stderr, "Multiple allocation requests.\n");
71	return MFX_ERR_MEMORY_ALLOC;
72	}
73	if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)) {
74	fprintf(stderr, "Unsupported surface type: %d\n", req->Type);
75	return MFX_ERR_UNSUPPORTED;
76	}
77	if (req->Info.BitDepthLuma != 8 \|\| req->Info.BitDepthChroma != 8 \|\|
78	req->Info.Shift \|\| req->Info.FourCC != MFX_FOURCC_NV12 \|\|
79	req->Info.ChromaFormat != MFX_CHROMAFORMAT_YUV420) {
80	fprintf(stderr, "Unsupported surface properties.\n");
81	return MFX_ERR_UNSUPPORTED;
82	}
83
84	decode->surfaces = av_malloc_array (req->NumFrameSuggested, sizeof(*decode->surfaces));
85	decode->surface_ids = av_malloc_array (req->NumFrameSuggested, sizeof(*decode->surface_ids));
86	decode->surface_used = av_mallocz_array(req->NumFrameSuggested, sizeof(*decode->surface_used));
87	if (!decode->surfaces \|\| !decode->surface_ids \|\| !decode->surface_used)
88	goto fail;
89
90	err = vaCreateSurfaces(decode->va_dpy, VA_RT_FORMAT_YUV420,
91	req->Info.Width, req->Info.Height,
92	decode->surfaces, req->NumFrameSuggested,
93	NULL, 0);
94	if (err != VA_STATUS_SUCCESS) {
95	fprintf(stderr, "Error allocating VA surfaces\n");
96	goto fail;
97	}
98	decode->nb_surfaces = req->NumFrameSuggested;
99
100	for (i = 0; i < decode->nb_surfaces; i++)
101	decode->surface_ids[i] = &decode->surfaces[i];
102
103	resp->mids = decode->surface_ids;
104	resp->NumFrameActual = decode->nb_surfaces;
105
106	decode->frame_info = req->Info;
107
108	return MFX_ERR_NONE;
109	fail:
110	av_freep(&decode->surfaces);
111	av_freep(&decode->surface_ids);
112	av_freep(&decode->surface_used);
113
114	return MFX_ERR_MEMORY_ALLOC;
115	}
116
117	static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
118	{
119	DecodeContext *decode = pthis;
120
121	if (decode->surfaces)
122	vaDestroySurfaces(decode->va_dpy, decode->surfaces, decode->nb_surfaces);
123	av_freep(&decode->surfaces);
124	av_freep(&decode->surface_ids);
125	av_freep(&decode->surface_used);
126	decode->nb_surfaces = 0;
127
128	return MFX_ERR_NONE;
129	}
130
131	static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
132	{
133	return MFX_ERR_UNSUPPORTED;
134	}
135
136	static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
137	{
138	return MFX_ERR_UNSUPPORTED;
139	}
140
141	static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
142	{
143	*hdl = mid;
144	return MFX_ERR_NONE;
145	}
146
147	static void free_buffer(void opaque, uint8_t data)
148	{
149	int *used = opaque;
150	*used = 0;
151	av_freep(&data);
152	}
153
154	static int get_buffer(AVCodecContext avctx, AVFrame frame, int flags)
155	{
156	DecodeContext *decode = avctx->opaque;
157
158	mfxFrameSurface1 *surf;
159	AVBufferRef *surf_buf;
160	int idx;
161
162	for (idx = 0; idx < decode->nb_surfaces; idx++) {
163	if (!decode->surface_used[idx])
164	break;
165	}
166	if (idx == decode->nb_surfaces) {
167	fprintf(stderr, "No free surfaces\n");
168	return AVERROR(ENOMEM);
169	}
170
171	surf = av_mallocz(sizeof(*surf));
172	if (!surf)
173	return AVERROR(ENOMEM);
174	surf_buf = av_buffer_create((uint8_t)surf, sizeof(surf), free_buffer,
175	&decode->surface_used[idx], AV_BUFFER_FLAG_READONLY);
176	if (!surf_buf) {
177	av_freep(&surf);
178	return AVERROR(ENOMEM);
179	}
180
181	surf->Info = decode->frame_info;
182	surf->Data.MemId = &decode->surfaces[idx];
183
184	frame->buf[0] = surf_buf;
185	frame->data[3] = (uint8_t*)surf;
186
187	decode->surface_used[idx] = 1;
188
189	return 0;
190	}
191
192	static int get_format(AVCodecContext avctx, const enum AVPixelFormat pix_fmts)
193	{
194	while (*pix_fmts != AV_PIX_FMT_NONE) {
195	if (*pix_fmts == AV_PIX_FMT_QSV) {
196	if (!avctx->hwaccel_context) {
197	DecodeContext *decode = avctx->opaque;
198	AVQSVContext *qsv = av_qsv_alloc_context();
199	if (!qsv)
200	return AV_PIX_FMT_NONE;
201
202	qsv->session = decode->mfx_session;
203	qsv->iopattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY;
204
205	avctx->hwaccel_context = qsv;
206	}
207
208	return AV_PIX_FMT_QSV;
209	}
210
211	pix_fmts++;
212	}
213
214	fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
215
216	return AV_PIX_FMT_NONE;
217	}
218
219	static int decode_packet(DecodeContext decode, AVCodecContext decoder_ctx,
220	AVFrame frame, AVPacket pkt,
221	AVIOContext *output_ctx)
222	{
223	int ret = 0;
224	int got_frame = 1;
225
226	while (pkt->size > 0 \|\| (!pkt->data && got_frame)) {
227	ret = avcodec_decode_video2(decoder_ctx, frame, &got_frame, pkt);
228	if (ret < 0) {
229	fprintf(stderr, "Error during decoding\n");
230	return ret;
231	}
232
233	pkt->data += ret;
234	pkt->size -= ret;
235
236	/* A real program would do something useful with the decoded frame here.
237	* We just retrieve the raw data and write it to a file, which is rather
238	* useless but pedagogic. */
239	if (got_frame) {
240	mfxFrameSurface1 surf = (mfxFrameSurface1)frame->data[3];
241	VASurfaceID surface = (VASurfaceID)surf->Data.MemId;
242
243	VAImageFormat img_fmt = {
244	.fourcc = VA_FOURCC_NV12,
245	.byte_order = VA_LSB_FIRST,
246	.bits_per_pixel = 8,
247	.depth = 8,
248	};
249
250	VAImage img;
251
252	VAStatus err;
253	uint8_t *data;
254	int i, j;
255
256	img.buf = VA_INVALID_ID;
257	img.image_id = VA_INVALID_ID;
258
259	err = vaCreateImage(decode->va_dpy, &img_fmt,
260	frame->width, frame->height, &img);
261	if (err != VA_STATUS_SUCCESS) {
262	fprintf(stderr, "Error creating an image: %s\n",
263	vaErrorStr(err));
264	ret = AVERROR_UNKNOWN;
265	goto fail;
266	}
267
268	err = vaGetImage(decode->va_dpy, surface, 0, 0,
269	frame->width, frame->height,
270	img.image_id);
271	if (err != VA_STATUS_SUCCESS) {
272	fprintf(stderr, "Error getting an image: %s\n",
273	vaErrorStr(err));
274	ret = AVERROR_UNKNOWN;
275	goto fail;
276	}
277
278	err = vaMapBuffer(decode->va_dpy, img.buf, (void**)&data);
279	if (err != VA_STATUS_SUCCESS) {
280	fprintf(stderr, "Error mapping the image buffer: %s\n",
281	vaErrorStr(err));
282	ret = AVERROR_UNKNOWN;
283	goto fail;
284	}
285
286	for (i = 0; i < img.num_planes; i++)
287	for (j = 0; j < (img.height >> (i > 0)); j++)
288	avio_write(output_ctx, data + img.offsets[i] + j * img.pitches[i], img.width);
289
290	fail:
291	if (img.buf != VA_INVALID_ID)
292	vaUnmapBuffer(decode->va_dpy, img.buf);
293	if (img.image_id != VA_INVALID_ID)
294	vaDestroyImage(decode->va_dpy, img.image_id);
295	av_frame_unref(frame);
296
297	if (ret < 0)
298	return ret;
299	}
300	}
301
302	return 0;
303	}
304
305	int main(int argc, char **argv)
306	{
307	AVFormatContext *input_ctx = NULL;
308	AVStream *video_st = NULL;
309	AVCodecContext *decoder_ctx = NULL;
310	const AVCodec *decoder;
311
312	AVPacket pkt = { 0 };
313	AVFrame *frame = NULL;
314
315	DecodeContext decode = { NULL };
316
317	Display *dpy = NULL;
318	int va_ver_major, va_ver_minor;
319
320	mfxIMPL mfx_impl = MFX_IMPL_AUTO_ANY;
321	mfxVersion mfx_ver = { { 1, 1 } };
322
323	mfxFrameAllocator frame_allocator = {
324	.pthis = &decode,
325	.Alloc = frame_alloc,
326	.Lock = frame_lock,
327	.Unlock = frame_unlock,
328	.GetHDL = frame_get_hdl,
329	.Free = frame_free,
330	};
331
332	AVIOContext *output_ctx = NULL;
333
334	int ret, i, err;
335
336	av_register_all();
337
338	if (argc < 3) {
339	fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
340	return 1;
341	}
342
343	/* open the input file */
344	ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
345	if (ret < 0) {
346	fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
347	goto finish;
348	}
349
350	/* find the first H.264 video stream */
351	for (i = 0; i < input_ctx->nb_streams; i++) {
352	AVStream *st = input_ctx->streams[i];
353
354	if (st->codec->codec_id == AV_CODEC_ID_H264 && !video_st)
355	video_st = st;
356	else
357	st->discard = AVDISCARD_ALL;
358	}
359	if (!video_st) {
360	fprintf(stderr, "No H.264 video stream in the input file\n");
361	goto finish;
362	}
363
364	/* initialize VA-API */
365	dpy = XOpenDisplay(NULL);
366	if (!dpy) {
367	fprintf(stderr, "Cannot open the X display\n");
368	goto finish;
369	}
370	decode.va_dpy = vaGetDisplay(dpy);
371	if (!decode.va_dpy) {
372	fprintf(stderr, "Cannot open the VA display\n");
373	goto finish;
374	}
375
376	err = vaInitialize(decode.va_dpy, &va_ver_major, &va_ver_minor);
377	if (err != VA_STATUS_SUCCESS) {
378	fprintf(stderr, "Cannot initialize VA: %s\n", vaErrorStr(err));
379	goto finish;
380	}
381	fprintf(stderr, "Initialized VA v%d.%d\n", va_ver_major, va_ver_minor);
382
383	/* initialize an MFX session */
384	err = MFXInit(mfx_impl, &mfx_ver, &decode.mfx_session);
385	if (err != MFX_ERR_NONE) {
386	fprintf(stderr, "Error initializing an MFX session\n");
387	goto finish;
388	}
389
390	MFXVideoCORE_SetHandle(decode.mfx_session, MFX_HANDLE_VA_DISPLAY, decode.va_dpy);
391	MFXVideoCORE_SetFrameAllocator(decode.mfx_session, &frame_allocator);
392
393	/* initialize the decoder */
394	decoder = avcodec_find_decoder_by_name("h264_qsv");
395	if (!decoder) {
396	fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
397	goto finish;
398	}
399
400	decoder_ctx = avcodec_alloc_context3(decoder);
401	if (!decoder_ctx) {
402	ret = AVERROR(ENOMEM);
403	goto finish;
404	}
405	decoder_ctx->codec_id = AV_CODEC_ID_H264;
406	if (video_st->codec->extradata_size) {
407	decoder_ctx->extradata = av_mallocz(video_st->codec->extradata_size +
059a9348	408	AV_INPUT_BUFFER_PADDING_SIZE);
990e4a66 AK	409	if (!decoder_ctx->extradata) {
	410	ret = AVERROR(ENOMEM);
	411	goto finish;
	412	}
	413	memcpy(decoder_ctx->extradata, video_st->codec->extradata,
	414	video_st->codec->extradata_size);
	415	decoder_ctx->extradata_size = video_st->codec->extradata_size;
	416	}
	417	decoder_ctx->refcounted_frames = 1;
	418
	419	decoder_ctx->opaque = &decode;
	420	decoder_ctx->get_buffer2 = get_buffer;
	421	decoder_ctx->get_format = get_format;
	422
	423	ret = avcodec_open2(decoder_ctx, NULL, NULL);
	424	if (ret < 0) {
	425	fprintf(stderr, "Error opening the decoder: ");
	426	goto finish;
	427	}
	428
	429	/* open the output stream */
	430	ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
	431	if (ret < 0) {
	432	fprintf(stderr, "Error opening the output context: ");
	433	goto finish;
	434	}
	435
	436	frame = av_frame_alloc();
	437	if (!frame) {
	438	ret = AVERROR(ENOMEM);
	439	goto finish;
	440	}
	441
	442	/* actual decoding */
	443	while (ret >= 0) {
	444	ret = av_read_frame(input_ctx, &pkt);
	445	if (ret < 0)
	446	break;
	447
	448	if (pkt.stream_index == video_st->index)
	449	ret = decode_packet(&decode, decoder_ctx, frame, &pkt, output_ctx);
	450
	451	av_packet_unref(&pkt);
	452	}
	453
	454	/* flush the decoder */
	455	pkt.data = NULL;
	456	pkt.size = 0;
	457	ret = decode_packet(&decode, decoder_ctx, frame, &pkt, output_ctx);
	458
	459	finish:
	460	if (ret < 0) {
	461	char buf[1024];
	462	av_strerror(ret, buf, sizeof(buf));
	463	fprintf(stderr, "%s\n", buf);
	464	}
	465
	466	avformat_close_input(&input_ctx);
	467
	468	av_frame_free(&frame);
	469
	470	if (decode.mfx_session)
	471	MFXClose(decode.mfx_session);
	472	if (decode.va_dpy)
473	vaTerminate(decode.va_dpy);
474	if (dpy)
475	XCloseDisplay(dpy);
476
477	if (decoder_ctx)
478	av_freep(&decoder_ctx->hwaccel_context);
479	avcodec_free_context(&decoder_ctx);
480
481	avio_close(output_ctx);
482
483	return ret;
484	}