git.sesse.net Git - ffmpeg/blob - 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     if (avctx->hwaccel_context) {
 213         AVQSVContext *qsv = avctx->hwaccel_context;
 214
 215         q->session         = qsv->session;
 216         q->param.IOPattern = qsv->iopattern;
 217     }
 218
 219     if (!q->session) {
 220         ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
 221                                            q->load_plugins);
 222         if (ret < 0)
 223             return ret;
 224
 225         q->session = q->internal_qs.session;
 226     }
 227
 228     ret = init_video_param(avctx, q);
 229     if (ret < 0)
 230         return ret;
 231
 232     ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
 233     if (ret < 0) {
 234         av_log(avctx, AV_LOG_ERROR, "Error querying the encoding parameters\n");
 235         return ff_qsv_error(ret);
 236     }
 237
 238     ret = MFXVideoENCODE_Init(q->session, &q->param);
 239     if (MFX_WRN_PARTIAL_ACCELERATION==ret) {
 240         av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
 241     } else if (ret < 0) {
 242         av_log(avctx, AV_LOG_ERROR, "Error initializing the encoder\n");
 243         return ff_qsv_error(ret);
 244     }
 245
 246     ret = qsv_retrieve_enc_params(avctx, q);
 247     if (ret < 0) {
 248         av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
 249         return ret;
 250     }
 251
 252     avctx->coded_frame = av_frame_alloc();
 253     if (!avctx->coded_frame)
 254         return AVERROR(ENOMEM);
 255
 256     q->avctx = avctx;
 257
 258     return 0;
 259 }
 260
 261 static void clear_unused_frames(QSVEncContext *q)
 262 {
 263     QSVFrame *cur = q->work_frames;
 264     while (cur) {
 265         if (cur->surface && !cur->surface->Data.Locked) {
 266             cur->surface = NULL;
 267             av_frame_unref(cur->frame);
 268         }
 269         cur = cur->next;
 270     }
 271 }
 272
 273 static int get_free_frame(QSVEncContext *q, QSVFrame **f)
 274 {
 275     QSVFrame *frame, **last;
 276
 277     clear_unused_frames(q);
 278
 279     frame = q->work_frames;
 280     last  = &q->work_frames;
 281     while (frame) {
 282         if (!frame->surface) {
 283             *f = frame;
 284             return 0;
 285         }
 286
 287         last  = &frame->next;
 288         frame = frame->next;
 289     }
 290
 291     frame = av_mallocz(sizeof(*frame));
 292     if (!frame)
 293         return AVERROR(ENOMEM);
 294     frame->frame = av_frame_alloc();
 295     if (!frame->frame) {
 296         av_freep(&frame);
 297         return AVERROR(ENOMEM);
 298     }
 299     *last = frame;
 300
 301     *f = frame;
 302
 303     return 0;
 304 }
 305
 306 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
 307                         mfxFrameSurface1 **surface)
 308 {
 309     QSVFrame *qf;
 310     int ret;
 311
 312     ret = get_free_frame(q, &qf);
 313     if (ret < 0)
 314         return ret;
 315
 316     if (frame->format == AV_PIX_FMT_QSV) {
 317         ret = av_frame_ref(qf->frame, frame);
 318         if (ret < 0)
 319             return ret;
 320
 321         qf->surface = (mfxFrameSurface1*)qf->frame->data[3];
 322         *surface = qf->surface;
 323         return 0;
 324     }
 325
 326     /* make a copy if the input is not padded as libmfx requires */
 327     if (     frame->height & (q->height_align - 1) ||
 328         frame->linesize[0] & (q->width_align - 1)) {
 329         qf->frame->height = FFALIGN(frame->height, q->height_align);
 330         qf->frame->width  = FFALIGN(frame->width, q->width_align);
 331
 332         ret = ff_get_buffer(q->avctx, qf->frame, AV_GET_BUFFER_FLAG_REF);
 333         if (ret < 0)
 334             return ret;
 335
 336         qf->frame->height = frame->height;
 337         qf->frame->width  = frame->width;
 338         ret = av_frame_copy(qf->frame, frame);
 339         if (ret < 0) {
 340             av_frame_unref(qf->frame);
 341             return ret;
 342         }
 343     } else {
 344         ret = av_frame_ref(qf->frame, frame);
 345         if (ret < 0)
 346             return ret;
 347     }
 348
 349     qf->surface_internal.Info = q->param.mfx.FrameInfo;
 350
 351     qf->surface_internal.Info.PicStruct =
 352         !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
 353         frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :
 354                                    MFX_PICSTRUCT_FIELD_BFF;
 355     if (frame->repeat_pict == 1)
 356         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
 357     else if (frame->repeat_pict == 2)
 358         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
 359     else if (frame->repeat_pict == 4)
 360         qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
 361
 362     qf->surface_internal.Data.PitchLow  = qf->frame->linesize[0];
 363     qf->surface_internal.Data.Y         = qf->frame->data[0];
 364     qf->surface_internal.Data.UV        = qf->frame->data[1];
 365     qf->surface_internal.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
 366
 367     qf->surface = &qf->surface_internal;
 368
 369     *surface = qf->surface;
 370
 371     return 0;
 372 }
 373
 374 static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
 375 {
 376     if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
 377         if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
 378             q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
 379             q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
 380             av_log(avctx, AV_LOG_WARNING,
 381                    "Interlaced coding is supported"
 382                    " at Main/High Profile Level 2.1-4.1\n");
 383     }
 384 }
 385
 386 int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q,
 387                   AVPacket *pkt, const AVFrame *frame, int *got_packet)
 388 {
 389     mfxBitstream bs = { { { 0 } } };
 390
 391     mfxFrameSurface1 *surf = NULL;
 392     mfxSyncPoint sync      = NULL;
 393     int ret;
 394
 395     if (frame) {
 396         ret = submit_frame(q, frame, &surf);
 397         if (ret < 0) {
 398             av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
 399             return ret;
 400         }
 401     }
 402
 403     ret = ff_alloc_packet(pkt, q->packet_size);
 404     if (ret < 0) {
 405         av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
 406         return ret;
 407     }
 408     bs.Data      = pkt->data;
 409     bs.MaxLength = pkt->size;
 410
 411     do {
 412         ret = MFXVideoENCODE_EncodeFrameAsync(q->session, NULL, surf, &bs, &sync);
 413         if (ret == MFX_WRN_DEVICE_BUSY) {
 414             av_usleep(1);
 415             continue;
 416         }
 417         break;
 418     } while ( 1 );
 419
 420     if (ret < 0) {
 421         if (ret == MFX_ERR_MORE_DATA)
 422             return 0;
 423         av_log(avctx, AV_LOG_ERROR, "EncodeFrameAsync returned %d\n", ret);
 424         return ff_qsv_error(ret);
 425     }
 426
 427     if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM) {
 428         if (frame->interlaced_frame)
 429             print_interlace_msg(avctx, q);
 430         else
 431             av_log(avctx, AV_LOG_WARNING,
 432                    "EncodeFrameAsync returned 'incompatible param' code\n");
 433     }
 434     if (sync) {
 435         MFXVideoCORE_SyncOperation(q->session, sync, 60000);
 436
 437         if (bs.FrameType & MFX_FRAMETYPE_I || bs.FrameType & MFX_FRAMETYPE_xI)
 438             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 439         else if (bs.FrameType & MFX_FRAMETYPE_P || bs.FrameType & MFX_FRAMETYPE_xP)
 440             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_P;
 441         else if (bs.FrameType & MFX_FRAMETYPE_B || bs.FrameType & MFX_FRAMETYPE_xB)
 442             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_B;
 443
 444         pkt->dts  = av_rescale_q(bs.DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
 445         pkt->pts  = av_rescale_q(bs.TimeStamp,       (AVRational){1, 90000}, avctx->time_base);
 446         pkt->size = bs.DataLength;
 447
 448         if (bs.FrameType & MFX_FRAMETYPE_IDR ||
 449             bs.FrameType & MFX_FRAMETYPE_xIDR)
 450             pkt->flags |= AV_PKT_FLAG_KEY;
 451
 452         *got_packet = 1;
 453     }
 454
 455     return 0;
 456 }
 457
 458 int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
 459 {
 460     QSVFrame *cur;
 461
 462     MFXVideoENCODE_Close(q->session);
 463     q->session = NULL;
 464
 465     ff_qsv_close_internal_session(&q->internal_qs);
 466
 467     cur = q->work_frames;
 468     while (cur) {
 469         q->work_frames = cur->next;
 470         av_frame_free(&cur->frame);
 471         av_freep(&cur);
 472         cur = q->work_frames;
 473     }
 474
 475     av_frame_free(&avctx->coded_frame);
 476
 477     return 0;
 478 }