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 <mfx/mfxvideo.h>
28 
29 #include "libavutil/common.h"
30 #include "libavutil/opt.h"
31 
32 #include "avcodec.h"
33 #include "internal.h"
34 #include "qsv.h"
35 #include "qsv_internal.h"
36 #include "qsvenc.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[] = {
104 
105  { "cavlc", "Enable CAVLC", OFFSET(qsv.cavlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
106 #if QSV_HAVE_VCM
107  { "vcm", "Use the video conferencing mode ratecontrol", OFFSET(qsv.vcm), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
108 #endif
109  { "idr_interval", "Distance (in I-frames) between IDR frames", OFFSET(qsv.idr_interval), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
110  { "pic_timing_sei", "Insert picture timing SEI with pic_struct_syntax element", OFFSET(qsv.pic_timing_sei), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
111  { "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 },
112  { "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 },
113 
114 #if QSV_HAVE_LA
115  { "look_ahead", "Use VBR algorithm with look ahead", OFFSET(qsv.look_ahead), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
116  { "look_ahead_depth", "Depth of look ahead in number frames", OFFSET(qsv.look_ahead_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, VE },
117 #endif
118 #if QSV_HAVE_LA_DS
119  { "look_ahead_downsampling", "Downscaling factor for the frames saved for the lookahead analysis", OFFSET(qsv.look_ahead_downsampling),
120  AV_OPT_TYPE_INT, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, MFX_LOOKAHEAD_DS_UNKNOWN, MFX_LOOKAHEAD_DS_4x, VE, "look_ahead_downsampling" },
121  { "unknown" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },
122  { "auto" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },
123  { "off" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_OFF }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },
124  { "2x" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_2x }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },
125  { "4x" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_4x }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },
126 #endif
127 
128  { "int_ref_type", "Intra refresh type", OFFSET(qsv.int_ref_type), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE, "int_ref_type" },
129  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, .flags = VE, "int_ref_type" },
130  { "vertical", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, .flags = VE, "int_ref_type" },
131  { "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 },
132  { "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 },
133  { "recovery_point_sei", "Insert recovery point SEI messages", OFFSET(qsv.recovery_point_sei), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
134 
135  { "profile", NULL, OFFSET(qsv.profile), AV_OPT_TYPE_INT, { .i64 = MFX_PROFILE_UNKNOWN }, 0, INT_MAX, VE, "profile" },
136  { "unknown" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, VE, "profile" },
137  { "baseline", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_AVC_BASELINE }, INT_MIN, INT_MAX, VE, "profile" },
138  { "main" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_AVC_MAIN }, INT_MIN, INT_MAX, VE, "profile" },
139  { "high" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_AVC_HIGH }, INT_MIN, INT_MAX, VE, "profile" },
140 
141  { "a53cc" , "Use A53 Closed Captions (if available)", OFFSET(qsv.a53_cc), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, VE},
142 
143  { "aud", "Insert the Access Unit Delimiter NAL", OFFSET(qsv.aud), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
144 
145 #if QSV_HAVE_MF
146  { "mfmode", "Multi-Frame Mode", OFFSET(qsv.mfmode), AV_OPT_TYPE_INT, { .i64 = MFX_MF_AUTO }, MFX_MF_DEFAULT, MFX_MF_AUTO, VE, "mfmode"},
147  { "off" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_MF_DISABLED }, INT_MIN, INT_MAX, VE, "mfmode" },
148  { "auto" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_MF_AUTO }, INT_MIN, INT_MAX, VE, "mfmode" },
149 #endif
150 
151  { "repeat_pps", "repeat pps for every frame", OFFSET(qsv.repeat_pps), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
152 
153  { NULL },
154 };
155 
156 static const AVClass class = {
157  .class_name = "h264_qsv encoder",
158  .item_name = av_default_item_name,
159  .option = options,
161 };
162 
164  { "b", "1M" },
165  { "refs", "0" },
166  // same as the x264 default
167  { "g", "250" },
168  { "bf", "3" },
169  { "qmin", "-1" },
170  { "qmax", "-1" },
171 #if FF_API_CODER_TYPE
172  { "coder", "-1" },
173 #endif
174  { "trellis", "-1" },
175  { "flags", "+cgop" },
176 #if FF_API_PRIVATE_OPT
177  { "b_strategy", "-1" },
178 #endif
179  { NULL },
180 };
181 
183  .name = "h264_qsv",
184  .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (Intel Quick Sync Video acceleration)"),
185  .priv_data_size = sizeof(QSVH264EncContext),
187  .id = AV_CODEC_ID_H264,
188  .init = qsv_enc_init,
189  .encode2 = qsv_enc_frame,
190  .close = qsv_enc_close,
191  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID,
192  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
195  AV_PIX_FMT_NONE },
196  .priv_class = &class,
197  .defaults = qsv_enc_defaults,
198  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
199  .wrapper_name = "qsv",
200 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
int single_sei_nal_unit
Definition: qsvenc.h:160
#define NULL
Definition: coverity.c:32
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
int int_ref_type
Definition: qsvenc.h:171
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int look_ahead_depth
Definition: qsvenc.h:151
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
int int_ref_qp_delta
Definition: qsvenc.h:173
GLint GLenum type
Definition: opengl_enc.c:104
static AVPacket pkt
AVCodec.
Definition: avcodec.h:3484
int look_ahead
Definition: qsvenc.h:150
#define AV_PIX_FMT_P010
Definition: pixfmt.h:436
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:72
#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: avcodec.h:1009
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1412
#define av_cold
Definition: attributes.h:82
AVOptions.
static const AVCodecDefault qsv_enc_defaults[]
Definition: qsvenc_h264.c:163
#define QSV_COMMON_OPTS
Definition: qsvenc.h:73
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1504
static const AVOption options[]
Definition: qsvenc_h264.c:102
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:89
const char * name
Name of the codec implementation.
Definition: avcodec.h:3491
int max_dec_frame_buffering
Definition: qsvenc.h:161
#define MFX_LOOKAHEAD_DS_UNKNOWN
Definition: qsvenc.h:67
AVCodec ff_h264_qsv_encoder
Definition: qsvenc_h264.c:182
int idr_interval
Definition: qsvenc.h:144
int a53_cc
Definition: qsvenc.h:180
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
#define MFX_LOOKAHEAD_DS_OFF
Definition: qsvenc.h:68
#define MFX_LOOKAHEAD_DS_2x
Definition: qsvenc.h:69
int repeat_pps
Definition: qsvenc.h:176
QSVEncContext qsv
Definition: qsvenc_h264.c:40
Libavcodec external API header.
static int qsv_h264_set_encode_ctrl(AVCodecContext *avctx, const AVFrame *frame, mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc_h264.c:43
main external API structure.
Definition: avcodec.h:1568
int profile
Definition: qsvenc.h:145
#define AV_CODEC_CAP_HYBRID
Codec is potentially backed by a hardware implementation, but not necessarily.
Definition: avcodec.h:1088
Describe the class of an AVClass context structure.
Definition: log.h:67
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:995
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:222
static int qsv_enc_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc_h264.c:85
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
int int_ref_cycle_size
Definition: qsvenc.h:172
static av_cold int qsv_enc_init(AVCodecContext *avctx)
Definition: qsvenc_h264.c:77
common internal api header.
common internal and external API header
#define MFX_LOOKAHEAD_DS_4x
Definition: qsvenc.h:70
void * priv_data
Definition: avcodec.h:1595
#define VE
Definition: qsvenc_h264.c:101
int recovery_point_sei
Definition: qsvenc.h:174
#define OFFSET(x)
Definition: qsvenc_h264.c:100
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: utils.c:2156
int look_ahead_downsampling
Definition: qsvenc.h:152
static av_cold int qsv_enc_close(AVCodecContext *avctx)
Definition: qsvenc_h264.c:93
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1457
int pic_timing_sei
Definition: qsvenc.h:149
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:186