FFmpeg
qsvenc_h264.c
Go to the documentation of this file.
1 /*
2  * Intel MediaSDK QSV based H.264 encoder
3  *
4  * copyright (c) 2013 Yukinori Yamazoe
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 
24 #include <stdint.h>
25 #include <sys/types.h>
26 
27 #include <mfxvideo.h>
28 
29 #include "libavutil/common.h"
30 #include "libavutil/opt.h"
31 
32 #include "avcodec.h"
33 #include "codec_internal.h"
34 #include "qsv.h"
35 #include "qsvenc.h"
36 #include "atsc_a53.h"
37 
38 typedef struct QSVH264EncContext {
39  AVClass *class;
42 
44  const AVFrame *frame, mfxEncodeCtrl* enc_ctrl)
45 {
46  QSVH264EncContext *qh264 = avctx->priv_data;
47  QSVEncContext *q = &qh264->qsv;
48 
49  if (q->a53_cc && frame) {
50  mfxPayload* payload;
51  mfxU8* sei_data;
52  size_t sei_size;
53  int res;
54 
55  res = ff_alloc_a53_sei(frame, sizeof(mfxPayload) + 2, (void**)&payload, &sei_size);
56  if (res < 0 || !payload)
57  return res;
58 
59  sei_data = (mfxU8*)(payload + 1);
60  // SEI header
61  sei_data[0] = 4;
62  sei_data[1] = (mfxU8)sei_size; // size of SEI data
63  // SEI data filled in by ff_alloc_a53_sei
64 
65  payload->BufSize = sei_size + 2;
66  payload->NumBit = payload->BufSize * 8;
67  payload->Type = 4;
68  payload->Data = sei_data;
69 
70  enc_ctrl->NumExtParam = 0;
71  enc_ctrl->NumPayload = 1;
72  enc_ctrl->Payload[0] = payload;
73  }
74  return 0;
75 }
76 
78 {
79  QSVH264EncContext *q = avctx->priv_data;
80 
82  return ff_qsv_enc_init(avctx, &q->qsv);
83 }
84 
86  const AVFrame *frame, int *got_packet)
87 {
88  QSVH264EncContext *q = avctx->priv_data;
89 
90  return ff_qsv_encode(avctx, &q->qsv, pkt, frame, got_packet);
91 }
92 
94 {
95  QSVH264EncContext *q = avctx->priv_data;
96 
97  return ff_qsv_enc_close(avctx, &q->qsv);
98 }
99 
100 #define OFFSET(x) offsetof(QSVH264EncContext, x)
101 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
102 static const AVOption options[] = {
120 #if QSV_HAVE_HE
121  QSV_HE_OPTIONS
122 #endif
123 
124  { "cavlc", "Enable CAVLC", OFFSET(qsv.cavlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
125 #if QSV_HAVE_VCM
126  { "vcm", "Use the video conferencing mode ratecontrol", OFFSET(qsv.vcm), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
127 #endif
128  { "idr_interval", "Distance (in I-frames) between IDR frames", OFFSET(qsv.idr_interval), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
129  { "pic_timing_sei", "Insert picture timing SEI with pic_struct_syntax element", OFFSET(qsv.pic_timing_sei), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
130  { "single_sei_nal_unit", "Put all the SEI messages into one NALU", OFFSET(qsv.single_sei_nal_unit), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
131  { "max_dec_frame_buffering", "Maximum number of frames buffered in the DPB", OFFSET(qsv.max_dec_frame_buffering), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, VE },
132 
133  { "look_ahead", "Use VBR algorithm with look ahead", OFFSET(qsv.look_ahead), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
134  { "look_ahead_depth", "Depth of look ahead in number frames", OFFSET(qsv.look_ahead_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, VE },
135  { "look_ahead_downsampling", "Downscaling factor for the frames saved for the lookahead analysis", OFFSET(qsv.look_ahead_downsampling),
136  AV_OPT_TYPE_INT, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, MFX_LOOKAHEAD_DS_UNKNOWN, MFX_LOOKAHEAD_DS_4x, VE, .unit = "look_ahead_downsampling" },
137  { "unknown" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, INT_MIN, INT_MAX, VE, .unit = "look_ahead_downsampling" },
138  { "auto" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, INT_MIN, INT_MAX, VE, .unit = "look_ahead_downsampling" },
139  { "off" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_OFF }, INT_MIN, INT_MAX, VE, .unit = "look_ahead_downsampling" },
140  { "2x" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_2x }, INT_MIN, INT_MAX, VE, .unit = "look_ahead_downsampling" },
141  { "4x" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_4x }, INT_MIN, INT_MAX, VE, .unit = "look_ahead_downsampling" },
142 
143  { "int_ref_type", "Intra refresh type. B frames should be set to 0.", OFFSET(qsv.int_ref_type), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE, .unit = "int_ref_type" },
144  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, .flags = VE, .unit = "int_ref_type" },
145  { "vertical", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, .flags = VE, .unit = "int_ref_type" },
146  { "horizontal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, .flags = VE, .unit = "int_ref_type" },
147  { "slice" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, .flags = VE, .unit = "int_ref_type" },
148  { "int_ref_cycle_size", "Number of frames in the intra refresh cycle", OFFSET(qsv.int_ref_cycle_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE },
149  { "int_ref_qp_delta", "QP difference for the refresh MBs", OFFSET(qsv.int_ref_qp_delta), AV_OPT_TYPE_INT, { .i64 = INT16_MIN }, INT16_MIN, INT16_MAX, VE },
150  { "recovery_point_sei", "Insert recovery point SEI messages", OFFSET(qsv.recovery_point_sei), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
151  { "int_ref_cycle_dist", "Distance between the beginnings of the intra-refresh cycles in frames", OFFSET(qsv.int_ref_cycle_dist), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT16_MAX, VE },
152  { "profile", NULL, OFFSET(qsv.profile), AV_OPT_TYPE_INT, { .i64 = MFX_PROFILE_UNKNOWN }, 0, INT_MAX, VE, .unit = "profile" },
153  { "unknown" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, VE, .unit = "profile" },
154  { "baseline", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_AVC_BASELINE }, INT_MIN, INT_MAX, VE, .unit = "profile" },
155  { "main" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_AVC_MAIN }, INT_MIN, INT_MAX, VE, .unit = "profile" },
156  { "high" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_AVC_HIGH }, INT_MIN, INT_MAX, VE, .unit = "profile" },
157 
158  { "a53cc" , "Use A53 Closed Captions (if available)", OFFSET(qsv.a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE},
159 
160  { "aud", "Insert the Access Unit Delimiter NAL", OFFSET(qsv.aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
161 
162 #if QSV_HAVE_MF
163  { "mfmode", "Multi-Frame Mode", OFFSET(qsv.mfmode), AV_OPT_TYPE_INT, { .i64 = MFX_MF_AUTO }, MFX_MF_DEFAULT, MFX_MF_AUTO, VE, .unit = "mfmode"},
164  { "off" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_MF_DISABLED }, INT_MIN, INT_MAX, VE, .unit = "mfmode" },
165  { "auto" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_MF_AUTO }, INT_MIN, INT_MAX, VE, .unit = "mfmode" },
166 #endif
167 
168  { "repeat_pps", "repeat pps for every frame", OFFSET(qsv.repeat_pps), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
169 
170  { NULL },
171 };
172 
173 static const AVClass class = {
174  .class_name = "h264_qsv encoder",
175  .item_name = av_default_item_name,
176  .option = options,
178 };
179 
181  { "b", "0" },
182  { "refs", "0" },
183  { "g", "-1" },
184  { "bf", "-1" },
185  { "qmin", "-1" },
186  { "qmax", "-1" },
187  { "trellis", "-1" },
188  { "flags", "+cgop" },
189  { NULL },
190 };
191 
193  .p.name = "h264_qsv",
194  CODEC_LONG_NAME("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (Intel Quick Sync Video acceleration)"),
195  .priv_data_size = sizeof(QSVH264EncContext),
196  .p.type = AVMEDIA_TYPE_VIDEO,
197  .p.id = AV_CODEC_ID_H264,
198  .init = qsv_enc_init,
200  .close = qsv_enc_close,
201  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID,
202  .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
204  AV_PIX_FMT_NONE },
205  .p.priv_class = &class,
206  .defaults = qsv_enc_defaults,
207  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
209  .p.wrapper_name = "qsv",
210  .hw_configs = ff_qsv_enc_hw_configs,
211 };
qsv_enc_frame
static int qsv_enc_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc_h264.c:85
ff_alloc_a53_sei
int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for A53 side data and allocate and fill SEI message with A53 info.
Definition: atsc_a53.c:26
qsv_h264_set_encode_ctrl
static int qsv_h264_set_encode_ctrl(AVCodecContext *avctx, const AVFrame *frame, mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc_h264.c:43
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
opt.h
qsv_enc_init
static av_cold int qsv_enc_init(AVCodecContext *avctx)
Definition: qsvenc_h264.c:77
QSV_OPTION_ADAPTIVE_B
#define QSV_OPTION_ADAPTIVE_B
Definition: qsvenc.h:101
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
QSV_OPTION_DBLK_IDC
#define QSV_OPTION_DBLK_IDC
Definition: qsvenc.h:110
AVOption
AVOption.
Definition: opt.h:357
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:126
VE
#define VE
Definition: qsvenc_h264.c:101
OFFSET
#define OFFSET(x)
Definition: qsvenc_h264.c:100
QSV_OPTION_MAX_MIN_QP
#define QSV_OPTION_MAX_MIN_QP
Definition: qsvenc.h:116
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
QSV_OPTION_BITRATE_LIMIT
#define QSV_OPTION_BITRATE_LIMIT
Definition: qsvenc.h:89
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:295
ff_qsv_enc_hw_configs
const AVCodecHWConfigInternal *const ff_qsv_enc_hw_configs[]
Definition: qsvenc.c:2760
pkt
AVPacket * pkt
Definition: movenc.c:60
av_cold
#define av_cold
Definition: attributes.h:90
QSVEncContext
Definition: qsvenc.h:157
qsvenc.h
QSV_OPTION_MAX_SLICE_SIZE
#define QSV_OPTION_MAX_SLICE_SIZE
Definition: qsvenc.h:86
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
QSV_OPTION_RDO
#define QSV_OPTION_RDO
Definition: qsvenc.h:78
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
QSV_OPTION_LOW_DELAY_BRC
#define QSV_OPTION_LOW_DELAY_BRC
Definition: qsvenc.h:113
NULL
#define NULL
Definition: coverity.c:32
QSVH264EncContext::qsv
QSVEncContext qsv
Definition: qsvenc_h264.c:40
qsv.h
QSV_COMMON_OPTS
#define QSV_COMMON_OPTS
Definition: qsvenc.h:56
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
QSVH264EncContext
Definition: qsvenc_h264.c:38
AV_PIX_FMT_QSV
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:247
QSV_OPTION_ADAPTIVE_I
#define QSV_OPTION_ADAPTIVE_I
Definition: qsvenc.h:98
QSV_OPTION_SKIP_FRAME
#define QSV_OPTION_SKIP_FRAME
Definition: qsvenc.h:141
codec_internal.h
qsv_enc_close
static av_cold int qsv_enc_close(AVCodecContext *avctx)
Definition: qsvenc_h264.c:93
QSVEncContext::a53_cc
int a53_cc
Definition: qsvenc.h:262
options
static const AVOption options[]
Definition: qsvenc_h264.c:102
QSV_OPTION_SCENARIO
#define QSV_OPTION_SCENARIO
Definition: qsvenc.h:124
QSV_OPTION_EXTBRC
#define QSV_OPTION_EXTBRC
Definition: qsvenc.h:95
ff_qsv_enc_close
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2708
QSVEncContext::set_encode_ctrl_cb
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:268
common.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
avcodec.h
QSV_OPTION_P_STRATEGY
#define QSV_OPTION_P_STRATEGY
Definition: qsvenc.h:104
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
atsc_a53.h
QSV_OPTION_MAX_FRAME_SIZE
#define QSV_OPTION_MAX_FRAME_SIZE
Definition: qsvenc.h:81
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
qsv_enc_defaults
static const FFCodecDefault qsv_enc_defaults[]
Definition: qsvenc_h264.c:180
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
QSV_OPTION_AVBR
#define QSV_OPTION_AVBR
Definition: qsvenc.h:137
ff_qsv_enc_init
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1635
AV_CODEC_CAP_HYBRID
#define AV_CODEC_CAP_HYBRID
Codec is potentially backed by a hardware implementation, but not necessarily.
Definition: codec.h:152
AVPacket
This structure stores compressed data.
Definition: packet.h:510
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
ff_qsv_encode
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:2640
QSV_OPTION_MBBRC
#define QSV_OPTION_MBBRC
Definition: qsvenc.h:92
ff_h264_qsv_encoder
const FFCodec ff_h264_qsv_encoder
Definition: qsvenc_h264.c:192
QSV_OPTION_B_STRATEGY
#define QSV_OPTION_B_STRATEGY
Definition: qsvenc.h:107