1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
|
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_VAAPI_ENCODE_H
#define AVCODEC_VAAPI_ENCODE_H
#include <stdint.h>
#include <va/va.h>
#include "libavutil/hwcontext.h"
#include "libavutil/hwcontext_vaapi.h"
#include "avcodec.h"
struct VAAPIEncodeType;
struct VAAPIEncodePicture;
enum {
MAX_CONFIG_ATTRIBUTES = 4,
MAX_GLOBAL_PARAMS = 4,
MAX_PICTURE_REFERENCES = 2,
MAX_PICTURE_SLICES = 112,
MAX_PARAM_BUFFERS = 128,
MAX_REORDER_DELAY = 16,
MAX_PARAM_BUFFER_SIZE = 1024,
};
enum {
PICTURE_TYPE_IDR = 0,
PICTURE_TYPE_I = 1,
PICTURE_TYPE_P = 2,
PICTURE_TYPE_B = 3,
};
typedef struct VAAPIEncodeSlice {
int index;
void *priv_data;
void *codec_slice_params;
} VAAPIEncodeSlice;
typedef struct VAAPIEncodePicture {
struct VAAPIEncodePicture *next;
int64_t display_order;
int64_t encode_order;
int64_t pts;
int type;
int input_available;
int encode_issued;
int encode_complete;
AVFrame *input_image;
VASurfaceID input_surface;
AVFrame *recon_image;
VASurfaceID recon_surface;
int nb_param_buffers;
VABufferID param_buffers[MAX_PARAM_BUFFERS];
AVBufferRef *output_buffer_ref;
VABufferID output_buffer;
void *priv_data;
void *codec_picture_params;
int nb_refs;
struct VAAPIEncodePicture *refs[MAX_PICTURE_REFERENCES];
int nb_slices;
VAAPIEncodeSlice *slices[MAX_PICTURE_SLICES];
} VAAPIEncodePicture;
typedef struct VAAPIEncodeContext {
const AVClass *class;
// Codec-specific hooks.
const struct VAAPIEncodeType *codec;
// Encoding profile (VAProfileXXX).
VAProfile va_profile;
// Encoding entrypoint (usually VAEntryointEncSlice).
VAEntrypoint va_entrypoint;
// Surface colour/sampling format (usually VA_RT_FORMAT_YUV420).
unsigned int va_rt_format;
// Rate control mode.
unsigned int va_rc_mode;
// Supported packed headers (initially the desired set, modified
// later to what is actually supported).
unsigned int va_packed_headers;
// The required size of surfaces. This is probably the input
// size (AVCodecContext.width|height) aligned up to whatever
// block size is required by the codec.
int surface_width;
int surface_height;
// Everything above this point must be set before calling
// ff_vaapi_encode_init().
// Codec-specific state.
void *priv_data;
// Configuration attributes to use when creating va_config.
VAConfigAttrib config_attributes[MAX_CONFIG_ATTRIBUTES];
int nb_config_attributes;
VAConfigID va_config;
VAContextID va_context;
AVBufferRef *device_ref;
AVHWDeviceContext *device;
AVVAAPIDeviceContext *hwctx;
// The hardware frame context containing the input frames.
AVBufferRef *input_frames_ref;
AVHWFramesContext *input_frames;
// The hardware frame context containing the reconstructed frames.
AVBufferRef *recon_frames_ref;
AVHWFramesContext *recon_frames;
// Pool of (reusable) bitstream output buffers.
AVBufferPool *output_buffer_pool;
// Global parameters which will be applied at the start of the
// sequence (includes rate control parameters below).
VAEncMiscParameterBuffer *global_params[MAX_GLOBAL_PARAMS];
size_t global_params_size[MAX_GLOBAL_PARAMS];
int nb_global_params;
// Rate control parameters.
struct {
VAEncMiscParameterBuffer misc;
VAEncMiscParameterRateControl rc;
} rc_params;
struct {
VAEncMiscParameterBuffer misc;
VAEncMiscParameterHRD hrd;
} hrd_params;
// Per-sequence parameter structure (VAEncSequenceParameterBuffer*).
void *codec_sequence_params;
// Per-sequence parameters found in the per-picture parameter
// structure (VAEncPictureParameterBuffer*).
void *codec_picture_params;
// Current encoding window, in display (input) order.
VAAPIEncodePicture *pic_start, *pic_end;
// Next input order index (display order).
int64_t input_order;
// Number of frames that output is behind input.
int64_t output_delay;
// Number of frames decode output will need to be delayed.
int64_t decode_delay;
// Next output order index (encode order).
int64_t output_order;
enum {
// All encode operations are done independently (synchronise
// immediately after every operation).
ISSUE_MODE_SERIALISE_EVERYTHING = 0,
// Overlap as many operations as possible.
ISSUE_MODE_MAXIMISE_THROUGHPUT,
// Overlap operations only when satisfying parallel dependencies.
ISSUE_MODE_MINIMISE_LATENCY,
} issue_mode;
// Timestamp handling.
int64_t first_pts;
int64_t dts_pts_diff;
int64_t ts_ring[MAX_REORDER_DELAY * 3];
// Frame type decision.
int p_per_i;
int b_per_p;
int force_idr;
int gop_counter;
int p_counter;
int end_of_stream;
// Codec-local options are allocated to follow this structure in
// memory (in the AVCodec definition, set priv_data_size to
// sizeof(VAAPIEncodeContext) + sizeof(VAAPIEncodeFooOptions)).
void *codec_options;
char codec_options_data[0];
} VAAPIEncodeContext;
typedef struct VAAPIEncodeType {
size_t priv_data_size;
// Perform any extra codec-specific configuration after the
// codec context is initialised (set up the private data and
// add any necessary global parameters).
int (*configure)(AVCodecContext *avctx);
// The size of the parameter structures:
// sizeof(VAEnc{type}ParameterBuffer{codec}).
size_t sequence_params_size;
size_t picture_params_size;
size_t slice_params_size;
// Fill the parameter structures.
int (*init_sequence_params)(AVCodecContext *avctx);
int (*init_picture_params)(AVCodecContext *avctx,
VAAPIEncodePicture *pic);
int (*init_slice_params)(AVCodecContext *avctx,
VAAPIEncodePicture *pic,
VAAPIEncodeSlice *slice);
// The type used by the packed header: this should look like
// VAEncPackedHeader{something}.
int sequence_header_type;
int picture_header_type;
int slice_header_type;
// Write the packed header data to the provided buffer.
// The sequence header is also used to fill the codec extradata
// when the encoder is starting.
int (*write_sequence_header)(AVCodecContext *avctx,
char *data, size_t *data_len);
int (*write_picture_header)(AVCodecContext *avctx,
VAAPIEncodePicture *pic,
char *data, size_t *data_len);
int (*write_slice_header)(AVCodecContext *avctx,
VAAPIEncodePicture *pic,
VAAPIEncodeSlice *slice,
char *data, size_t *data_len);
// Fill an extra parameter structure, which will then be
// passed to vaRenderPicture(). Will be called repeatedly
// with increasing index argument until AVERROR_EOF is
// returned.
int (*write_extra_buffer)(AVCodecContext *avctx,
VAAPIEncodePicture *pic,
int index, int *type,
char *data, size_t *data_len);
// Write an extra packed header. Will be called repeatedly
// with increasing index argument until AVERROR_EOF is
// returned.
int (*write_extra_header)(AVCodecContext *avctx,
VAAPIEncodePicture *pic,
int index, int *type,
char *data, size_t *data_len);
} VAAPIEncodeType;
int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *input_image, int *got_packet);
int ff_vaapi_encode_init(AVCodecContext *avctx);
int ff_vaapi_encode_close(AVCodecContext *avctx);
#endif /* AVCODEC_VAAPI_ENCODE_H */
|