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