avcodec/qsvenc: Added PicTiming SEI
[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 & 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.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 & AV_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 & AV_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->rc_max_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->extco.PicTimingSEI         = q->pic_timing_sei ?
150                                         MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
151
152         q->extparam[0] = (mfxExtBuffer *)&q->extco;
153
154         q->param.ExtParam    = q->extparam;
155         q->param.NumExtParam = FF_ARRAY_ELEMS(q->extparam);
156     }
157
158     return 0;
159 }
160
161 static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
162 {
163     uint8_t sps_buf[128];
164     uint8_t pps_buf[128];
165
166     mfxExtCodingOptionSPSPPS extradata = {
167         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
168         .Header.BufferSz = sizeof(extradata),
169         .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
170         .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
171     };
172
173     mfxExtBuffer *ext_buffers[] = {
174         (mfxExtBuffer*)&extradata,
175     };
176
177     int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
178     int ret;
179
180     q->param.ExtParam    = ext_buffers;
181     q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
182
183     ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
184     if (ret < 0)
185         return ff_qsv_error(ret);
186
187     q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
188
189     if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)) {
190         av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
191         return AVERROR_UNKNOWN;
192     }
193
194     avctx->extradata = av_malloc(extradata.SPSBufSize + need_pps * extradata.PPSBufSize +
195                                  AV_INPUT_BUFFER_PADDING_SIZE);
196     if (!avctx->extradata)
197         return AVERROR(ENOMEM);
198
199     memcpy(avctx->extradata,                        sps_buf, extradata.SPSBufSize);
200     if (need_pps)
201         memcpy(avctx->extradata + extradata.SPSBufSize, pps_buf, extradata.PPSBufSize);
202     avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
203     memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
204
205     return 0;
206 }
207
208 int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
209 {
210     int ret;
211
212     q->param.IOPattern  = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
213     q->param.AsyncDepth = q->async_depth;
214
215     q->async_fifo = av_fifo_alloc((1 + q->async_depth) *
216                                   (sizeof(AVPacket) + sizeof(mfxSyncPoint) + sizeof(mfxBitstream*)));
217     if (!q->async_fifo)
218         return AVERROR(ENOMEM);
219
220     if (avctx->hwaccel_context) {
221         AVQSVContext *qsv = avctx->hwaccel_context;
222
223         q->session         = qsv->session;
224         q->param.IOPattern = qsv->iopattern;
225     }
226
227     if (!q->session) {
228         ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
229                                            q->load_plugins);
230         if (ret < 0)
231             return ret;
232
233         q->session = q->internal_qs.session;
234     }
235
236     ret = init_video_param(avctx, q);
237     if (ret < 0)
238         return ret;
239
240     ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
241     if (ret < 0) {
242         av_log(avctx, AV_LOG_ERROR, "Error querying the encoding parameters\n");
243         return ff_qsv_error(ret);
244     }
245
246     ret = MFXVideoENCODE_Init(q->session, &q->param);
247     if (MFX_WRN_PARTIAL_ACCELERATION==ret) {
248         av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
249     } else if (ret < 0) {
250         av_log(avctx, AV_LOG_ERROR, "Error initializing the encoder\n");
251         return ff_qsv_error(ret);
252     }
253
254     ret = qsv_retrieve_enc_params(avctx, q);
255     if (ret < 0) {
256         av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
257         return ret;
258     }
259
260     q->avctx = avctx;
261
262     return 0;
263 }
264
265 static void clear_unused_frames(QSVEncContext *q)
266 {
267     QSVFrame *cur = q->work_frames;
268     while (cur) {
269         if (cur->surface && !cur->surface->Data.Locked) {
270             cur->surface = NULL;
271             av_frame_unref(cur->frame);
272         }
273         cur = cur->next;
274     }
275 }
276
277 static int get_free_frame(QSVEncContext *q, QSVFrame **f)
278 {
279     QSVFrame *frame, **last;
280
281     clear_unused_frames(q);
282
283     frame = q->work_frames;
284     last  = &q->work_frames;
285     while (frame) {
286         if (!frame->surface) {
287             *f = frame;
288             return 0;
289         }
290
291         last  = &frame->next;
292         frame = frame->next;
293     }
294
295     frame = av_mallocz(sizeof(*frame));
296     if (!frame)
297         return AVERROR(ENOMEM);
298     frame->frame = av_frame_alloc();
299     if (!frame->frame) {
300         av_freep(&frame);
301         return AVERROR(ENOMEM);
302     }
303     *last = frame;
304
305     *f = frame;
306
307     return 0;
308 }
309
310 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
311                         mfxFrameSurface1 **surface)
312 {
313     QSVFrame *qf;
314     int ret;
315
316     ret = get_free_frame(q, &qf);
317     if (ret < 0)
318         return ret;
319
320     if (frame->format == AV_PIX_FMT_QSV) {
321         ret = av_frame_ref(qf->frame, frame);
322         if (ret < 0)
323             return ret;
324
325         qf->surface = (mfxFrameSurface1*)qf->frame->data[3];
326         *surface = qf->surface;
327         return 0;
328     }
329
330     /* make a copy if the input is not padded as libmfx requires */
331     if (     frame->height & (q->height_align - 1) ||
332         frame->linesize[0] & (q->width_align - 1)) {
333         qf->frame->height = FFALIGN(frame->height, q->height_align);
334         qf->frame->width  = FFALIGN(frame->width, q->width_align);
335
336         ret = ff_get_buffer(q->avctx, qf->frame, AV_GET_BUFFER_FLAG_REF);
337         if (ret < 0)
338             return ret;
339
340         qf->frame->height = frame->height;
341         qf->frame->width  = frame->width;
342         ret = av_frame_copy(qf->frame, frame);
343         if (ret < 0) {
344             av_frame_unref(qf->frame);
345             return ret;
346         }
347     } else {
348         ret = av_frame_ref(qf->frame, frame);
349         if (ret < 0)
350             return ret;
351     }
352
353     qf->surface_internal.Info = q->param.mfx.FrameInfo;
354
355     qf->surface_internal.Info.PicStruct =
356         !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
357         frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :
358                                    MFX_PICSTRUCT_FIELD_BFF;
359     if (frame->repeat_pict == 1)
360         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
361     else if (frame->repeat_pict == 2)
362         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
363     else if (frame->repeat_pict == 4)
364         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
365
366     qf->surface_internal.Data.PitchLow  = qf->frame->linesize[0];
367     qf->surface_internal.Data.Y         = qf->frame->data[0];
368     qf->surface_internal.Data.UV        = qf->frame->data[1];
369     qf->surface_internal.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
370
371     qf->surface = &qf->surface_internal;
372
373     *surface = qf->surface;
374
375     return 0;
376 }
377
378 static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
379 {
380     if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
381         if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
382             q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
383             q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
384             av_log(avctx, AV_LOG_WARNING,
385                    "Interlaced coding is supported"
386                    " at Main/High Profile Level 2.1-4.1\n");
387     }
388 }
389
390 int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q,
391                   AVPacket *pkt, const AVFrame *frame, int *got_packet)
392 {
393     AVPacket new_pkt = { 0 };
394     mfxBitstream *bs;
395
396     mfxFrameSurface1 *surf = NULL;
397     mfxSyncPoint sync      = NULL;
398     int ret;
399
400     if (frame) {
401         ret = submit_frame(q, frame, &surf);
402         if (ret < 0) {
403             av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
404             return ret;
405         }
406     }
407
408     ret = av_new_packet(&new_pkt, q->packet_size);
409     if (ret < 0) {
410         av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
411         return ret;
412     }
413
414     bs = av_mallocz(sizeof(*bs));
415     if (!bs) {
416         av_packet_unref(&new_pkt);
417         return AVERROR(ENOMEM);
418     }
419     bs->Data      = new_pkt.data;
420     bs->MaxLength = new_pkt.size;
421
422     do {
423         ret = MFXVideoENCODE_EncodeFrameAsync(q->session, NULL, surf, bs, &sync);
424         if (ret == MFX_WRN_DEVICE_BUSY) {
425             av_usleep(500);
426             continue;
427         }
428         break;
429     } while ( 1 );
430
431     if (ret < 0) {
432         av_packet_unref(&new_pkt);
433         av_freep(&bs);
434         if (ret == MFX_ERR_MORE_DATA)
435             return 0;
436         av_log(avctx, AV_LOG_ERROR, "EncodeFrameAsync returned %d\n", ret);
437         return ff_qsv_error(ret);
438     }
439
440     if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM) {
441         if (frame->interlaced_frame)
442             print_interlace_msg(avctx, q);
443         else
444             av_log(avctx, AV_LOG_WARNING,
445                    "EncodeFrameAsync returned 'incompatible param' code\n");
446     }
447     if (sync) {
448         av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
449         av_fifo_generic_write(q->async_fifo, &sync,    sizeof(sync),    NULL);
450         av_fifo_generic_write(q->async_fifo, &bs,      sizeof(bs),    NULL);
451     } else {
452         av_packet_unref(&new_pkt);
453         av_freep(&bs);
454     }
455
456     if (!av_fifo_space(q->async_fifo) ||
457         (!frame && av_fifo_size(q->async_fifo))) {
458         av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
459         av_fifo_generic_read(q->async_fifo, &sync,    sizeof(sync),    NULL);
460         av_fifo_generic_read(q->async_fifo, &bs,      sizeof(bs),      NULL);
461
462         MFXVideoCORE_SyncOperation(q->session, sync, 60000);
463
464         new_pkt.dts  = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
465         new_pkt.pts  = av_rescale_q(bs->TimeStamp,       (AVRational){1, 90000}, avctx->time_base);
466         new_pkt.size = bs->DataLength;
467
468         if (bs->FrameType & MFX_FRAMETYPE_IDR ||
469             bs->FrameType & MFX_FRAMETYPE_xIDR)
470             new_pkt.flags |= AV_PKT_FLAG_KEY;
471
472 #if FF_API_CODED_FRAME
473 FF_DISABLE_DEPRECATION_WARNINGS
474         if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
475             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
476         else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
477             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_P;
478         else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
479             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_B;
480 FF_ENABLE_DEPRECATION_WARNINGS
481 #endif
482
483         av_freep(&bs);
484
485         if (pkt->data) {
486             if (pkt->size < new_pkt.size) {
487                 av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
488                        pkt->size, new_pkt.size);
489                 av_packet_unref(&new_pkt);
490                 return AVERROR(EINVAL);
491             }
492
493             memcpy(pkt->data, new_pkt.data, new_pkt.size);
494             pkt->size = new_pkt.size;
495
496             ret = av_packet_copy_props(pkt, &new_pkt);
497             av_packet_unref(&new_pkt);
498             if (ret < 0)
499                 return ret;
500         } else
501             *pkt = new_pkt;
502
503         *got_packet = 1;
504     }
505
506     return 0;
507 }
508
509 int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
510 {
511     QSVFrame *cur;
512
513     MFXVideoENCODE_Close(q->session);
514     q->session = NULL;
515
516     ff_qsv_close_internal_session(&q->internal_qs);
517
518     cur = q->work_frames;
519     while (cur) {
520         q->work_frames = cur->next;
521         av_frame_free(&cur->frame);
522         av_freep(&cur);
523         cur = q->work_frames;
524     }
525
526     while (q->async_fifo && av_fifo_size(q->async_fifo)) {
527         AVPacket pkt;
528         mfxSyncPoint sync;
529         mfxBitstream *bs;
530
531         av_fifo_generic_read(q->async_fifo, &pkt,  sizeof(pkt),  NULL);
532         av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
533         av_fifo_generic_read(q->async_fifo, &bs,   sizeof(bs),   NULL);
534
535         av_freep(&bs);
536         av_packet_unref(&pkt);
537     }
538     av_fifo_free(q->async_fifo);
539     q->async_fifo = NULL;
540
541     return 0;
542 }