FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* This file is part of FFmpeg.
3			*
4			* FFmpeg is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU Lesser General Public
6			* License as published by the Free Software Foundation; either
7			* version 2.1 of the License, or (at your option) any later version.
8			*
9			* FFmpeg is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* Lesser General Public License for more details.
13			*
14			* You should have received a copy of the GNU Lesser General Public
15			* License along with FFmpeg; if not, write to the Free Software
16			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17			*/
18
19			#ifndef AVCODEC_HW_BASE_ENCODE_H
20			#define AVCODEC_HW_BASE_ENCODE_H
21
22			#include "avcodec.h"
23			#include "libavutil/hwcontext.h"
24			#include "libavutil/fifo.h"
25
26			#define MAX_DPB_SIZE 16
27			#define MAX_PICTURE_REFERENCES 2
28			#define MAX_REORDER_DELAY 16
29			#define MAX_ASYNC_DEPTH 64
30			#define MAX_REFERENCE_LIST_NUM 2
31
32		✗	static inline const char *ff_hw_base_encode_get_pictype_name(const int type)
33			{
34		✗	const char * const picture_type_name[] = { "IDR", "I", "P", "B" };
35		✗	return picture_type_name[type];
36			}
37
38			enum {
39			FF_HW_PICTURE_TYPE_IDR = 0,
40			FF_HW_PICTURE_TYPE_I = 1,
41			FF_HW_PICTURE_TYPE_P = 2,
42			FF_HW_PICTURE_TYPE_B = 3,
43			};
44
45			enum {
46			// Codec supports controlling the subdivision of pictures into slices.
47			FF_HW_FLAG_SLICE_CONTROL = 1 << 0,
48			// Codec only supports constant quality (no rate control).
49			FF_HW_FLAG_CONSTANT_QUALITY_ONLY = 1 << 1,
50			// Codec is intra-only.
51			FF_HW_FLAG_INTRA_ONLY = 1 << 2,
52			// Codec supports B-pictures.
53			FF_HW_FLAG_B_PICTURES = 1 << 3,
54			// Codec supports referencing B-pictures.
55			FF_HW_FLAG_B_PICTURE_REFERENCES = 1 << 4,
56			// Codec supports non-IDR key pictures (that is, key pictures do
57			// not necessarily empty the DPB).
58			FF_HW_FLAG_NON_IDR_KEY_PICTURES = 1 << 5,
59			};
60
61			typedef struct FFHWBaseEncodePicture {
62			// API-specific private data
63			void *priv;
64			// Codec-specific private data
65			void *codec_priv;
66
67			struct FFHWBaseEncodePicture *next;
68
69			int64_t display_order;
70			int64_t encode_order;
71			int64_t pts;
72			int64_t duration;
73			int force_idr;
74
75			void *opaque;
76			AVBufferRef *opaque_ref;
77
78			int type;
79			int b_depth;
80			int encode_issued;
81			int encode_complete;
82
83			AVFrame *input_image;
84			AVFrame *recon_image;
85
86			// Whether this picture is a reference picture.
87			int is_reference;
88
89			// The contents of the DPB after this picture has been decoded.
90			// This will contain the picture itself if it is a reference picture,
91			// but not if it isn't.
92			int nb_dpb_pics;
93			struct FFHWBaseEncodePicture *dpb[MAX_DPB_SIZE];
94			// The reference pictures used in decoding this picture. If they are
95			// used by later pictures they will also appear in the DPB. ref[0][] for
96			// previous reference frames. ref[1][] for future reference frames.
97			int nb_refs[MAX_REFERENCE_LIST_NUM];
98			struct FFHWBaseEncodePicture *refs[MAX_REFERENCE_LIST_NUM][MAX_PICTURE_REFERENCES];
99			// The previous reference picture in encode order. Must be in at least
100			// one of the reference list and DPB list.
101			struct FFHWBaseEncodePicture *prev;
102			// Reference count for other pictures referring to this one through
103			// the above pointers, directly from incomplete pictures and indirectly
104			// through completed pictures.
105			int ref_count[2];
106			int ref_removed[2];
107			} FFHWBaseEncodePicture;
108
109			typedef struct FFHWEncodePictureOperation {
110			// Size of API-specific internal picture data
111			size_t priv_size;
112			// Initialize API-specific internals
113			int (*init)(AVCodecContext *avctx, FFHWBaseEncodePicture *pic);
114			// Issue the picture structure, which will send the frame surface to HW Encode API.
115			int (*issue)(AVCodecContext *avctx, FFHWBaseEncodePicture *pic);
116			// Get the output AVPacket.
117			int (*output)(AVCodecContext *avctx, FFHWBaseEncodePicture *pic, AVPacket *pkt);
118			// Free the picture structure.
119			int (*free)(AVCodecContext *avctx, FFHWBaseEncodePicture *pic);
120			} FFHWEncodePictureOperation;
121
122			typedef struct FFHWBaseEncodeContext {
123			const AVClass *class;
124			void *log_ctx;
125
126			// Hardware-specific hooks.
127			const struct FFHWEncodePictureOperation *op;
128
129			// Global options.
130
131			// Number of I frames between IDR frames.
132			int idr_interval;
133
134			// Desired B frame reference depth.
135			int desired_b_depth;
136
137			// The required size of surfaces. This is probably the input
138			// size (AVCodecContext.width|height) aligned up to whatever
139			// block size is required by the codec.
140			int surface_width;
141			int surface_height;
142
143			// The block size for slice calculations.
144			int slice_block_width;
145			int slice_block_height;
146
147			// The hardware device context.
148			AVBufferRef *device_ref;
149			AVHWDeviceContext *device;
150
151			// The hardware frame context containing the input frames.
152			AVBufferRef *input_frames_ref;
153			AVHWFramesContext *input_frames;
154
155			// The hardware frame context containing the reconstructed frames.
156			AVBufferRef *recon_frames_ref;
157			AVHWFramesContext *recon_frames;
158
159			// Current encoding window, in display (input) order.
160			FFHWBaseEncodePicture *pic_start, *pic_end;
161			// The next picture to use as the previous reference picture in
162			// encoding order. Order from small to large in encoding order.
163			FFHWBaseEncodePicture *next_prev[MAX_PICTURE_REFERENCES];
164			int nb_next_prev;
165
166			// Next input order index (display order).
167			int64_t input_order;
168			// Number of frames that output is behind input.
169			int64_t output_delay;
170			// Next encode order index.
171			int64_t encode_order;
172			// Number of frames decode output will need to be delayed.
173			int64_t decode_delay;
174			// Next output order index (in encode order).
175			int64_t output_order;
176
177			// Timestamp handling.
178			int64_t first_pts;
179			int64_t dts_pts_diff;
180			int64_t ts_ring[MAX_REORDER_DELAY * 3 +
181			MAX_ASYNC_DEPTH];
182
183			// Frame type decision.
184			int gop_size;
185			int closed_gop;
186			int gop_per_idr;
187			int p_per_i;
188			int max_b_depth;
189			int b_per_p;
190			int force_idr;
191			int idr_counter;
192			int gop_counter;
193			int end_of_stream;
194			int p_to_gpb;
195
196			// The number of L0/L1 references supported by the driver.
197			int ref_l0;
198			int ref_l1;
199
200			// Whether the driver supports ROI at all.
201			int roi_allowed;
202
203			// The encoder does not support cropping information, so warn about
204			// it the first time we encounter any nonzero crop fields.
205			int crop_warned;
206			// If the driver does not support ROI then warn the first time we
207			// encounter a frame with ROI side data.
208			int roi_warned;
209
210			// The frame to be filled with data.
211			AVFrame *frame;
212
213			// Whether the HW supports sync buffer function.
214			// If supported, encode_fifo/async_depth will be used together.
215			// Used for output buffer synchronization.
216			int async_encode;
217
218			// Store buffered pic.
219			AVFifo *encode_fifo;
220			// Max number of frame buffered in encoder.
221			int async_depth;
222
223			/** Tail data of a pic, now only used for av1 repeat frame header. */
224			AVPacket *tail_pkt;
225			} FFHWBaseEncodeContext;
226
227			int ff_hw_base_encode_set_output_property(FFHWBaseEncodeContext *ctx, AVCodecContext *avctx,
228			FFHWBaseEncodePicture *pic, AVPacket *pkt, int flag_no_delay);
229
230			int ff_hw_base_encode_receive_packet(FFHWBaseEncodeContext *ctx, AVCodecContext *avctx, AVPacket *pkt);
231
232			int ff_hw_base_init_gop_structure(FFHWBaseEncodeContext *ctx, AVCodecContext *avctx,
233			uint32_t ref_l0, uint32_t ref_l1,
234			int flags, int prediction_pre_only);
235
236			int ff_hw_base_get_recon_format(FFHWBaseEncodeContext *ctx, const void *hwconfig,
237			enum AVPixelFormat *fmt);
238
239			int ff_hw_base_encode_init(AVCodecContext *avctx, FFHWBaseEncodeContext *ctx);
240
241			int ff_hw_base_encode_close(FFHWBaseEncodeContext *ctx);
242
243			#define HW_BASE_ENCODE_COMMON_OPTIONS \
244			{ "idr_interval", \
245			"Distance (in I-frames) between key frames", \
246			OFFSET(common.base.idr_interval), AV_OPT_TYPE_INT, \
247			{ .i64 = 0 }, 0, INT_MAX, FLAGS }, \
248			{ "b_depth", \
249			"Maximum B-frame reference depth", \
250			OFFSET(common.base.desired_b_depth), AV_OPT_TYPE_INT, \
251			{ .i64 = 1 }, 1, INT_MAX, FLAGS }, \
252			{ "async_depth", "Maximum processing parallelism. " \
253			"Increase this to improve single channel performance.", \
254			OFFSET(common.base.async_depth), AV_OPT_TYPE_INT, \
255			{ .i64 = 2 }, 1, MAX_ASYNC_DEPTH, FLAGS }
256
257			#endif /* AVCODEC_HW_BASE_ENCODE_H */
258