Merge commit '40cf1bbacc6220a0aa6bed5c331871d43f9ce370'
[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 FFmpeg.
8  *
9  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 & 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.CropX          = 0;
71     q->param.mfx.FrameInfo.CropY          = 0;
72     q->param.mfx.FrameInfo.CropW          = avctx->width;
73     q->param.mfx.FrameInfo.CropH          = avctx->height;
74     q->param.mfx.FrameInfo.AspectRatioW   = avctx->sample_aspect_ratio.num;
75     q->param.mfx.FrameInfo.AspectRatioH   = avctx->sample_aspect_ratio.den;
76     q->param.mfx.FrameInfo.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
77     q->param.mfx.FrameInfo.BitDepthLuma   = 8;
78     q->param.mfx.FrameInfo.BitDepthChroma = 8;
79     q->param.mfx.FrameInfo.Width          = FFALIGN(avctx->width, q->width_align);
80
81     if (avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
82        /* A true field layout (TFF or BFF) is not important here,
83           it will specified later during frame encoding. But it is important
84           to specify is frame progressive or not because allowed heigh alignment
85           does depend by this.
86         */
87         q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
88         q->height_align = 32;
89     } else {
90         q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
91         q->height_align = 16;
92     }
93    q->param.mfx.FrameInfo.Height    = FFALIGN(avctx->height, q->height_align);
94
95     if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
96         q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
97         q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
98     } else {
99         q->param.mfx.FrameInfo.FrameRateExtN  = avctx->time_base.den;
100         q->param.mfx.FrameInfo.FrameRateExtD  = avctx->time_base.num;
101     }
102
103     if (avctx->flags & CODEC_FLAG_QSCALE) {
104         q->param.mfx.RateControlMethod = MFX_RATECONTROL_CQP;
105         ratecontrol_desc = "constant quantization parameter (CQP)";
106     } else if (avctx->rc_max_rate == avctx->bit_rate) {
107         q->param.mfx.RateControlMethod = MFX_RATECONTROL_CBR;
108         ratecontrol_desc = "constant bitrate (CBR)";
109     } else if (!avctx->rc_max_rate) {
110         q->param.mfx.RateControlMethod = MFX_RATECONTROL_AVBR;
111         ratecontrol_desc = "average variable bitrate (AVBR)";
112     } else {
113         q->param.mfx.RateControlMethod = MFX_RATECONTROL_VBR;
114         ratecontrol_desc = "variable bitrate (VBR)";
115     }
116
117     av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", ratecontrol_desc);
118
119     switch (q->param.mfx.RateControlMethod) {
120     case MFX_RATECONTROL_CBR:
121     case MFX_RATECONTROL_VBR:
122         q->param.mfx.InitialDelayInKB = avctx->rc_initial_buffer_occupancy / 1000;
123         q->param.mfx.TargetKbps       = avctx->bit_rate / 1000;
124         q->param.mfx.MaxKbps          = avctx->bit_rate / 1000;
125         break;
126     case MFX_RATECONTROL_CQP:
127         quant = avctx->global_quality / FF_QP2LAMBDA;
128
129         q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
130         q->param.mfx.QPP = av_clip(quant, 0, 51);
131         q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
132
133         break;
134     case MFX_RATECONTROL_AVBR:
135         q->param.mfx.TargetKbps  = avctx->bit_rate / 1000;
136         q->param.mfx.Convergence = q->avbr_convergence;
137         q->param.mfx.Accuracy    = q->avbr_accuracy;
138         break;
139     }
140
141     // the HEVC encoder plugin currently fails if coding options
142     // are provided
143     if (avctx->codec_id != AV_CODEC_ID_HEVC) {
144         q->extco.Header.BufferId      = MFX_EXTBUFF_CODING_OPTION;
145         q->extco.Header.BufferSz      = sizeof(q->extco);
146         q->extco.CAVLC                = avctx->coder_type == FF_CODER_TYPE_VLC ?
147                                         MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
148
149         q->extparam[0] = (mfxExtBuffer *)&q->extco;
150
151         q->param.ExtParam    = q->extparam;
152         q->param.NumExtParam = FF_ARRAY_ELEMS(q->extparam);
153     }
154
155     return 0;
156 }
157
158 static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
159 {
160     uint8_t sps_buf[128];
161     uint8_t pps_buf[128];
162
163     mfxExtCodingOptionSPSPPS extradata = {
164         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
165         .Header.BufferSz = sizeof(extradata),
166         .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
167         .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
168     };
169
170     mfxExtBuffer *ext_buffers[] = {
171         (mfxExtBuffer*)&extradata,
172     };
173
174     int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
175     int ret;
176
177     q->param.ExtParam    = ext_buffers;
178     q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
179
180     ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
181     if (ret < 0)
182         return ff_qsv_error(ret);
183
184     q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
185
186     if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)) {
187         av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
188         return AVERROR_UNKNOWN;
189     }
190
191     avctx->extradata = av_malloc(extradata.SPSBufSize + need_pps * extradata.PPSBufSize +
192                                  FF_INPUT_BUFFER_PADDING_SIZE);
193     if (!avctx->extradata)
194         return AVERROR(ENOMEM);
195
196     memcpy(avctx->extradata,                        sps_buf, extradata.SPSBufSize);
197     if (need_pps)
198         memcpy(avctx->extradata + extradata.SPSBufSize, pps_buf, extradata.PPSBufSize);
199     avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
200     memset(avctx->extradata + avctx->extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
201
202     return 0;
203 }
204
205 int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
206 {
207     int ret;
208
209     q->param.IOPattern  = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
210     q->param.AsyncDepth = q->async_depth;
211
212     q->async_fifo = av_fifo_alloc((1 + q->async_depth) *
213                                   (sizeof(AVPacket) + sizeof(mfxSyncPoint) + sizeof(mfxBitstream*)));
214     if (!q->async_fifo)
215         return AVERROR(ENOMEM);
216
217     if (avctx->hwaccel_context) {
218         AVQSVContext *qsv = avctx->hwaccel_context;
219
220         q->session         = qsv->session;
221         q->param.IOPattern = qsv->iopattern;
222     }
223
224     if (!q->session) {
225         ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
226                                            q->load_plugins);
227         if (ret < 0)
228             return ret;
229
230         q->session = q->internal_qs.session;
231     }
232
233     ret = init_video_param(avctx, q);
234     if (ret < 0)
235         return ret;
236
237     ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
238     if (ret < 0) {
239         av_log(avctx, AV_LOG_ERROR, "Error querying the encoding parameters\n");
240         return ff_qsv_error(ret);
241     }
242
243     ret = MFXVideoENCODE_Init(q->session, &q->param);
244     if (MFX_WRN_PARTIAL_ACCELERATION==ret) {
245         av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
246     } else if (ret < 0) {
247         av_log(avctx, AV_LOG_ERROR, "Error initializing the encoder\n");
248         return ff_qsv_error(ret);
249     }
250
251     ret = qsv_retrieve_enc_params(avctx, q);
252     if (ret < 0) {
253         av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
254         return ret;
255     }
256
257     q->avctx = avctx;
258
259     return 0;
260 }
261
262 static void clear_unused_frames(QSVEncContext *q)
263 {
264     QSVFrame *cur = q->work_frames;
265     while (cur) {
266         if (cur->surface && !cur->surface->Data.Locked) {
267             cur->surface = NULL;
268             av_frame_unref(cur->frame);
269         }
270         cur = cur->next;
271     }
272 }
273
274 static int get_free_frame(QSVEncContext *q, QSVFrame **f)
275 {
276     QSVFrame *frame, **last;
277
278     clear_unused_frames(q);
279
280     frame = q->work_frames;
281     last  = &q->work_frames;
282     while (frame) {
283         if (!frame->surface) {
284             *f = frame;
285             return 0;
286         }
287
288         last  = &frame->next;
289         frame = frame->next;
290     }
291
292     frame = av_mallocz(sizeof(*frame));
293     if (!frame)
294         return AVERROR(ENOMEM);
295     frame->frame = av_frame_alloc();
296     if (!frame->frame) {
297         av_freep(&frame);
298         return AVERROR(ENOMEM);
299     }
300     *last = frame;
301
302     *f = frame;
303
304     return 0;
305 }
306
307 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
308                         mfxFrameSurface1 **surface)
309 {
310     QSVFrame *qf;
311     int ret;
312
313     ret = get_free_frame(q, &qf);
314     if (ret < 0)
315         return ret;
316
317     if (frame->format == AV_PIX_FMT_QSV) {
318         ret = av_frame_ref(qf->frame, frame);
319         if (ret < 0)
320             return ret;
321
322         qf->surface = (mfxFrameSurface1*)qf->frame->data[3];
323         *surface = qf->surface;
324         return 0;
325     }
326
327     /* make a copy if the input is not padded as libmfx requires */
328     if (     frame->height & (q->height_align - 1) ||
329         frame->linesize[0] & (q->width_align - 1)) {
330         qf->frame->height = FFALIGN(frame->height, q->height_align);
331         qf->frame->width  = FFALIGN(frame->width, q->width_align);
332
333         ret = ff_get_buffer(q->avctx, qf->frame, AV_GET_BUFFER_FLAG_REF);
334         if (ret < 0)
335             return ret;
336
337         qf->frame->height = frame->height;
338         qf->frame->width  = frame->width;
339         ret = av_frame_copy(qf->frame, frame);
340         if (ret < 0) {
341             av_frame_unref(qf->frame);
342             return ret;
343         }
344     } else {
345         ret = av_frame_ref(qf->frame, frame);
346         if (ret < 0)
347             return ret;
348     }
349
350     qf->surface_internal.Info = q->param.mfx.FrameInfo;
351
352     qf->surface_internal.Info.PicStruct =
353         !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
354         frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :
355                                    MFX_PICSTRUCT_FIELD_BFF;
356     if (frame->repeat_pict == 1)
357         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
358     else if (frame->repeat_pict == 2)
359         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
360     else if (frame->repeat_pict == 4)
361         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
362
363     qf->surface_internal.Data.PitchLow  = qf->frame->linesize[0];
364     qf->surface_internal.Data.Y         = qf->frame->data[0];
365     qf->surface_internal.Data.UV        = qf->frame->data[1];
366     qf->surface_internal.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
367
368     qf->surface = &qf->surface_internal;
369
370     *surface = qf->surface;
371
372     return 0;
373 }
374
375 static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
376 {
377     if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
378         if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
379             q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
380             q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
381             av_log(avctx, AV_LOG_WARNING,
382                    "Interlaced coding is supported"
383                    " at Main/High Profile Level 2.1-4.1\n");
384     }
385 }
386
387 int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q,
388                   AVPacket *pkt, const AVFrame *frame, int *got_packet)
389 {
390     AVPacket new_pkt = { 0 };
391     mfxBitstream *bs;
392
393     mfxFrameSurface1 *surf = NULL;
394     mfxSyncPoint sync      = NULL;
395     int ret;
396
397     if (frame) {
398         ret = submit_frame(q, frame, &surf);
399         if (ret < 0) {
400             av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
401             return ret;
402         }
403     }
404
405     ret = av_new_packet(&new_pkt, q->packet_size);
406     if (ret < 0) {
407         av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
408         return ret;
409     }
410
411     bs = av_mallocz(sizeof(*bs));
412     if (!bs) {
413         av_packet_unref(&new_pkt);
414         return AVERROR(ENOMEM);
415     }
416     bs->Data      = new_pkt.data;
417     bs->MaxLength = new_pkt.size;
418
419     do {
420         ret = MFXVideoENCODE_EncodeFrameAsync(q->session, NULL, surf, bs, &sync);
421         if (ret == MFX_WRN_DEVICE_BUSY) {
422             av_usleep(1);
423             continue;
424         }
425         break;
426     } while ( 1 );
427
428     if (ret < 0) {
429         av_packet_unref(&new_pkt);
430         av_freep(&bs);
431         if (ret == MFX_ERR_MORE_DATA)
432             return 0;
433         av_log(avctx, AV_LOG_ERROR, "EncodeFrameAsync returned %d\n", ret);
434         return ff_qsv_error(ret);
435     }
436
437     if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM) {
438         if (frame->interlaced_frame)
439             print_interlace_msg(avctx, q);
440         else
441             av_log(avctx, AV_LOG_WARNING,
442                    "EncodeFrameAsync returned 'incompatible param' code\n");
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     MFXVideoENCODE_Close(q->session);
511     q->session = NULL;
512
513     ff_qsv_close_internal_session(&q->internal_qs);
514
515     cur = q->work_frames;
516     while (cur) {
517         q->work_frames = cur->next;
518         av_frame_free(&cur->frame);
519         av_freep(&cur);
520         cur = q->work_frames;
521     }
522
523     while (q->async_fifo && av_fifo_size(q->async_fifo)) {
524         AVPacket pkt;
525         mfxSyncPoint sync;
526         mfxBitstream *bs;
527
528         av_fifo_generic_read(q->async_fifo, &pkt,  sizeof(pkt),  NULL);
529         av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
530         av_fifo_generic_read(q->async_fifo, &bs,   sizeof(bs),   NULL);
531
532         av_freep(&bs);
533         av_packet_unref(&pkt);
534     }
535     av_fifo_free(q->async_fifo);
536     q->async_fifo = NULL;
537
538     return 0;
539 }