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 |
|
|
/** |
20 |
|
|
* @file |
21 |
|
|
* common internal api header. |
22 |
|
|
*/ |
23 |
|
|
|
24 |
|
|
#ifndef AVCODEC_INTERNAL_H |
25 |
|
|
#define AVCODEC_INTERNAL_H |
26 |
|
|
|
27 |
|
|
#include <stdint.h> |
28 |
|
|
|
29 |
|
|
#include "libavutil/buffer.h" |
30 |
|
|
#include "libavutil/channel_layout.h" |
31 |
|
|
#include "libavutil/fifo.h" |
32 |
|
|
#include "libavutil/mathematics.h" |
33 |
|
|
#include "libavutil/pixfmt.h" |
34 |
|
|
#include "avcodec.h" |
35 |
|
|
#include "config.h" |
36 |
|
|
|
37 |
|
|
/** |
38 |
|
|
* The codec does not modify any global variables in the init function, |
39 |
|
|
* allowing to call the init function without locking any global mutexes. |
40 |
|
|
*/ |
41 |
|
|
#define FF_CODEC_CAP_INIT_THREADSAFE (1 << 0) |
42 |
|
|
/** |
43 |
|
|
* The codec allows calling the close function for deallocation even if |
44 |
|
|
* the init function returned a failure. Without this capability flag, a |
45 |
|
|
* codec does such cleanup internally when returning failures from the |
46 |
|
|
* init function and does not expect the close function to be called at |
47 |
|
|
* all. |
48 |
|
|
*/ |
49 |
|
|
#define FF_CODEC_CAP_INIT_CLEANUP (1 << 1) |
50 |
|
|
/** |
51 |
|
|
* Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set |
52 |
|
|
* AVFrame.pkt_dts manually. If the flag is set, decode.c won't overwrite |
53 |
|
|
* this field. If it's unset, decode.c tries to guess the pkt_dts field |
54 |
|
|
* from the input AVPacket. |
55 |
|
|
*/ |
56 |
|
|
#define FF_CODEC_CAP_SETS_PKT_DTS (1 << 2) |
57 |
|
|
/** |
58 |
|
|
* The decoder extracts and fills its parameters even if the frame is |
59 |
|
|
* skipped due to the skip_frame setting. |
60 |
|
|
*/ |
61 |
|
|
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM (1 << 3) |
62 |
|
|
/** |
63 |
|
|
* The decoder sets the cropping fields in the output frames manually. |
64 |
|
|
* If this cap is set, the generic code will initialize output frame |
65 |
|
|
* dimensions to coded rather than display values. |
66 |
|
|
*/ |
67 |
|
|
#define FF_CODEC_CAP_EXPORTS_CROPPING (1 << 4) |
68 |
|
|
/** |
69 |
|
|
* Codec initializes slice-based threading with a main function |
70 |
|
|
*/ |
71 |
|
|
#define FF_CODEC_CAP_SLICE_THREAD_HAS_MF (1 << 5) |
72 |
|
|
/* |
73 |
|
|
* The codec supports frame threading and has inter-frame dependencies, so it |
74 |
|
|
* uses ff_thread_report/await_progress(). |
75 |
|
|
*/ |
76 |
|
|
#define FF_CODEC_CAP_ALLOCATE_PROGRESS (1 << 6) |
77 |
|
|
/** |
78 |
|
|
* Codec handles avctx->thread_count == 0 (auto) internally. |
79 |
|
|
*/ |
80 |
|
|
#define FF_CODEC_CAP_AUTO_THREADS (1 << 7) |
81 |
|
|
|
82 |
|
|
/** |
83 |
|
|
* AVCodec.codec_tags termination value |
84 |
|
|
*/ |
85 |
|
|
#define FF_CODEC_TAGS_END -1 |
86 |
|
|
|
87 |
|
|
|
88 |
|
|
#ifdef TRACE |
89 |
|
|
# define ff_tlog(ctx, ...) av_log(ctx, AV_LOG_TRACE, __VA_ARGS__) |
90 |
|
|
#else |
91 |
|
|
# define ff_tlog(ctx, ...) do { } while(0) |
92 |
|
|
#endif |
93 |
|
|
|
94 |
|
|
|
95 |
|
|
#define FF_DEFAULT_QUANT_BIAS 999999 |
96 |
|
|
|
97 |
|
|
#define FF_QSCALE_TYPE_MPEG1 0 |
98 |
|
|
#define FF_QSCALE_TYPE_MPEG2 1 |
99 |
|
|
#define FF_QSCALE_TYPE_H264 2 |
100 |
|
|
#define FF_QSCALE_TYPE_VP56 3 |
101 |
|
|
|
102 |
|
|
#define FF_SANE_NB_CHANNELS 512U |
103 |
|
|
|
104 |
|
|
#define FF_SIGNBIT(x) ((x) >> CHAR_BIT * sizeof(x) - 1) |
105 |
|
|
|
106 |
|
|
#if HAVE_SIMD_ALIGN_64 |
107 |
|
|
# define STRIDE_ALIGN 64 /* AVX-512 */ |
108 |
|
|
#elif HAVE_SIMD_ALIGN_32 |
109 |
|
|
# define STRIDE_ALIGN 32 |
110 |
|
|
#elif HAVE_SIMD_ALIGN_16 |
111 |
|
|
# define STRIDE_ALIGN 16 |
112 |
|
|
#else |
113 |
|
|
# define STRIDE_ALIGN 8 |
114 |
|
|
#endif |
115 |
|
|
|
116 |
|
|
typedef struct DecodeSimpleContext { |
117 |
|
|
AVPacket *in_pkt; |
118 |
|
|
} DecodeSimpleContext; |
119 |
|
|
|
120 |
|
|
typedef struct EncodeSimpleContext { |
121 |
|
|
AVFrame *in_frame; |
122 |
|
|
} EncodeSimpleContext; |
123 |
|
|
|
124 |
|
|
typedef struct AVCodecInternal { |
125 |
|
|
/** |
126 |
|
|
* Whether the parent AVCodecContext is a copy of the context which had |
127 |
|
|
* init() called on it. |
128 |
|
|
* This is used by multithreading - shared tables and picture pointers |
129 |
|
|
* should be freed from the original context only. |
130 |
|
|
*/ |
131 |
|
|
int is_copy; |
132 |
|
|
|
133 |
|
|
/** |
134 |
|
|
* An audio frame with less than required samples has been submitted and |
135 |
|
|
* padded with silence. Reject all subsequent frames. |
136 |
|
|
*/ |
137 |
|
|
int last_audio_frame; |
138 |
|
|
|
139 |
|
|
#if FF_API_OLD_ENCDEC |
140 |
|
|
AVFrame *to_free; |
141 |
|
|
#endif |
142 |
|
|
|
143 |
|
|
AVBufferRef *pool; |
144 |
|
|
|
145 |
|
|
void *thread_ctx; |
146 |
|
|
|
147 |
|
|
DecodeSimpleContext ds; |
148 |
|
|
AVBSFContext *bsf; |
149 |
|
|
|
150 |
|
|
/** |
151 |
|
|
* Properties (timestamps+side data) extracted from the last packet passed |
152 |
|
|
* for decoding. |
153 |
|
|
*/ |
154 |
|
|
AVPacket *last_pkt_props; |
155 |
|
|
AVFifoBuffer *pkt_props; |
156 |
|
|
|
157 |
|
|
/** |
158 |
|
|
* temporary buffer used for encoders to store their bitstream |
159 |
|
|
*/ |
160 |
|
|
uint8_t *byte_buffer; |
161 |
|
|
unsigned int byte_buffer_size; |
162 |
|
|
|
163 |
|
|
void *frame_thread_encoder; |
164 |
|
|
|
165 |
|
|
EncodeSimpleContext es; |
166 |
|
|
|
167 |
|
|
/** |
168 |
|
|
* Number of audio samples to skip at the start of the next decoded frame |
169 |
|
|
*/ |
170 |
|
|
int skip_samples; |
171 |
|
|
|
172 |
|
|
/** |
173 |
|
|
* hwaccel-specific private data |
174 |
|
|
*/ |
175 |
|
|
void *hwaccel_priv_data; |
176 |
|
|
|
177 |
|
|
/** |
178 |
|
|
* checks API usage: after codec draining, flush is required to resume operation |
179 |
|
|
*/ |
180 |
|
|
int draining; |
181 |
|
|
|
182 |
|
|
/** |
183 |
|
|
* buffers for using new encode/decode API through legacy API |
184 |
|
|
*/ |
185 |
|
|
AVPacket *buffer_pkt; |
186 |
|
|
AVFrame *buffer_frame; |
187 |
|
|
int draining_done; |
188 |
|
|
|
189 |
|
|
#if FF_API_OLD_ENCDEC |
190 |
|
|
int compat_decode_warned; |
191 |
|
|
/* this variable is set by the decoder internals to signal to the old |
192 |
|
|
* API compat wrappers the amount of data consumed from the last packet */ |
193 |
|
|
size_t compat_decode_consumed; |
194 |
|
|
/* when a partial packet has been consumed, this stores the remaining size |
195 |
|
|
* of the packet (that should be submitted in the next decode call */ |
196 |
|
|
size_t compat_decode_partial_size; |
197 |
|
|
AVFrame *compat_decode_frame; |
198 |
|
|
AVPacket *compat_encode_packet; |
199 |
|
|
#endif |
200 |
|
|
|
201 |
|
|
int showed_multi_packet_warning; |
202 |
|
|
|
203 |
|
|
int skip_samples_multiplier; |
204 |
|
|
|
205 |
|
|
/* to prevent infinite loop on errors when draining */ |
206 |
|
|
int nb_draining_errors; |
207 |
|
|
|
208 |
|
|
/* used when avctx flag AV_CODEC_FLAG_DROPCHANGED is set */ |
209 |
|
|
int changed_frames_dropped; |
210 |
|
|
int initial_format; |
211 |
|
|
int initial_width, initial_height; |
212 |
|
|
int initial_sample_rate; |
213 |
|
|
int initial_channels; |
214 |
|
|
uint64_t initial_channel_layout; |
215 |
|
|
} AVCodecInternal; |
216 |
|
|
|
217 |
|
|
struct AVCodecDefault { |
218 |
|
|
const uint8_t *key; |
219 |
|
|
const uint8_t *value; |
220 |
|
|
}; |
221 |
|
|
|
222 |
|
|
extern const uint8_t ff_log2_run[41]; |
223 |
|
|
|
224 |
|
|
/** |
225 |
|
|
* Return the index into tab at which {a,b} match elements {[0],[1]} of tab. |
226 |
|
|
* If there is no such matching pair then size is returned. |
227 |
|
|
*/ |
228 |
|
|
int ff_match_2uint16(const uint16_t (*tab)[2], int size, int a, int b); |
229 |
|
|
|
230 |
|
|
unsigned int avpriv_toupper4(unsigned int x); |
231 |
|
|
|
232 |
|
|
void ff_color_frame(AVFrame *frame, const int color[4]); |
233 |
|
|
|
234 |
|
|
/** |
235 |
|
|
* Maximum size in bytes of extradata. |
236 |
|
|
* This value was chosen such that every bit of the buffer is |
237 |
|
|
* addressable by a 32-bit signed integer as used by get_bits. |
238 |
|
|
*/ |
239 |
|
|
#define FF_MAX_EXTRADATA_SIZE ((1 << 28) - AV_INPUT_BUFFER_PADDING_SIZE) |
240 |
|
|
|
241 |
|
|
/** |
242 |
|
|
* Check AVPacket size and/or allocate data. |
243 |
|
|
* |
244 |
|
|
* Encoders supporting AVCodec.encode2() can use this as a convenience to |
245 |
|
|
* ensure the output packet data is large enough, whether provided by the user |
246 |
|
|
* or allocated in this function. |
247 |
|
|
* |
248 |
|
|
* @param avctx the AVCodecContext of the encoder |
249 |
|
|
* @param avpkt the AVPacket |
250 |
|
|
* If avpkt->data is already set, avpkt->size is checked |
251 |
|
|
* to ensure it is large enough. |
252 |
|
|
* If avpkt->data is NULL, a new buffer is allocated. |
253 |
|
|
* avpkt->size is set to the specified size. |
254 |
|
|
* All other AVPacket fields will be reset with av_init_packet(). |
255 |
|
|
* @param size the minimum required packet size |
256 |
|
|
* @param min_size This is a hint to the allocation algorithm, which indicates |
257 |
|
|
* to what minimal size the caller might later shrink the packet |
258 |
|
|
* to. Encoders often allocate packets which are larger than the |
259 |
|
|
* amount of data that is written into them as the exact amount is |
260 |
|
|
* not known at the time of allocation. min_size represents the |
261 |
|
|
* size a packet might be shrunk to by the caller. Can be set to |
262 |
|
|
* 0. setting this roughly correctly allows the allocation code |
263 |
|
|
* to choose between several allocation strategies to improve |
264 |
|
|
* speed slightly. |
265 |
|
|
* @return non negative on success, negative error code on failure |
266 |
|
|
*/ |
267 |
|
|
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size); |
268 |
|
|
|
269 |
|
|
/** |
270 |
|
|
* Rescale from sample rate to AVCodecContext.time_base. |
271 |
|
|
*/ |
272 |
|
296098 |
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, |
273 |
|
|
int64_t samples) |
274 |
|
|
{ |
275 |
✗✓ |
296098 |
if(samples == AV_NOPTS_VALUE) |
276 |
|
|
return AV_NOPTS_VALUE; |
277 |
|
296098 |
return av_rescale_q(samples, (AVRational){ 1, avctx->sample_rate }, |
278 |
|
|
avctx->time_base); |
279 |
|
|
} |
280 |
|
|
|
281 |
|
|
/** |
282 |
|
|
* 2^(x) for integer x |
283 |
|
|
* @return correctly rounded float |
284 |
|
|
*/ |
285 |
|
179564 |
static av_always_inline float ff_exp2fi(int x) { |
286 |
|
|
/* Normal range */ |
287 |
✓✗✓✗
|
179564 |
if (-126 <= x && x <= 128) |
288 |
|
179564 |
return av_int2float((x+127) << 23); |
289 |
|
|
/* Too large */ |
290 |
|
|
else if (x > 128) |
291 |
|
|
return INFINITY; |
292 |
|
|
/* Subnormal numbers */ |
293 |
|
|
else if (x > -150) |
294 |
|
|
return av_int2float(1 << (x+149)); |
295 |
|
|
/* Negligibly small */ |
296 |
|
|
else |
297 |
|
|
return 0; |
298 |
|
|
} |
299 |
|
|
|
300 |
|
|
/** |
301 |
|
|
* Get a buffer for a frame. This is a wrapper around |
302 |
|
|
* AVCodecContext.get_buffer() and should be used instead calling get_buffer() |
303 |
|
|
* directly. |
304 |
|
|
*/ |
305 |
|
|
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags); |
306 |
|
|
|
307 |
|
|
#define FF_REGET_BUFFER_FLAG_READONLY 1 ///< the returned buffer does not need to be writable |
308 |
|
|
/** |
309 |
|
|
* Identical in function to ff_get_buffer(), except it reuses the existing buffer |
310 |
|
|
* if available. |
311 |
|
|
*/ |
312 |
|
|
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags); |
313 |
|
|
|
314 |
|
|
int ff_thread_can_start_frame(AVCodecContext *avctx); |
315 |
|
|
|
316 |
|
|
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx); |
317 |
|
|
|
318 |
|
|
const uint8_t *avpriv_find_start_code(const uint8_t *p, |
319 |
|
|
const uint8_t *end, |
320 |
|
|
uint32_t *state); |
321 |
|
|
|
322 |
|
|
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec); |
323 |
|
|
|
324 |
|
|
/** |
325 |
|
|
* Check that the provided frame dimensions are valid and set them on the codec |
326 |
|
|
* context. |
327 |
|
|
*/ |
328 |
|
|
int ff_set_dimensions(AVCodecContext *s, int width, int height); |
329 |
|
|
|
330 |
|
|
/** |
331 |
|
|
* Check that the provided sample aspect ratio is valid and set it on the codec |
332 |
|
|
* context. |
333 |
|
|
*/ |
334 |
|
|
int ff_set_sar(AVCodecContext *avctx, AVRational sar); |
335 |
|
|
|
336 |
|
|
/** |
337 |
|
|
* Add or update AV_FRAME_DATA_MATRIXENCODING side data. |
338 |
|
|
*/ |
339 |
|
|
int ff_side_data_update_matrix_encoding(AVFrame *frame, |
340 |
|
|
enum AVMatrixEncoding matrix_encoding); |
341 |
|
|
|
342 |
|
|
/** |
343 |
|
|
* Select the (possibly hardware accelerated) pixel format. |
344 |
|
|
* This is a wrapper around AVCodecContext.get_format() and should be used |
345 |
|
|
* instead of calling get_format() directly. |
346 |
|
|
* |
347 |
|
|
* The list of pixel formats must contain at least one valid entry, and is |
348 |
|
|
* terminated with AV_PIX_FMT_NONE. If it is possible to decode to software, |
349 |
|
|
* the last entry in the list must be the most accurate software format. |
350 |
|
|
* If it is not possible to decode to software, AVCodecContext.sw_pix_fmt |
351 |
|
|
* must be set before calling this function. |
352 |
|
|
*/ |
353 |
|
|
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt); |
354 |
|
|
|
355 |
|
|
/** |
356 |
|
|
* Add a CPB properties side data to an encoding context. |
357 |
|
|
*/ |
358 |
|
|
AVCPBProperties *ff_add_cpb_side_data(AVCodecContext *avctx); |
359 |
|
|
|
360 |
|
|
/** |
361 |
|
|
* Check AVFrame for S12M timecode side data and allocate and fill TC SEI message with timecode info |
362 |
|
|
* |
363 |
|
|
* @param frame Raw frame to get S12M timecode side data from |
364 |
|
|
* @param rate The frame rate |
365 |
|
|
* @param prefix_len Number of bytes to allocate before SEI message |
366 |
|
|
* @param data Pointer to a variable to store allocated memory |
367 |
|
|
* Upon return the variable will hold NULL on error or if frame has no S12M timecode info. |
368 |
|
|
* Otherwise it will point to prefix_len uninitialized bytes followed by |
369 |
|
|
* *sei_size SEI message |
370 |
|
|
* @param sei_size Pointer to a variable to store generated SEI message length |
371 |
|
|
* @return Zero on success, negative error code on failure |
372 |
|
|
*/ |
373 |
|
|
int ff_alloc_timecode_sei(const AVFrame *frame, AVRational rate, size_t prefix_len, |
374 |
|
|
void **data, size_t *sei_size); |
375 |
|
|
|
376 |
|
|
/** |
377 |
|
|
* Get an estimated video bitrate based on frame size, frame rate and coded |
378 |
|
|
* bits per pixel. |
379 |
|
|
*/ |
380 |
|
|
int64_t ff_guess_coded_bitrate(AVCodecContext *avctx); |
381 |
|
|
|
382 |
|
|
/** |
383 |
|
|
* Check if a value is in the list. If not, return the default value |
384 |
|
|
* |
385 |
|
|
* @param ctx Context for the log msg |
386 |
|
|
* @param val_name Name of the checked value, for log msg |
387 |
|
|
* @param array_valid_values Array of valid int, ended with INT_MAX |
388 |
|
|
* @param default_value Value return if checked value is not in the array |
389 |
|
|
* @return Value or default_value. |
390 |
|
|
*/ |
391 |
|
|
int ff_int_from_list_or_default(void *ctx, const char * val_name, int val, |
392 |
|
|
const int * array_valid_values, int default_value); |
393 |
|
|
|
394 |
|
|
void ff_dvdsub_parse_palette(uint32_t *palette, const char *p); |
395 |
|
|
|
396 |
|
|
#if defined(_WIN32) && CONFIG_SHARED && !defined(BUILDING_avcodec) |
397 |
|
|
# define av_export_avcodec __declspec(dllimport) |
398 |
|
|
#else |
399 |
|
|
# define av_export_avcodec |
400 |
|
|
#endif |
401 |
|
|
|
402 |
|
|
#endif /* AVCODEC_INTERNAL_H */ |