71ac3ce05840e617ced5e79dc69b5a8a62e6451b
[ffmpeg.git] / libavcodec / qsvenc.c
1 /*
2  * Intel MediaSDK QSV encoder utility functions
3  *
4  * copyright (c) 2013 Yukinori Yamazoe
5  * copyright (c) 2015 Anton Khirnov
6  *
7  * This file is part of Libav.
8  *
9  * Libav is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * Libav is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with Libav; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 #include <string.h>
25 #include <sys/types.h>
26 #include <mfx/mfxvideo.h>
27
28 #include "libavutil/common.h"
29 #include "libavutil/mem.h"
30 #include "libavutil/log.h"
31 #include "libavutil/time.h"
32 #include "libavutil/imgutils.h"
33
34 #include "avcodec.h"
35 #include "internal.h"
36 #include "qsv.h"
37 #include "qsv_internal.h"
38 #include "qsvenc.h"
39
40 static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
41 {
42     const char *ratecontrol_desc;
43
44     float quant;
45     int ret;
46
47     ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
48     if (ret < 0)
49         return AVERROR_BUG;
50     q->param.mfx.CodecId = ret;
51
52     q->width_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
53
54     if (avctx->level > 0)
55         q->param.mfx.CodecLevel = avctx->level;
56
57     q->param.mfx.CodecProfile       = q->profile;
58     q->param.mfx.TargetUsage        = q->preset;
59     q->param.mfx.GopPicSize         = FFMAX(0, avctx->gop_size);
60     q->param.mfx.GopRefDist         = FFMAX(-1, avctx->max_b_frames) + 1;
61     q->param.mfx.GopOptFlag         = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
62                                       MFX_GOP_CLOSED : 0;
63     q->param.mfx.IdrInterval        = q->idr_interval;
64     q->param.mfx.NumSlice           = avctx->slices;
65     q->param.mfx.NumRefFrame        = FFMAX(0, avctx->refs);
66     q->param.mfx.EncodedOrder       = 0;
67     q->param.mfx.BufferSizeInKB     = 0;
68
69     q->param.mfx.FrameInfo.FourCC         = MFX_FOURCC_NV12;
70     q->param.mfx.FrameInfo.Width          = FFALIGN(avctx->width, q->width_align);
71     q->param.mfx.FrameInfo.Height         = FFALIGN(avctx->height, 32);
72     q->param.mfx.FrameInfo.CropX          = 0;
73     q->param.mfx.FrameInfo.CropY          = 0;
74     q->param.mfx.FrameInfo.CropW          = avctx->width;
75     q->param.mfx.FrameInfo.CropH          = avctx->height;
76     q->param.mfx.FrameInfo.AspectRatioW   = avctx->sample_aspect_ratio.num;
77     q->param.mfx.FrameInfo.AspectRatioH   = avctx->sample_aspect_ratio.den;
78     q->param.mfx.FrameInfo.PicStruct      = MFX_PICSTRUCT_PROGRESSIVE;
79     q->param.mfx.FrameInfo.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
80     q->param.mfx.FrameInfo.BitDepthLuma   = 8;
81     q->param.mfx.FrameInfo.BitDepthChroma = 8;
82
83     if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
84         q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
85         q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
86     } else {
87         q->param.mfx.FrameInfo.FrameRateExtN  = avctx->time_base.den;
88         q->param.mfx.FrameInfo.FrameRateExtD  = avctx->time_base.num;
89     }
90
91     if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
92         q->param.mfx.RateControlMethod = MFX_RATECONTROL_CQP;
93         ratecontrol_desc = "constant quantization parameter (CQP)";
94     } else if (avctx->rc_max_rate == avctx->bit_rate) {
95         q->param.mfx.RateControlMethod = MFX_RATECONTROL_CBR;
96         ratecontrol_desc = "constant bitrate (CBR)";
97     } else if (!avctx->rc_max_rate) {
98         q->param.mfx.RateControlMethod = MFX_RATECONTROL_AVBR;
99         ratecontrol_desc = "average variable bitrate (AVBR)";
100     } else {
101         q->param.mfx.RateControlMethod = MFX_RATECONTROL_VBR;
102         ratecontrol_desc = "variable bitrate (VBR)";
103     }
104
105     av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", ratecontrol_desc);
106
107     switch (q->param.mfx.RateControlMethod) {
108     case MFX_RATECONTROL_CBR:
109     case MFX_RATECONTROL_VBR:
110         q->param.mfx.InitialDelayInKB = avctx->rc_initial_buffer_occupancy / 1000;
111         q->param.mfx.TargetKbps       = avctx->bit_rate / 1000;
112         q->param.mfx.MaxKbps          = avctx->bit_rate / 1000;
113         break;
114     case MFX_RATECONTROL_CQP:
115         quant = avctx->global_quality / FF_QP2LAMBDA;
116
117         q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
118         q->param.mfx.QPP = av_clip(quant, 0, 51);
119         q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
120
121         break;
122     case MFX_RATECONTROL_AVBR:
123         q->param.mfx.TargetKbps  = avctx->bit_rate / 1000;
124         q->param.mfx.Convergence = q->avbr_convergence;
125         q->param.mfx.Accuracy    = q->avbr_accuracy;
126         break;
127     }
128
129     // the HEVC encoder plugin currently fails if coding options
130     // are provided
131     if (avctx->codec_id != AV_CODEC_ID_HEVC) {
132         q->extco.Header.BufferId      = MFX_EXTBUFF_CODING_OPTION;
133         q->extco.Header.BufferSz      = sizeof(q->extco);
134         q->extco.CAVLC                = avctx->coder_type == FF_CODER_TYPE_VLC ?
135                                         MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
136
137         q->extparam_internal[0] = (mfxExtBuffer *)&q->extco;
138     }
139
140     return 0;
141 }
142
143 static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
144 {
145     uint8_t sps_buf[128];
146     uint8_t pps_buf[128];
147
148     mfxExtCodingOptionSPSPPS extradata = {
149         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
150         .Header.BufferSz = sizeof(extradata),
151         .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
152         .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
153     };
154
155     mfxExtBuffer *ext_buffers[] = {
156         (mfxExtBuffer*)&extradata,
157     };
158
159     int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
160     int ret;
161
162     q->param.ExtParam    = ext_buffers;
163     q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
164
165     ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
166     if (ret < 0)
167         return ff_qsv_error(ret);
168
169     q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
170
171     if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)) {
172         av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
173         return AVERROR_UNKNOWN;
174     }
175
176     avctx->extradata = av_malloc(extradata.SPSBufSize + need_pps * extradata.PPSBufSize +
177                                  AV_INPUT_BUFFER_PADDING_SIZE);
178     if (!avctx->extradata)
179         return AVERROR(ENOMEM);
180
181     memcpy(avctx->extradata,                        sps_buf, extradata.SPSBufSize);
182     if (need_pps)
183         memcpy(avctx->extradata + extradata.SPSBufSize, pps_buf, extradata.PPSBufSize);
184     avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
185     memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
186
187     return 0;
188 }
189
190 int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
191 {
192     int ret;
193
194     q->param.IOPattern  = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
195     q->param.AsyncDepth = q->async_depth;
196
197     q->async_fifo = av_fifo_alloc((1 + q->async_depth) *
198                                   (sizeof(AVPacket) + sizeof(mfxSyncPoint) + sizeof(mfxBitstream*)));
199     if (!q->async_fifo)
200         return AVERROR(ENOMEM);
201
202     if (avctx->hwaccel_context) {
203         AVQSVContext *qsv = avctx->hwaccel_context;
204
205         q->session         = qsv->session;
206         q->param.IOPattern = qsv->iopattern;
207     }
208
209     if (!q->session) {
210         ret = ff_qsv_init_internal_session(avctx, &q->internal_session,
211                                            q->load_plugins);
212         if (ret < 0)
213             return ret;
214
215         q->session = q->internal_session;
216     }
217
218     ret = init_video_param(avctx, q);
219     if (ret < 0)
220         return ret;
221
222     ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
223     if (ret < 0) {
224         av_log(avctx, AV_LOG_ERROR, "Error querying the encoding parameters\n");
225         return ff_qsv_error(ret);
226     }
227
228     if (avctx->hwaccel_context) {
229         AVQSVContext *qsv = avctx->hwaccel_context;
230         int i, j;
231
232         q->extparam = av_mallocz_array(qsv->nb_ext_buffers + FF_ARRAY_ELEMS(q->extparam_internal),
233                                        sizeof(*q->extparam));
234         if (!q->extparam)
235             return AVERROR(ENOMEM);
236
237         q->param.ExtParam = q->extparam;
238         for (i = 0; i < qsv->nb_ext_buffers; i++)
239             q->param.ExtParam[i] = qsv->ext_buffers[i];
240         q->param.NumExtParam = qsv->nb_ext_buffers;
241
242         for (i = 0; i < FF_ARRAY_ELEMS(q->extparam_internal); i++) {
243             for (j = 0; j < qsv->nb_ext_buffers; j++) {
244                 if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
245                     break;
246             }
247             if (j < qsv->nb_ext_buffers)
248                 continue;
249
250             q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
251         }
252     } else {
253         q->param.ExtParam    = q->extparam_internal;
254         q->param.NumExtParam = FF_ARRAY_ELEMS(q->extparam_internal);
255     }
256
257     ret = MFXVideoENCODE_Init(q->session, &q->param);
258     if (ret < 0) {
259         av_log(avctx, AV_LOG_ERROR, "Error initializing the encoder\n");
260         return ff_qsv_error(ret);
261     }
262
263     ret = qsv_retrieve_enc_params(avctx, q);
264     if (ret < 0) {
265         av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
266         return ret;
267     }
268
269     q->avctx = avctx;
270
271     return 0;
272 }
273
274 static void clear_unused_frames(QSVEncContext *q)
275 {
276     QSVFrame *cur = q->work_frames;
277     while (cur) {
278         if (cur->surface && !cur->surface->Data.Locked) {
279             cur->surface = NULL;
280             av_frame_unref(cur->frame);
281         }
282         cur = cur->next;
283     }
284 }
285
286 static int get_free_frame(QSVEncContext *q, QSVFrame **f)
287 {
288     QSVFrame *frame, **last;
289
290     clear_unused_frames(q);
291
292     frame = q->work_frames;
293     last  = &q->work_frames;
294     while (frame) {
295         if (!frame->surface) {
296             *f = frame;
297             return 0;
298         }
299
300         last  = &frame->next;
301         frame = frame->next;
302     }
303
304     frame = av_mallocz(sizeof(*frame));
305     if (!frame)
306         return AVERROR(ENOMEM);
307     frame->frame = av_frame_alloc();
308     if (!frame->frame) {
309         av_freep(&frame);
310         return AVERROR(ENOMEM);
311     }
312     *last = frame;
313
314     *f = frame;
315
316     return 0;
317 }
318
319 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
320                         mfxFrameSurface1 **surface)
321 {
322     QSVFrame *qf;
323     int ret;
324
325     ret = get_free_frame(q, &qf);
326     if (ret < 0)
327         return ret;
328
329     if (frame->format == AV_PIX_FMT_QSV) {
330         ret = av_frame_ref(qf->frame, frame);
331         if (ret < 0)
332             return ret;
333
334         qf->surface = (mfxFrameSurface1*)qf->frame->data[3];
335     } else {
336     /* make a copy if the input is not padded as libmfx requires */
337     if (frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) {
338         qf->frame->height = FFALIGN(frame->height, 32);
339         qf->frame->width  = FFALIGN(frame->width, q->width_align);
340
341         ret = ff_get_buffer(q->avctx, qf->frame, AV_GET_BUFFER_FLAG_REF);
342         if (ret < 0)
343             return ret;
344
345         qf->frame->height = frame->height;
346         qf->frame->width  = frame->width;
347         ret = av_frame_copy(qf->frame, frame);
348         if (ret < 0) {
349             av_frame_unref(qf->frame);
350             return ret;
351         }
352     } else {
353         ret = av_frame_ref(qf->frame, frame);
354         if (ret < 0)
355             return ret;
356     }
357
358     qf->surface_internal.Info = q->param.mfx.FrameInfo;
359
360     qf->surface_internal.Info.PicStruct =
361         !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
362         frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :
363                                    MFX_PICSTRUCT_FIELD_BFF;
364     if (frame->repeat_pict == 1)
365         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
366     else if (frame->repeat_pict == 2)
367         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
368     else if (frame->repeat_pict == 4)
369         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
370
371     qf->surface_internal.Data.PitchLow  = qf->frame->linesize[0];
372     qf->surface_internal.Data.Y         = qf->frame->data[0];
373     qf->surface_internal.Data.UV        = qf->frame->data[1];
374
375     qf->surface = &qf->surface_internal;
376     }
377
378     qf->surface->Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
379
380     *surface = qf->surface;
381
382     return 0;
383 }
384
385 static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
386 {
387     if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
388         if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
389             q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
390             q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
391             av_log(avctx, AV_LOG_WARNING,
392                    "Interlaced coding is supported"
393                    " at Main/High Profile Level 2.1-4.1\n");
394     }
395 }
396
397 int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q,
398                   AVPacket *pkt, const AVFrame *frame, int *got_packet)
399 {
400     AVPacket new_pkt = { 0 };
401     mfxBitstream *bs;
402
403     mfxFrameSurface1 *surf = NULL;
404     mfxSyncPoint sync      = NULL;
405     int ret;
406
407     if (frame) {
408         ret = submit_frame(q, frame, &surf);
409         if (ret < 0) {
410             av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
411             return ret;
412         }
413     }
414
415     ret = av_new_packet(&new_pkt, q->packet_size);
416     if (ret < 0) {
417         av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
418         return ret;
419     }
420
421     bs = av_mallocz(sizeof(*bs));
422     if (!bs) {
423         av_packet_unref(&new_pkt);
424         return AVERROR(ENOMEM);
425     }
426     bs->Data      = new_pkt.data;
427     bs->MaxLength = new_pkt.size;
428
429     do {
430         ret = MFXVideoENCODE_EncodeFrameAsync(q->session, NULL, surf, bs, &sync);
431         if (ret == MFX_WRN_DEVICE_BUSY)
432             av_usleep(1);
433     } while (ret > 0);
434
435     if (ret < 0) {
436         av_packet_unref(&new_pkt);
437         av_freep(&bs);
438         return (ret == MFX_ERR_MORE_DATA) ? 0 : ff_qsv_error(ret);
439     }
440
441     if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
442         print_interlace_msg(avctx, q);
443
444     if (sync) {
445         av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
446         av_fifo_generic_write(q->async_fifo, &sync,    sizeof(sync),    NULL);
447         av_fifo_generic_write(q->async_fifo, &bs,      sizeof(bs),    NULL);
448     } else {
449         av_packet_unref(&new_pkt);
450         av_freep(&bs);
451     }
452
453     if (!av_fifo_space(q->async_fifo) ||
454         (!frame && av_fifo_size(q->async_fifo))) {
455         av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
456         av_fifo_generic_read(q->async_fifo, &sync,    sizeof(sync),    NULL);
457         av_fifo_generic_read(q->async_fifo, &bs,      sizeof(bs),      NULL);
458
459         MFXVideoCORE_SyncOperation(q->session, sync, 60000);
460
461         new_pkt.dts  = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
462         new_pkt.pts  = av_rescale_q(bs->TimeStamp,       (AVRational){1, 90000}, avctx->time_base);
463         new_pkt.size = bs->DataLength;
464
465         if (bs->FrameType & MFX_FRAMETYPE_IDR ||
466             bs->FrameType & MFX_FRAMETYPE_xIDR)
467             new_pkt.flags |= AV_PKT_FLAG_KEY;
468
469 #if FF_API_CODED_FRAME
470 FF_DISABLE_DEPRECATION_WARNINGS
471         if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
472             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
473         else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
474             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_P;
475         else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
476             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_B;
477 FF_ENABLE_DEPRECATION_WARNINGS
478 #endif
479
480         av_freep(&bs);
481
482         if (pkt->data) {
483             if (pkt->size < new_pkt.size) {
484                 av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
485                        pkt->size, new_pkt.size);
486                 av_packet_unref(&new_pkt);
487                 return AVERROR(EINVAL);
488             }
489
490             memcpy(pkt->data, new_pkt.data, new_pkt.size);
491             pkt->size = new_pkt.size;
492
493             ret = av_packet_copy_props(pkt, &new_pkt);
494             av_packet_unref(&new_pkt);
495             if (ret < 0)
496                 return ret;
497         } else
498             *pkt = new_pkt;
499
500         *got_packet = 1;
501     }
502
503     return 0;
504 }
505
506 int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
507 {
508     QSVFrame *cur;
509
510     if (q->session)
511         MFXVideoENCODE_Close(q->session);
512     if (q->internal_session)
513         MFXClose(q->internal_session);
514     q->session          = NULL;
515     q->internal_session = NULL;
516
517     cur = q->work_frames;
518     while (cur) {
519         q->work_frames = cur->next;
520         av_frame_free(&cur->frame);
521         av_freep(&cur);
522         cur = q->work_frames;
523     }
524
525     while (q->async_fifo && av_fifo_size(q->async_fifo)) {
526         AVPacket pkt;
527         mfxSyncPoint sync;
528         mfxBitstream *bs;
529
530         av_fifo_generic_read(q->async_fifo, &pkt,  sizeof(pkt),  NULL);
531         av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
532         av_fifo_generic_read(q->async_fifo, &bs,   sizeof(bs),   NULL);
533
534         av_freep(&bs);
535         av_packet_unref(&pkt);
536     }
537     av_fifo_free(q->async_fifo);
538     q->async_fifo = NULL;
539
540     av_freep(&q->extparam);
541
542     return 0;
543 }