FFmpeg
qsvenc_hevc.c
Go to the documentation of this file.
1 /*
2  * Intel MediaSDK QSV based HEVC encoder
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 
22 #include <stdint.h>
23 #include <sys/types.h>
24 
25 #include <mfxvideo.h>
26 
27 #include "libavutil/common.h"
28 #include "libavutil/opt.h"
29 
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "codec_internal.h"
33 #include "get_bits.h"
34 #include "hevc.h"
35 #include "hevcdec.h"
36 #include "h2645_parse.h"
37 #include "qsv.h"
38 #include "qsvenc.h"
39 
40 enum LoadPlugin {
44 };
45 
46 typedef struct QSVHEVCEncContext {
47  AVClass *class;
51 
53 {
54  GetByteContext gbc;
55  PutByteContext pbc;
56 
57  GetBitContext gb;
58  H2645RBSP sps_rbsp = { NULL };
59  H2645NAL sps_nal = { NULL };
60  HEVCSPS sps = { 0 };
61  HEVCVPS vps = { 0 };
62  uint8_t vps_buf[128], vps_rbsp_buf[128];
63  uint8_t *new_extradata;
64  unsigned int sps_id;
65  int ret, i, type, vps_size;
66 
67  if (!avctx->extradata_size) {
68  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx\n");
69  return AVERROR_UNKNOWN;
70  }
71 
73  if (!sps_rbsp.rbsp_buffer)
74  return AVERROR(ENOMEM);
75 
76  /* parse the SPS */
77  ret = ff_h2645_extract_rbsp(avctx->extradata + 4, avctx->extradata_size - 4, &sps_rbsp, &sps_nal, 1);
78  if (ret < 0) {
79  av_log(avctx, AV_LOG_ERROR, "Error unescaping the SPS buffer\n");
80  return ret;
81  }
82 
83  ret = init_get_bits8(&gb, sps_nal.data, sps_nal.size);
84  if (ret < 0) {
85  av_freep(&sps_rbsp.rbsp_buffer);
86  return ret;
87  }
88 
89  get_bits(&gb, 1);
90  type = get_bits(&gb, 6);
91  if (type != HEVC_NAL_SPS) {
92  av_log(avctx, AV_LOG_ERROR, "Unexpected NAL type in the extradata: %d\n",
93  type);
94  av_freep(&sps_rbsp.rbsp_buffer);
95  return AVERROR_INVALIDDATA;
96  }
97  get_bits(&gb, 9);
98 
99  ret = ff_hevc_parse_sps(&sps, &gb, &sps_id, 0, NULL, avctx);
100  av_freep(&sps_rbsp.rbsp_buffer);
101  if (ret < 0) {
102  av_log(avctx, AV_LOG_ERROR, "Error parsing the SPS\n");
103  return ret;
104  }
105 
106  /* generate the VPS */
107  vps.vps_max_layers = 1;
108  vps.vps_max_sub_layers = sps.max_sub_layers;
109  vps.vps_temporal_id_nesting_flag = sps.temporal_id_nesting_flag;
110  memcpy(&vps.ptl, &sps.ptl, sizeof(vps.ptl));
111  vps.vps_sub_layer_ordering_info_present_flag = 1;
112  for (i = 0; i < HEVC_MAX_SUB_LAYERS; i++) {
113  vps.vps_max_dec_pic_buffering[i] = sps.temporal_layer[i].max_dec_pic_buffering;
114  vps.vps_num_reorder_pics[i] = sps.temporal_layer[i].num_reorder_pics;
115  vps.vps_max_latency_increase[i] = sps.temporal_layer[i].max_latency_increase;
116  }
117 
118  vps.vps_num_layer_sets = 1;
119  vps.vps_timing_info_present_flag = sps.vui.vui_timing_info_present_flag;
120  vps.vps_num_units_in_tick = sps.vui.vui_num_units_in_tick;
121  vps.vps_time_scale = sps.vui.vui_time_scale;
122  vps.vps_poc_proportional_to_timing_flag = sps.vui.vui_poc_proportional_to_timing_flag;
123  vps.vps_num_ticks_poc_diff_one = sps.vui.vui_num_ticks_poc_diff_one_minus1 + 1;
124  vps.vps_num_hrd_parameters = 0;
125 
126  /* generate the encoded RBSP form of the VPS */
127  ret = ff_hevc_encode_nal_vps(&vps, sps.vps_id, vps_rbsp_buf, sizeof(vps_rbsp_buf));
128  if (ret < 0) {
129  av_log(avctx, AV_LOG_ERROR, "Error writing the VPS\n");
130  return ret;
131  }
132 
133  /* escape and add the startcode */
134  bytestream2_init(&gbc, vps_rbsp_buf, ret);
135  bytestream2_init_writer(&pbc, vps_buf, sizeof(vps_buf));
136 
137  bytestream2_put_be32(&pbc, 1); // startcode
138  bytestream2_put_byte(&pbc, HEVC_NAL_VPS << 1); // NAL
139  bytestream2_put_byte(&pbc, 1); // header
140 
141  while (bytestream2_get_bytes_left(&gbc)) {
142  if (bytestream2_get_bytes_left(&gbc) >= 3 && bytestream2_peek_be24(&gbc) <= 3) {
143  bytestream2_put_be24(&pbc, 3);
144  bytestream2_skip(&gbc, 2);
145  } else
146  bytestream2_put_byte(&pbc, bytestream2_get_byte(&gbc));
147  }
148 
149  vps_size = bytestream2_tell_p(&pbc);
150  new_extradata = av_mallocz(vps_size + avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
151  if (!new_extradata)
152  return AVERROR(ENOMEM);
153  memcpy(new_extradata, vps_buf, vps_size);
154  memcpy(new_extradata + vps_size, avctx->extradata, avctx->extradata_size);
155 
156  av_freep(&avctx->extradata);
157  avctx->extradata = new_extradata;
158  avctx->extradata_size += vps_size;
159 
160  return 0;
161 }
162 
164 {
165  QSVHEVCEncContext *q = avctx->priv_data;
166  int ret;
167 
168  if (q->load_plugin != LOAD_PLUGIN_NONE) {
169  static const char * const uid_hevcenc_sw = "2fca99749fdb49aeb121a5b63ef568f7";
170  static const char * const uid_hevcenc_hw = "6fadc791a0c2eb479ab6dcd5ea9da347";
171 
172  if (q->qsv.load_plugins[0]) {
173  av_log(avctx, AV_LOG_WARNING,
174  "load_plugins is not empty, but load_plugin is not set to 'none'."
175  "The load_plugin value will be ignored.\n");
176  } else {
178 
180  q->qsv.load_plugins = av_strdup(uid_hevcenc_sw);
181  else
182  q->qsv.load_plugins = av_strdup(uid_hevcenc_hw);
183 
184  if (!q->qsv.load_plugins)
185  return AVERROR(ENOMEM);
186  }
187  }
188 
189  // HEVC and H264 meaning of the value is shifted by 1, make it consistent
190  q->qsv.idr_interval++;
191 
192  ret = ff_qsv_enc_init(avctx, &q->qsv);
193  if (ret < 0)
194  return ret;
195 
196  if (!q->qsv.hevc_vps) {
197  ret = generate_fake_vps(&q->qsv, avctx);
198  if (ret < 0) {
199  ff_qsv_enc_close(avctx, &q->qsv);
200  return ret;
201  }
202  }
203 
204  return 0;
205 }
206 
208  const AVFrame *frame, int *got_packet)
209 {
210  QSVHEVCEncContext *q = avctx->priv_data;
211 
212  return ff_qsv_encode(avctx, &q->qsv, pkt, frame, got_packet);
213 }
214 
216 {
217  QSVHEVCEncContext *q = avctx->priv_data;
218 
219  return ff_qsv_enc_close(avctx, &q->qsv);
220 }
221 
222 #define OFFSET(x) offsetof(QSVHEVCEncContext, x)
223 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
224 static const AVOption options[] = {
236 
237  { "idr_interval", "Distance (in I-frames) between IDR frames", OFFSET(qsv.idr_interval), AV_OPT_TYPE_INT, { .i64 = 0 }, -1, INT_MAX, VE, "idr_interval" },
238  { "begin_only", "Output an IDR-frame only at the beginning of the stream", 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, 0, 0, VE, "idr_interval" },
239  { "load_plugin", "A user plugin to load in an internal session", OFFSET(load_plugin), AV_OPT_TYPE_INT, { .i64 = LOAD_PLUGIN_HEVC_HW }, LOAD_PLUGIN_NONE, LOAD_PLUGIN_HEVC_HW, VE, "load_plugin" },
240  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_NONE }, 0, 0, VE, "load_plugin" },
241  { "hevc_sw", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_HEVC_SW }, 0, 0, VE, "load_plugin" },
242  { "hevc_hw", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_HEVC_HW }, 0, 0, VE, "load_plugin" },
243 
244  { "load_plugins", "A :-separate list of hexadecimal plugin UIDs to load in an internal session",
245  OFFSET(qsv.load_plugins), AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VE },
246 
247  { "look_ahead_depth", "Depth of look ahead in number frames, available when extbrc option is enabled", OFFSET(qsv.look_ahead_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, VE },
248  { "profile", NULL, OFFSET(qsv.profile), AV_OPT_TYPE_INT, { .i64 = MFX_PROFILE_UNKNOWN }, 0, INT_MAX, VE, "profile" },
249  { "unknown", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, VE, "profile" },
250  { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_HEVC_MAIN }, INT_MIN, INT_MAX, VE, "profile" },
251  { "main10", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_HEVC_MAIN10 }, INT_MIN, INT_MAX, VE, "profile" },
252  { "mainsp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_HEVC_MAINSP }, INT_MIN, INT_MAX, VE, "profile" },
253  { "rext", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_HEVC_REXT }, INT_MIN, INT_MAX, VE, "profile" },
254 #if QSV_VERSION_ATLEAST(1, 32)
255  { "scc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_HEVC_SCC }, INT_MIN, INT_MAX, VE, "profile" },
256 #endif
257 
258  { "gpb", "1: GPB (generalized P/B frame); 0: regular P frame", OFFSET(qsv.gpb), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE},
259 
260  { "tile_cols", "Number of columns for tiled encoding", OFFSET(qsv.tile_cols), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, VE },
261  { "tile_rows", "Number of rows for tiled encoding", OFFSET(qsv.tile_rows), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, VE },
262  { "recovery_point_sei", "Insert recovery point SEI messages", OFFSET(qsv.recovery_point_sei), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
263  { "aud", "Insert the Access Unit Delimiter NAL", OFFSET(qsv.aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
264  { "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 },
265  { "transform_skip", "Turn this option ON to enable transformskip", OFFSET(qsv.transform_skip), AV_OPT_TYPE_INT, { .i64 = -1}, -1, 1, VE},
266  { "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, "int_ref_type" },
267  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, .flags = VE, "int_ref_type" },
268  { "vertical", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, .flags = VE, "int_ref_type" },
269  { "horizontal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, .flags = VE, "int_ref_type" },
270  { "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 },
271  { "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 },
272  { "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 },
273 
274  { NULL },
275 };
276 
277 static const AVClass class = {
278  .class_name = "hevc_qsv encoder",
279  .item_name = av_default_item_name,
280  .option = options,
282 };
283 
285  { "b", "1M" },
286  { "refs", "0" },
287  // same as the x264 default
288  { "g", "248" },
289  { "bf", "-1" },
290  { "qmin", "-1" },
291  { "qmax", "-1" },
292  { "trellis", "-1" },
293  { "flags", "+cgop" },
294  { NULL },
295 };
296 
298  .p.name = "hevc_qsv",
299  .p.long_name = NULL_IF_CONFIG_SMALL("HEVC (Intel Quick Sync Video acceleration)"),
300  .priv_data_size = sizeof(QSVHEVCEncContext),
301  .p.type = AVMEDIA_TYPE_VIDEO,
302  .p.id = AV_CODEC_ID_HEVC,
303  .init = qsv_enc_init,
305  .close = qsv_enc_close,
306  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID,
307  .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
314  AV_PIX_FMT_NONE },
315  .p.priv_class = &class,
316  .defaults = qsv_enc_defaults,
317  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
319  .p.wrapper_name = "qsv",
320  .hw_configs = ff_qsv_enc_hw_configs,
321 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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:41
h2645_parse.h
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
GetByteContext
Definition: bytestream.h:33
LOAD_PLUGIN_NONE
@ LOAD_PLUGIN_NONE
Definition: qsvenc_hevc.c:41
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
QSV_OPTION_DBLK_IDC
#define QSV_OPTION_DBLK_IDC
Definition: qsvenc.h:100
AVOption
AVOption.
Definition: opt.h:251
bytestream2_tell_p
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:197
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:33
FFCodec
Definition: codec_internal.h:118
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
QSVEncContext::load_plugins
char * load_plugins
Definition: qsvenc.h:216
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
QSV_OPTION_MAX_MIN_QP
#define QSV_OPTION_MAX_MIN_QP
Definition: qsvenc.h:106
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
QSVEncContext::hevc_vps
int hevc_vps
Definition: qsvenc.h:162
FFCodecDefault
Definition: codec_internal.h:88
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
GetBitContext
Definition: get_bits.h:61
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:269
AV_PIX_FMT_Y210
#define AV_PIX_FMT_Y210
Definition: pixfmt.h:463
ff_qsv_enc_hw_configs
const AVCodecHWConfigInternal *const ff_qsv_enc_hw_configs[]
Definition: qsvenc.c:1945
ff_hevc_qsv_encoder
const FFCodec ff_hevc_qsv_encoder
Definition: qsvenc_hevc.c:297
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
QSVEncContext
Definition: qsvenc.h:118
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
H2645NAL::size
int size
Definition: h2645_parse.h:36
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
qsvenc.h
generate_fake_vps
static int generate_fake_vps(QSVEncContext *q, AVCodecContext *avctx)
Definition: qsvenc_hevc.c:52
get_bits.h
H2645NAL::data
const uint8_t * data
Definition: h2645_parse.h:35
QSV_OPTION_MAX_SLICE_SIZE
#define QSV_OPTION_MAX_SLICE_SIZE
Definition: qsvenc.h:76
QSV_OPTION_RDO
#define QSV_OPTION_RDO
Definition: qsvenc.h:68
ff_hevc_parse_sps
int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id, int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx)
Parse the SPS from the bitstream into the provided HEVCSPS struct.
Definition: hevc_ps.c:905
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:103
NULL
#define NULL
Definition: coverity.c:32
qsv.h
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
QSV_COMMON_OPTS
#define QSV_COMMON_OPTS
Definition: qsvenc.h:53
HEVC_MAX_SUB_LAYERS
@ HEVC_MAX_SUB_LAYERS
Definition: hevc.h:105
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
Definition: cbs_h265_syntax_template.c:423
AV_PIX_FMT_QSV
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:212
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
H2645RBSP::rbsp_buffer
uint8_t * rbsp_buffer
Definition: h2645_parse.h:75
PutByteContext
Definition: bytestream.h:37
ff_hevc_encode_nal_vps
int ff_hevc_encode_nal_vps(HEVCVPS *vps, unsigned int id, uint8_t *buf, int buf_size)
Definition: hevc_ps_enc.c:66
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
hevcdec.h
codec_internal.h
VE
#define VE
Definition: qsvenc_hevc.c:223
LoadPlugin
LoadPlugin
Definition: qsvdec.c:871
H2645NAL
Definition: h2645_parse.h:34
LOAD_PLUGIN_HEVC_SW
@ LOAD_PLUGIN_HEVC_SW
Definition: qsvenc_hevc.c:42
qsv_enc_init
static av_cold int qsv_enc_init(AVCodecContext *avctx)
Definition: qsvenc_hevc.c:163
QSV_OPTION_EXTBRC
#define QSV_OPTION_EXTBRC
Definition: qsvenc.h:85
ff_qsv_enc_close
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1896
QSVHEVCEncContext
Definition: qsvenc_hevc.c:46
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:499
ff_h2645_extract_rbsp
int ff_h2645_extract_rbsp(const uint8_t *src, int length, H2645RBSP *rbsp, H2645NAL *nal, int small_padding)
Extract the raw (unescaped) bitstream.
Definition: h2645_parse.c:34
common.h
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:48
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:224
AV_PIX_FMT_X2RGB10
#define AV_PIX_FMT_X2RGB10
Definition: pixfmt.h:464
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
QSVHEVCEncContext::load_plugin
int load_plugin
Definition: qsvenc_hevc.c:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
options
static const AVOption options[]
Definition: qsvenc_hevc.c:224
hevc.h
H2645RBSP::rbsp_buffer_alloc_size
int rbsp_buffer_alloc_size
Definition: h2645_parse.h:77
avcodec.h
HEVC_NAL_VPS
@ HEVC_NAL_VPS
Definition: hevc.h:61
ret
ret
Definition: filter_design.txt:187
QSV_OPTION_P_STRATEGY
#define QSV_OPTION_P_STRATEGY
Definition: qsvenc.h:94
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:89
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
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
QSV_OPTION_MAX_FRAME_SIZE
#define QSV_OPTION_MAX_FRAME_SIZE
Definition: qsvenc.h:71
LOAD_PLUGIN_HEVC_HW
@ LOAD_PLUGIN_HEVC_HW
Definition: qsvenc_hevc.c:43
QSVHEVCEncContext::qsv
QSVEncContext qsv
Definition: qsvenc_hevc.c:48
AVCodecContext
main external API structure.
Definition: avcodec.h:398
QSVEncContext::idr_interval
int idr_interval
Definition: qsvenc.h:166
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
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:82
AV_PIX_FMT_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:460
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
HEVC_NAL_SPS
@ HEVC_NAL_SPS
Definition: hevc.h:62
ff_qsv_enc_init
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1264
HEVCVPS
Definition: hevc_ps.h:123
AV_CODEC_CAP_HYBRID
#define AV_CODEC_CAP_HYBRID
Codec is potentially backed by a hardware implementation, but not necessarily.
Definition: codec.h:169
HEVCSPS
Definition: hevc_ps.h:153
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
bytestream.h
qsv_enc_defaults
static const FFCodecDefault qsv_enc_defaults[]
Definition: qsvenc_hevc.c:284
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
qsv_enc_frame
static int qsv_enc_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc_hevc.c:207
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
OFFSET
#define OFFSET(x)
Definition: qsvenc_hevc.c:222
H2645RBSP
Definition: h2645_parse.h:74
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
ff_qsv_encode
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1830
qsv_enc_close
static av_cold int qsv_enc_close(AVCodecContext *avctx)
Definition: qsvenc_hevc.c:215
QSV_OPTION_MBBRC
#define QSV_OPTION_MBBRC
Definition: qsvenc.h:82
QSV_OPTION_B_STRATEGY
#define QSV_OPTION_B_STRATEGY
Definition: qsvenc.h:97