1 |
|
|
/* |
2 |
|
|
* H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder |
3 |
|
|
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> |
4 |
|
|
* |
5 |
|
|
* This file is part of FFmpeg. |
6 |
|
|
* |
7 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
8 |
|
|
* modify it under the terms of the GNU Lesser General Public |
9 |
|
|
* License as published by the Free Software Foundation; either |
10 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
11 |
|
|
* |
12 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
13 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 |
|
|
* Lesser General Public License for more details. |
16 |
|
|
* |
17 |
|
|
* You should have received a copy of the GNU Lesser General Public |
18 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
19 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
20 |
|
|
*/ |
21 |
|
|
|
22 |
|
|
/** |
23 |
|
|
* @file |
24 |
|
|
* H.264 / AVC / MPEG-4 part10 codec. |
25 |
|
|
* @author Michael Niedermayer <michaelni@gmx.at> |
26 |
|
|
*/ |
27 |
|
|
|
28 |
|
|
#ifndef AVCODEC_H264DEC_H |
29 |
|
|
#define AVCODEC_H264DEC_H |
30 |
|
|
|
31 |
|
|
#include "libavutil/buffer.h" |
32 |
|
|
#include "libavutil/intreadwrite.h" |
33 |
|
|
#include "libavutil/mem_internal.h" |
34 |
|
|
#include "libavutil/thread.h" |
35 |
|
|
|
36 |
|
|
#include "cabac.h" |
37 |
|
|
#include "error_resilience.h" |
38 |
|
|
#include "h264_parse.h" |
39 |
|
|
#include "h264_ps.h" |
40 |
|
|
#include "h264_sei.h" |
41 |
|
|
#include "h2645_parse.h" |
42 |
|
|
#include "h264chroma.h" |
43 |
|
|
#include "h264dsp.h" |
44 |
|
|
#include "h264pred.h" |
45 |
|
|
#include "h264qpel.h" |
46 |
|
|
#include "internal.h" |
47 |
|
|
#include "mpegutils.h" |
48 |
|
|
#include "parser.h" |
49 |
|
|
#include "qpeldsp.h" |
50 |
|
|
#include "rectangle.h" |
51 |
|
|
#include "videodsp.h" |
52 |
|
|
|
53 |
|
|
#define H264_MAX_PICTURE_COUNT 36 |
54 |
|
|
|
55 |
|
|
#define MAX_MMCO_COUNT 66 |
56 |
|
|
|
57 |
|
|
#define MAX_DELAYED_PIC_COUNT 16 |
58 |
|
|
|
59 |
|
|
/* Compiling in interlaced support reduces the speed |
60 |
|
|
* of progressive decoding by about 2%. */ |
61 |
|
|
#define ALLOW_INTERLACE |
62 |
|
|
|
63 |
|
|
#define FMO 0 |
64 |
|
|
|
65 |
|
|
/** |
66 |
|
|
* The maximum number of slices supported by the decoder. |
67 |
|
|
* must be a power of 2 |
68 |
|
|
*/ |
69 |
|
|
#define MAX_SLICES 32 |
70 |
|
|
|
71 |
|
|
#ifdef ALLOW_INTERLACE |
72 |
|
|
#define MB_MBAFF(h) (h)->mb_mbaff |
73 |
|
|
#define MB_FIELD(sl) (sl)->mb_field_decoding_flag |
74 |
|
|
#define FRAME_MBAFF(h) (h)->mb_aff_frame |
75 |
|
|
#define FIELD_PICTURE(h) ((h)->picture_structure != PICT_FRAME) |
76 |
|
|
#define LEFT_MBS 2 |
77 |
|
|
#define LTOP 0 |
78 |
|
|
#define LBOT 1 |
79 |
|
|
#define LEFT(i) (i) |
80 |
|
|
#else |
81 |
|
|
#define MB_MBAFF(h) 0 |
82 |
|
|
#define MB_FIELD(sl) 0 |
83 |
|
|
#define FRAME_MBAFF(h) 0 |
84 |
|
|
#define FIELD_PICTURE(h) 0 |
85 |
|
|
#undef IS_INTERLACED |
86 |
|
|
#define IS_INTERLACED(mb_type) 0 |
87 |
|
|
#define LEFT_MBS 1 |
88 |
|
|
#define LTOP 0 |
89 |
|
|
#define LBOT 0 |
90 |
|
|
#define LEFT(i) 0 |
91 |
|
|
#endif |
92 |
|
|
#define FIELD_OR_MBAFF_PICTURE(h) (FRAME_MBAFF(h) || FIELD_PICTURE(h)) |
93 |
|
|
|
94 |
|
|
#ifndef CABAC |
95 |
|
|
#define CABAC(h) (h)->ps.pps->cabac |
96 |
|
|
#endif |
97 |
|
|
|
98 |
|
|
#define CHROMA(h) ((h)->ps.sps->chroma_format_idc) |
99 |
|
|
#define CHROMA422(h) ((h)->ps.sps->chroma_format_idc == 2) |
100 |
|
|
#define CHROMA444(h) ((h)->ps.sps->chroma_format_idc == 3) |
101 |
|
|
|
102 |
|
|
#define MB_TYPE_REF0 MB_TYPE_ACPRED // dirty but it fits in 16 bit |
103 |
|
|
#define MB_TYPE_8x8DCT 0x01000000 |
104 |
|
|
#define IS_REF0(a) ((a) & MB_TYPE_REF0) |
105 |
|
|
#define IS_8x8DCT(a) ((a) & MB_TYPE_8x8DCT) |
106 |
|
|
|
107 |
|
|
/** |
108 |
|
|
* Memory management control operation opcode. |
109 |
|
|
*/ |
110 |
|
|
typedef enum MMCOOpcode { |
111 |
|
|
MMCO_END = 0, |
112 |
|
|
MMCO_SHORT2UNUSED, |
113 |
|
|
MMCO_LONG2UNUSED, |
114 |
|
|
MMCO_SHORT2LONG, |
115 |
|
|
MMCO_SET_MAX_LONG, |
116 |
|
|
MMCO_RESET, |
117 |
|
|
MMCO_LONG, |
118 |
|
|
} MMCOOpcode; |
119 |
|
|
|
120 |
|
|
/** |
121 |
|
|
* Memory management control operation. |
122 |
|
|
*/ |
123 |
|
|
typedef struct MMCO { |
124 |
|
|
MMCOOpcode opcode; |
125 |
|
|
int short_pic_num; ///< pic_num without wrapping (pic_num & max_pic_num) |
126 |
|
|
int long_arg; ///< index, pic_num, or num long refs depending on opcode |
127 |
|
|
} MMCO; |
128 |
|
|
|
129 |
|
|
typedef struct H264Picture { |
130 |
|
|
AVFrame *f; |
131 |
|
|
ThreadFrame tf; |
132 |
|
|
|
133 |
|
|
AVBufferRef *qscale_table_buf; |
134 |
|
|
int8_t *qscale_table; |
135 |
|
|
|
136 |
|
|
AVBufferRef *motion_val_buf[2]; |
137 |
|
|
int16_t (*motion_val[2])[2]; |
138 |
|
|
|
139 |
|
|
AVBufferRef *mb_type_buf; |
140 |
|
|
uint32_t *mb_type; |
141 |
|
|
|
142 |
|
|
AVBufferRef *hwaccel_priv_buf; |
143 |
|
|
void *hwaccel_picture_private; ///< hardware accelerator private data |
144 |
|
|
|
145 |
|
|
AVBufferRef *ref_index_buf[2]; |
146 |
|
|
int8_t *ref_index[2]; |
147 |
|
|
|
148 |
|
|
int field_poc[2]; ///< top/bottom POC |
149 |
|
|
int poc; ///< frame POC |
150 |
|
|
int frame_num; ///< frame_num (raw frame_num from slice header) |
151 |
|
|
int mmco_reset; /**< MMCO_RESET set this 1. Reordering code must |
152 |
|
|
not mix pictures before and after MMCO_RESET. */ |
153 |
|
|
int pic_id; /**< pic_num (short -> no wrap version of pic_num, |
154 |
|
|
pic_num & max_pic_num; long -> long_pic_num) */ |
155 |
|
|
int long_ref; ///< 1->long term reference 0->short term reference |
156 |
|
|
int ref_poc[2][2][32]; ///< POCs of the frames/fields used as reference (FIXME need per slice) |
157 |
|
|
int ref_count[2][2]; ///< number of entries in ref_poc (FIXME need per slice) |
158 |
|
|
int mbaff; ///< 1 -> MBAFF frame 0-> not MBAFF |
159 |
|
|
int field_picture; ///< whether or not picture was encoded in separate fields |
160 |
|
|
|
161 |
|
|
int reference; |
162 |
|
|
int recovered; ///< picture at IDR or recovery point + recovery count |
163 |
|
|
int invalid_gap; |
164 |
|
|
int sei_recovery_frame_cnt; |
165 |
|
|
|
166 |
|
|
AVBufferRef *pps_buf; |
167 |
|
|
const PPS *pps; |
168 |
|
|
|
169 |
|
|
int mb_width, mb_height; |
170 |
|
|
int mb_stride; |
171 |
|
|
} H264Picture; |
172 |
|
|
|
173 |
|
|
typedef struct H264Ref { |
174 |
|
|
uint8_t *data[3]; |
175 |
|
|
int linesize[3]; |
176 |
|
|
|
177 |
|
|
int reference; |
178 |
|
|
int poc; |
179 |
|
|
int pic_id; |
180 |
|
|
|
181 |
|
|
H264Picture *parent; |
182 |
|
|
} H264Ref; |
183 |
|
|
|
184 |
|
|
typedef struct H264SliceContext { |
185 |
|
|
struct H264Context *h264; |
186 |
|
|
GetBitContext gb; |
187 |
|
|
ERContext er; |
188 |
|
|
|
189 |
|
|
int slice_num; |
190 |
|
|
int slice_type; |
191 |
|
|
int slice_type_nos; ///< S free slice type (SI/SP are remapped to I/P) |
192 |
|
|
int slice_type_fixed; |
193 |
|
|
|
194 |
|
|
int qscale; |
195 |
|
|
int chroma_qp[2]; // QPc |
196 |
|
|
int qp_thresh; ///< QP threshold to skip loopfilter |
197 |
|
|
int last_qscale_diff; |
198 |
|
|
|
199 |
|
|
// deblock |
200 |
|
|
int deblocking_filter; ///< disable_deblocking_filter_idc with 1 <-> 0 |
201 |
|
|
int slice_alpha_c0_offset; |
202 |
|
|
int slice_beta_offset; |
203 |
|
|
|
204 |
|
|
H264PredWeightTable pwt; |
205 |
|
|
|
206 |
|
|
int prev_mb_skipped; |
207 |
|
|
int next_mb_skipped; |
208 |
|
|
|
209 |
|
|
int chroma_pred_mode; |
210 |
|
|
int intra16x16_pred_mode; |
211 |
|
|
|
212 |
|
|
int8_t intra4x4_pred_mode_cache[5 * 8]; |
213 |
|
|
int8_t(*intra4x4_pred_mode); |
214 |
|
|
|
215 |
|
|
int topleft_mb_xy; |
216 |
|
|
int top_mb_xy; |
217 |
|
|
int topright_mb_xy; |
218 |
|
|
int left_mb_xy[LEFT_MBS]; |
219 |
|
|
|
220 |
|
|
int topleft_type; |
221 |
|
|
int top_type; |
222 |
|
|
int topright_type; |
223 |
|
|
int left_type[LEFT_MBS]; |
224 |
|
|
|
225 |
|
|
const uint8_t *left_block; |
226 |
|
|
int topleft_partition; |
227 |
|
|
|
228 |
|
|
unsigned int topleft_samples_available; |
229 |
|
|
unsigned int top_samples_available; |
230 |
|
|
unsigned int topright_samples_available; |
231 |
|
|
unsigned int left_samples_available; |
232 |
|
|
|
233 |
|
|
ptrdiff_t linesize, uvlinesize; |
234 |
|
|
ptrdiff_t mb_linesize; ///< may be equal to s->linesize or s->linesize * 2, for mbaff |
235 |
|
|
ptrdiff_t mb_uvlinesize; |
236 |
|
|
|
237 |
|
|
int mb_x, mb_y; |
238 |
|
|
int mb_xy; |
239 |
|
|
int resync_mb_x; |
240 |
|
|
int resync_mb_y; |
241 |
|
|
unsigned int first_mb_addr; |
242 |
|
|
// index of the first MB of the next slice |
243 |
|
|
int next_slice_idx; |
244 |
|
|
int mb_skip_run; |
245 |
|
|
int is_complex; |
246 |
|
|
|
247 |
|
|
int picture_structure; |
248 |
|
|
int mb_field_decoding_flag; |
249 |
|
|
int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag |
250 |
|
|
|
251 |
|
|
int redundant_pic_count; |
252 |
|
|
|
253 |
|
|
/** |
254 |
|
|
* number of neighbors (top and/or left) that used 8x8 dct |
255 |
|
|
*/ |
256 |
|
|
int neighbor_transform_size; |
257 |
|
|
|
258 |
|
|
int direct_spatial_mv_pred; |
259 |
|
|
int col_parity; |
260 |
|
|
int col_fieldoff; |
261 |
|
|
|
262 |
|
|
int cbp; |
263 |
|
|
int top_cbp; |
264 |
|
|
int left_cbp; |
265 |
|
|
|
266 |
|
|
int dist_scale_factor[32]; |
267 |
|
|
int dist_scale_factor_field[2][32]; |
268 |
|
|
int map_col_to_list0[2][16 + 32]; |
269 |
|
|
int map_col_to_list0_field[2][2][16 + 32]; |
270 |
|
|
|
271 |
|
|
/** |
272 |
|
|
* num_ref_idx_l0/1_active_minus1 + 1 |
273 |
|
|
*/ |
274 |
|
|
unsigned int ref_count[2]; ///< counts frames or fields, depending on current mb mode |
275 |
|
|
unsigned int list_count; |
276 |
|
|
H264Ref ref_list[2][48]; /**< 0..15: frame refs, 16..47: mbaff field refs. |
277 |
|
|
* Reordered version of default_ref_list |
278 |
|
|
* according to picture reordering in slice header */ |
279 |
|
|
struct { |
280 |
|
|
uint8_t op; |
281 |
|
|
uint32_t val; |
282 |
|
|
} ref_modifications[2][32]; |
283 |
|
|
int nb_ref_modifications[2]; |
284 |
|
|
|
285 |
|
|
unsigned int pps_id; |
286 |
|
|
|
287 |
|
|
const uint8_t *intra_pcm_ptr; |
288 |
|
|
int16_t *dc_val_base; |
289 |
|
|
|
290 |
|
|
uint8_t *bipred_scratchpad; |
291 |
|
|
uint8_t *edge_emu_buffer; |
292 |
|
|
uint8_t (*top_borders[2])[(16 * 3) * 2]; |
293 |
|
|
int bipred_scratchpad_allocated; |
294 |
|
|
int edge_emu_buffer_allocated; |
295 |
|
|
int top_borders_allocated[2]; |
296 |
|
|
|
297 |
|
|
/** |
298 |
|
|
* non zero coeff count cache. |
299 |
|
|
* is 64 if not available. |
300 |
|
|
*/ |
301 |
|
|
DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8]; |
302 |
|
|
|
303 |
|
|
/** |
304 |
|
|
* Motion vector cache. |
305 |
|
|
*/ |
306 |
|
|
DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2]; |
307 |
|
|
DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8]; |
308 |
|
|
DECLARE_ALIGNED(16, uint8_t, mvd_cache)[2][5 * 8][2]; |
309 |
|
|
uint8_t direct_cache[5 * 8]; |
310 |
|
|
|
311 |
|
|
DECLARE_ALIGNED(8, uint16_t, sub_mb_type)[4]; |
312 |
|
|
|
313 |
|
|
///< as a DCT coefficient is int32_t in high depth, we need to reserve twice the space. |
314 |
|
|
DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2]; |
315 |
|
|
DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2]; |
316 |
|
|
///< as mb is addressed by scantable[i] and scantable is uint8_t we can either |
317 |
|
|
///< check that i is not too large or ensure that there is some unused stuff after mb |
318 |
|
|
int16_t mb_padding[256 * 2]; |
319 |
|
|
|
320 |
|
|
uint8_t (*mvd_table[2])[2]; |
321 |
|
|
|
322 |
|
|
/** |
323 |
|
|
* Cabac |
324 |
|
|
*/ |
325 |
|
|
CABACContext cabac; |
326 |
|
|
uint8_t cabac_state[1024]; |
327 |
|
|
int cabac_init_idc; |
328 |
|
|
|
329 |
|
|
MMCO mmco[MAX_MMCO_COUNT]; |
330 |
|
|
int nb_mmco; |
331 |
|
|
int explicit_ref_marking; |
332 |
|
|
|
333 |
|
|
int frame_num; |
334 |
|
|
int poc_lsb; |
335 |
|
|
int delta_poc_bottom; |
336 |
|
|
int delta_poc[2]; |
337 |
|
|
int curr_pic_num; |
338 |
|
|
int max_pic_num; |
339 |
|
|
} H264SliceContext; |
340 |
|
|
|
341 |
|
|
/** |
342 |
|
|
* H264Context |
343 |
|
|
*/ |
344 |
|
|
typedef struct H264Context { |
345 |
|
|
const AVClass *class; |
346 |
|
|
AVCodecContext *avctx; |
347 |
|
|
VideoDSPContext vdsp; |
348 |
|
|
H264DSPContext h264dsp; |
349 |
|
|
H264ChromaContext h264chroma; |
350 |
|
|
H264QpelContext h264qpel; |
351 |
|
|
|
352 |
|
|
H264Picture DPB[H264_MAX_PICTURE_COUNT]; |
353 |
|
|
H264Picture *cur_pic_ptr; |
354 |
|
|
H264Picture cur_pic; |
355 |
|
|
H264Picture last_pic_for_ec; |
356 |
|
|
|
357 |
|
|
H264SliceContext *slice_ctx; |
358 |
|
|
int nb_slice_ctx; |
359 |
|
|
int nb_slice_ctx_queued; |
360 |
|
|
|
361 |
|
|
H2645Packet pkt; |
362 |
|
|
|
363 |
|
|
int pixel_shift; ///< 0 for 8-bit H.264, 1 for high-bit-depth H.264 |
364 |
|
|
|
365 |
|
|
/* coded dimensions -- 16 * mb w/h */ |
366 |
|
|
int width, height; |
367 |
|
|
int chroma_x_shift, chroma_y_shift; |
368 |
|
|
|
369 |
|
|
int droppable; |
370 |
|
|
int coded_picture_number; |
371 |
|
|
|
372 |
|
|
int context_initialized; |
373 |
|
|
int flags; |
374 |
|
|
int workaround_bugs; |
375 |
|
|
int x264_build; |
376 |
|
|
/* Set when slice threading is used and at least one slice uses deblocking |
377 |
|
|
* mode 1 (i.e. across slice boundaries). Then we disable the loop filter |
378 |
|
|
* during normal MB decoding and execute it serially at the end. |
379 |
|
|
*/ |
380 |
|
|
int postpone_filter; |
381 |
|
|
|
382 |
|
|
/* |
383 |
|
|
* Set to 1 when the current picture is IDR, 0 otherwise. |
384 |
|
|
*/ |
385 |
|
|
int picture_idr; |
386 |
|
|
|
387 |
|
|
int crop_left; |
388 |
|
|
int crop_right; |
389 |
|
|
int crop_top; |
390 |
|
|
int crop_bottom; |
391 |
|
|
|
392 |
|
|
int8_t(*intra4x4_pred_mode); |
393 |
|
|
H264PredContext hpc; |
394 |
|
|
|
395 |
|
|
uint8_t (*non_zero_count)[48]; |
396 |
|
|
|
397 |
|
|
#define LIST_NOT_USED -1 // FIXME rename? |
398 |
|
|
#define PART_NOT_AVAILABLE -2 |
399 |
|
|
|
400 |
|
|
/** |
401 |
|
|
* block_offset[ 0..23] for frame macroblocks |
402 |
|
|
* block_offset[24..47] for field macroblocks |
403 |
|
|
*/ |
404 |
|
|
int block_offset[2 * (16 * 3)]; |
405 |
|
|
|
406 |
|
|
uint32_t *mb2b_xy; // FIXME are these 4 a good idea? |
407 |
|
|
uint32_t *mb2br_xy; |
408 |
|
|
int b_stride; // FIXME use s->b4_stride |
409 |
|
|
|
410 |
|
|
uint16_t *slice_table; ///< slice_table_base + 2*mb_stride + 1 |
411 |
|
|
|
412 |
|
|
// interlacing specific flags |
413 |
|
|
int mb_aff_frame; |
414 |
|
|
int picture_structure; |
415 |
|
|
int first_field; |
416 |
|
|
|
417 |
|
|
uint8_t *list_counts; ///< Array of list_count per MB specifying the slice type |
418 |
|
|
|
419 |
|
|
/* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0, 1, 2), 0x0? luma_cbp */ |
420 |
|
|
uint16_t *cbp_table; |
421 |
|
|
|
422 |
|
|
/* chroma_pred_mode for i4x4 or i16x16, else 0 */ |
423 |
|
|
uint8_t *chroma_pred_mode_table; |
424 |
|
|
uint8_t (*mvd_table[2])[2]; |
425 |
|
|
uint8_t *direct_table; |
426 |
|
|
|
427 |
|
|
uint8_t scan_padding[16]; |
428 |
|
|
uint8_t zigzag_scan[16]; |
429 |
|
|
uint8_t zigzag_scan8x8[64]; |
430 |
|
|
uint8_t zigzag_scan8x8_cavlc[64]; |
431 |
|
|
uint8_t field_scan[16]; |
432 |
|
|
uint8_t field_scan8x8[64]; |
433 |
|
|
uint8_t field_scan8x8_cavlc[64]; |
434 |
|
|
uint8_t zigzag_scan_q0[16]; |
435 |
|
|
uint8_t zigzag_scan8x8_q0[64]; |
436 |
|
|
uint8_t zigzag_scan8x8_cavlc_q0[64]; |
437 |
|
|
uint8_t field_scan_q0[16]; |
438 |
|
|
uint8_t field_scan8x8_q0[64]; |
439 |
|
|
uint8_t field_scan8x8_cavlc_q0[64]; |
440 |
|
|
|
441 |
|
|
int mb_y; |
442 |
|
|
int mb_height, mb_width; |
443 |
|
|
int mb_stride; |
444 |
|
|
int mb_num; |
445 |
|
|
|
446 |
|
|
// ============================================================= |
447 |
|
|
// Things below are not used in the MB or more inner code |
448 |
|
|
|
449 |
|
|
int nal_ref_idc; |
450 |
|
|
int nal_unit_type; |
451 |
|
|
|
452 |
|
|
int has_slice; ///< slice NAL is found in the packet, set by decode_nal_units, its state does not need to be preserved outside h264_decode_frame() |
453 |
|
|
|
454 |
|
|
/** |
455 |
|
|
* Used to parse AVC variant of H.264 |
456 |
|
|
*/ |
457 |
|
|
int is_avc; ///< this flag is != 0 if codec is avc1 |
458 |
|
|
int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) |
459 |
|
|
|
460 |
|
|
int bit_depth_luma; ///< luma bit depth from sps to detect changes |
461 |
|
|
int chroma_format_idc; ///< chroma format from sps to detect changes |
462 |
|
|
|
463 |
|
|
H264ParamSets ps; |
464 |
|
|
|
465 |
|
|
uint16_t *slice_table_base; |
466 |
|
|
|
467 |
|
|
H264POCContext poc; |
468 |
|
|
|
469 |
|
|
H264Ref default_ref[2]; |
470 |
|
|
H264Picture *short_ref[32]; |
471 |
|
|
H264Picture *long_ref[32]; |
472 |
|
|
H264Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size? |
473 |
|
|
int last_pocs[MAX_DELAYED_PIC_COUNT]; |
474 |
|
|
H264Picture *next_output_pic; |
475 |
|
|
int next_outputed_poc; |
476 |
|
|
|
477 |
|
|
/** |
478 |
|
|
* memory management control operations buffer. |
479 |
|
|
*/ |
480 |
|
|
MMCO mmco[MAX_MMCO_COUNT]; |
481 |
|
|
int nb_mmco; |
482 |
|
|
int mmco_reset; |
483 |
|
|
int explicit_ref_marking; |
484 |
|
|
|
485 |
|
|
int long_ref_count; ///< number of actual long term references |
486 |
|
|
int short_ref_count; ///< number of actual short term references |
487 |
|
|
|
488 |
|
|
/** |
489 |
|
|
* @name Members for slice based multithreading |
490 |
|
|
* @{ |
491 |
|
|
*/ |
492 |
|
|
/** |
493 |
|
|
* current slice number, used to initialize slice_num of each thread/context |
494 |
|
|
*/ |
495 |
|
|
int current_slice; |
496 |
|
|
|
497 |
|
|
/** @} */ |
498 |
|
|
|
499 |
|
|
/** |
500 |
|
|
* Complement sei_pic_struct |
501 |
|
|
* SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames. |
502 |
|
|
* However, soft telecined frames may have these values. |
503 |
|
|
* This is used in an attempt to flag soft telecine progressive. |
504 |
|
|
*/ |
505 |
|
|
int prev_interlaced_frame; |
506 |
|
|
|
507 |
|
|
/** |
508 |
|
|
* Are the SEI recovery points looking valid. |
509 |
|
|
*/ |
510 |
|
|
int valid_recovery_point; |
511 |
|
|
|
512 |
|
|
/** |
513 |
|
|
* recovery_frame is the frame_num at which the next frame should |
514 |
|
|
* be fully constructed. |
515 |
|
|
* |
516 |
|
|
* Set to -1 when not expecting a recovery point. |
517 |
|
|
*/ |
518 |
|
|
int recovery_frame; |
519 |
|
|
|
520 |
|
|
/** |
521 |
|
|
* We have seen an IDR, so all the following frames in coded order are correctly |
522 |
|
|
* decodable. |
523 |
|
|
*/ |
524 |
|
|
#define FRAME_RECOVERED_IDR (1 << 0) |
525 |
|
|
/** |
526 |
|
|
* Sufficient number of frames have been decoded since a SEI recovery point, |
527 |
|
|
* so all the following frames in presentation order are correct. |
528 |
|
|
*/ |
529 |
|
|
#define FRAME_RECOVERED_SEI (1 << 1) |
530 |
|
|
|
531 |
|
|
int frame_recovered; ///< Initial frame has been completely recovered |
532 |
|
|
|
533 |
|
|
int has_recovery_point; |
534 |
|
|
|
535 |
|
|
int missing_fields; |
536 |
|
|
|
537 |
|
|
/* for frame threading, this is set to 1 |
538 |
|
|
* after finish_setup() has been called, so we cannot modify |
539 |
|
|
* some context properties (which are supposed to stay constant between |
540 |
|
|
* slices) anymore */ |
541 |
|
|
int setup_finished; |
542 |
|
|
|
543 |
|
|
int cur_chroma_format_idc; |
544 |
|
|
int cur_bit_depth_luma; |
545 |
|
|
int16_t slice_row[MAX_SLICES]; ///< to detect when MAX_SLICES is too low |
546 |
|
|
|
547 |
|
|
/* original AVCodecContext dimensions, used to handle container |
548 |
|
|
* cropping */ |
549 |
|
|
int width_from_caller; |
550 |
|
|
int height_from_caller; |
551 |
|
|
|
552 |
|
|
int enable_er; |
553 |
|
|
|
554 |
|
|
H264SEIContext sei; |
555 |
|
|
|
556 |
|
|
AVBufferPool *qscale_table_pool; |
557 |
|
|
AVBufferPool *mb_type_pool; |
558 |
|
|
AVBufferPool *motion_val_pool; |
559 |
|
|
AVBufferPool *ref_index_pool; |
560 |
|
|
int ref2frm[MAX_SLICES][2][64]; ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1 |
561 |
|
|
} H264Context; |
562 |
|
|
|
563 |
|
|
extern const uint16_t ff_h264_mb_sizes[4]; |
564 |
|
|
|
565 |
|
|
/** |
566 |
|
|
* Reconstruct bitstream slice_type. |
567 |
|
|
*/ |
568 |
|
|
int ff_h264_get_slice_type(const H264SliceContext *sl); |
569 |
|
|
|
570 |
|
|
/** |
571 |
|
|
* Allocate tables. |
572 |
|
|
* needs width/height |
573 |
|
|
*/ |
574 |
|
|
int ff_h264_alloc_tables(H264Context *h); |
575 |
|
|
|
576 |
|
|
int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx); |
577 |
|
|
int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl); |
578 |
|
|
void ff_h264_remove_all_refs(H264Context *h); |
579 |
|
|
|
580 |
|
|
/** |
581 |
|
|
* Execute the reference picture marking (memory management control operations). |
582 |
|
|
*/ |
583 |
|
|
int ff_h264_execute_ref_pic_marking(H264Context *h); |
584 |
|
|
|
585 |
|
|
int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, |
586 |
|
|
const H2645NAL *nal, void *logctx); |
587 |
|
|
|
588 |
|
|
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl); |
589 |
|
|
void ff_h264_decode_init_vlc(void); |
590 |
|
|
|
591 |
|
|
/** |
592 |
|
|
* Decode a macroblock |
593 |
|
|
* @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error |
594 |
|
|
*/ |
595 |
|
|
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl); |
596 |
|
|
|
597 |
|
|
/** |
598 |
|
|
* Decode a CABAC coded macroblock |
599 |
|
|
* @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error |
600 |
|
|
*/ |
601 |
|
|
int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl); |
602 |
|
|
|
603 |
|
|
void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl); |
604 |
|
|
|
605 |
|
|
void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl); |
606 |
|
|
void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl); |
607 |
|
|
void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl, |
608 |
|
|
int *mb_type); |
609 |
|
|
|
610 |
|
|
void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, |
611 |
|
|
uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, |
612 |
|
|
unsigned int linesize, unsigned int uvlinesize); |
613 |
|
|
void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, |
614 |
|
|
uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, |
615 |
|
|
unsigned int linesize, unsigned int uvlinesize); |
616 |
|
|
|
617 |
|
|
/* |
618 |
|
|
* o-o o-o |
619 |
|
|
* / / / |
620 |
|
|
* o-o o-o |
621 |
|
|
* ,---' |
622 |
|
|
* o-o o-o |
623 |
|
|
* / / / |
624 |
|
|
* o-o o-o |
625 |
|
|
*/ |
626 |
|
|
|
627 |
|
|
/* Scan8 organization: |
628 |
|
|
* 0 1 2 3 4 5 6 7 |
629 |
|
|
* 0 DY y y y y y |
630 |
|
|
* 1 y Y Y Y Y |
631 |
|
|
* 2 y Y Y Y Y |
632 |
|
|
* 3 y Y Y Y Y |
633 |
|
|
* 4 y Y Y Y Y |
634 |
|
|
* 5 DU u u u u u |
635 |
|
|
* 6 u U U U U |
636 |
|
|
* 7 u U U U U |
637 |
|
|
* 8 u U U U U |
638 |
|
|
* 9 u U U U U |
639 |
|
|
* 10 DV v v v v v |
640 |
|
|
* 11 v V V V V |
641 |
|
|
* 12 v V V V V |
642 |
|
|
* 13 v V V V V |
643 |
|
|
* 14 v V V V V |
644 |
|
|
* DY/DU/DV are for luma/chroma DC. |
645 |
|
|
*/ |
646 |
|
|
|
647 |
|
|
#define LUMA_DC_BLOCK_INDEX 48 |
648 |
|
|
#define CHROMA_DC_BLOCK_INDEX 49 |
649 |
|
|
|
650 |
|
|
// This table must be here because scan8[constant] must be known at compiletime |
651 |
|
|
static const uint8_t scan8[16 * 3 + 3] = { |
652 |
|
|
4 + 1 * 8, 5 + 1 * 8, 4 + 2 * 8, 5 + 2 * 8, |
653 |
|
|
6 + 1 * 8, 7 + 1 * 8, 6 + 2 * 8, 7 + 2 * 8, |
654 |
|
|
4 + 3 * 8, 5 + 3 * 8, 4 + 4 * 8, 5 + 4 * 8, |
655 |
|
|
6 + 3 * 8, 7 + 3 * 8, 6 + 4 * 8, 7 + 4 * 8, |
656 |
|
|
4 + 6 * 8, 5 + 6 * 8, 4 + 7 * 8, 5 + 7 * 8, |
657 |
|
|
6 + 6 * 8, 7 + 6 * 8, 6 + 7 * 8, 7 + 7 * 8, |
658 |
|
|
4 + 8 * 8, 5 + 8 * 8, 4 + 9 * 8, 5 + 9 * 8, |
659 |
|
|
6 + 8 * 8, 7 + 8 * 8, 6 + 9 * 8, 7 + 9 * 8, |
660 |
|
|
4 + 11 * 8, 5 + 11 * 8, 4 + 12 * 8, 5 + 12 * 8, |
661 |
|
|
6 + 11 * 8, 7 + 11 * 8, 6 + 12 * 8, 7 + 12 * 8, |
662 |
|
|
4 + 13 * 8, 5 + 13 * 8, 4 + 14 * 8, 5 + 14 * 8, |
663 |
|
|
6 + 13 * 8, 7 + 13 * 8, 6 + 14 * 8, 7 + 14 * 8, |
664 |
|
|
0 + 0 * 8, 0 + 5 * 8, 0 + 10 * 8 |
665 |
|
|
}; |
666 |
|
|
|
667 |
|
31328544 |
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b) |
668 |
|
|
{ |
669 |
|
|
#if HAVE_BIGENDIAN |
670 |
|
|
return (b & 0xFFFF) + (a << 16); |
671 |
|
|
#else |
672 |
|
31328544 |
return (a & 0xFFFF) + (b << 16); |
673 |
|
|
#endif |
674 |
|
|
} |
675 |
|
|
|
676 |
|
3719437 |
static av_always_inline uint16_t pack8to16(unsigned a, unsigned b) |
677 |
|
|
{ |
678 |
|
|
#if HAVE_BIGENDIAN |
679 |
|
|
return (b & 0xFF) + (a << 8); |
680 |
|
|
#else |
681 |
|
3719437 |
return (a & 0xFF) + (b << 8); |
682 |
|
|
#endif |
683 |
|
|
} |
684 |
|
|
|
685 |
|
|
/** |
686 |
|
|
* Get the chroma qp. |
687 |
|
|
*/ |
688 |
|
58474014 |
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale) |
689 |
|
|
{ |
690 |
|
58474014 |
return pps->chroma_qp_table[t][qscale]; |
691 |
|
|
} |
692 |
|
|
|
693 |
|
|
/** |
694 |
|
|
* Get the predicted intra4x4 prediction mode. |
695 |
|
|
*/ |
696 |
|
28715316 |
static av_always_inline int pred_intra_mode(const H264Context *h, |
697 |
|
|
H264SliceContext *sl, int n) |
698 |
|
|
{ |
699 |
|
28715316 |
const int index8 = scan8[n]; |
700 |
|
28715316 |
const int left = sl->intra4x4_pred_mode_cache[index8 - 1]; |
701 |
|
28715316 |
const int top = sl->intra4x4_pred_mode_cache[index8 - 8]; |
702 |
|
28715316 |
const int min = FFMIN(left, top); |
703 |
|
|
|
704 |
|
|
ff_tlog(h->avctx, "mode:%d %d min:%d\n", left, top, min); |
705 |
|
|
|
706 |
✓✓ |
28715316 |
if (min < 0) |
707 |
|
814253 |
return DC_PRED; |
708 |
|
|
else |
709 |
|
27901063 |
return min; |
710 |
|
|
} |
711 |
|
|
|
712 |
|
2884335 |
static av_always_inline void write_back_intra_pred_mode(const H264Context *h, |
713 |
|
|
H264SliceContext *sl) |
714 |
|
|
{ |
715 |
|
2884335 |
int8_t *i4x4 = sl->intra4x4_pred_mode + h->mb2br_xy[sl->mb_xy]; |
716 |
|
2884335 |
int8_t *i4x4_cache = sl->intra4x4_pred_mode_cache; |
717 |
|
|
|
718 |
|
2884335 |
AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4); |
719 |
|
2884335 |
i4x4[4] = i4x4_cache[7 + 8 * 3]; |
720 |
|
2884335 |
i4x4[5] = i4x4_cache[7 + 8 * 2]; |
721 |
|
2884335 |
i4x4[6] = i4x4_cache[7 + 8 * 1]; |
722 |
|
2884335 |
} |
723 |
|
|
|
724 |
|
9857218 |
static av_always_inline void write_back_non_zero_count(const H264Context *h, |
725 |
|
|
H264SliceContext *sl) |
726 |
|
|
{ |
727 |
|
9857218 |
const int mb_xy = sl->mb_xy; |
728 |
|
9857218 |
uint8_t *nnz = h->non_zero_count[mb_xy]; |
729 |
|
9857218 |
uint8_t *nnz_cache = sl->non_zero_count_cache; |
730 |
|
|
|
731 |
|
9857218 |
AV_COPY32(&nnz[ 0], &nnz_cache[4 + 8 * 1]); |
732 |
|
9857218 |
AV_COPY32(&nnz[ 4], &nnz_cache[4 + 8 * 2]); |
733 |
|
9857218 |
AV_COPY32(&nnz[ 8], &nnz_cache[4 + 8 * 3]); |
734 |
|
9857218 |
AV_COPY32(&nnz[12], &nnz_cache[4 + 8 * 4]); |
735 |
|
9857218 |
AV_COPY32(&nnz[16], &nnz_cache[4 + 8 * 6]); |
736 |
|
9857218 |
AV_COPY32(&nnz[20], &nnz_cache[4 + 8 * 7]); |
737 |
|
9857218 |
AV_COPY32(&nnz[32], &nnz_cache[4 + 8 * 11]); |
738 |
|
9857218 |
AV_COPY32(&nnz[36], &nnz_cache[4 + 8 * 12]); |
739 |
|
|
|
740 |
✓✓ |
9857218 |
if (!h->chroma_y_shift) { |
741 |
|
917795 |
AV_COPY32(&nnz[24], &nnz_cache[4 + 8 * 8]); |
742 |
|
917795 |
AV_COPY32(&nnz[28], &nnz_cache[4 + 8 * 9]); |
743 |
|
917795 |
AV_COPY32(&nnz[40], &nnz_cache[4 + 8 * 13]); |
744 |
|
917795 |
AV_COPY32(&nnz[44], &nnz_cache[4 + 8 * 14]); |
745 |
|
|
} |
746 |
|
9857218 |
} |
747 |
|
|
|
748 |
|
11980092 |
static av_always_inline void write_back_motion_list(const H264Context *h, |
749 |
|
|
H264SliceContext *sl, |
750 |
|
|
int b_stride, |
751 |
|
|
int b_xy, int b8_xy, |
752 |
|
|
int mb_type, int list) |
753 |
|
|
{ |
754 |
|
11980092 |
int16_t(*mv_dst)[2] = &h->cur_pic.motion_val[list][b_xy]; |
755 |
|
11980092 |
int16_t(*mv_src)[2] = &sl->mv_cache[list][scan8[0]]; |
756 |
|
11980092 |
AV_COPY128(mv_dst + 0 * b_stride, mv_src + 8 * 0); |
757 |
|
11980092 |
AV_COPY128(mv_dst + 1 * b_stride, mv_src + 8 * 1); |
758 |
|
11980092 |
AV_COPY128(mv_dst + 2 * b_stride, mv_src + 8 * 2); |
759 |
|
11980092 |
AV_COPY128(mv_dst + 3 * b_stride, mv_src + 8 * 3); |
760 |
|
|
if (CABAC(h)) { |
761 |
|
8407479 |
uint8_t (*mvd_dst)[2] = &sl->mvd_table[list][FMO ? 8 * sl->mb_xy |
762 |
|
8407479 |
: h->mb2br_xy[sl->mb_xy]]; |
763 |
|
8407479 |
uint8_t(*mvd_src)[2] = &sl->mvd_cache[list][scan8[0]]; |
764 |
✓✓ |
8407479 |
if (IS_SKIP(mb_type)) { |
765 |
|
3265569 |
AV_ZERO128(mvd_dst); |
766 |
|
|
} else { |
767 |
|
5141910 |
AV_COPY64(mvd_dst, mvd_src + 8 * 3); |
768 |
|
5141910 |
AV_COPY16(mvd_dst + 3 + 3, mvd_src + 3 + 8 * 0); |
769 |
|
5141910 |
AV_COPY16(mvd_dst + 3 + 2, mvd_src + 3 + 8 * 1); |
770 |
|
5141910 |
AV_COPY16(mvd_dst + 3 + 1, mvd_src + 3 + 8 * 2); |
771 |
|
|
} |
772 |
|
|
} |
773 |
|
|
|
774 |
|
|
{ |
775 |
|
11980092 |
int8_t *ref_index = &h->cur_pic.ref_index[list][b8_xy]; |
776 |
|
11980092 |
int8_t *ref_cache = sl->ref_cache[list]; |
777 |
|
11980092 |
ref_index[0 + 0 * 2] = ref_cache[scan8[0]]; |
778 |
|
11980092 |
ref_index[1 + 0 * 2] = ref_cache[scan8[4]]; |
779 |
|
11980092 |
ref_index[0 + 1 * 2] = ref_cache[scan8[8]]; |
780 |
|
11980092 |
ref_index[1 + 1 * 2] = ref_cache[scan8[12]]; |
781 |
|
|
} |
782 |
|
11980092 |
} |
783 |
|
|
|
784 |
|
9081359 |
static av_always_inline void write_back_motion(const H264Context *h, |
785 |
|
|
H264SliceContext *sl, |
786 |
|
|
int mb_type) |
787 |
|
|
{ |
788 |
|
9081359 |
const int b_stride = h->b_stride; |
789 |
|
9081359 |
const int b_xy = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride; // try mb2b(8)_xy |
790 |
|
9081359 |
const int b8_xy = 4 * sl->mb_xy; |
791 |
|
|
|
792 |
✓✓ |
9081359 |
if (USES_LIST(mb_type, 0)) { |
793 |
|
8379457 |
write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 0); |
794 |
|
|
} else { |
795 |
|
701902 |
fill_rectangle(&h->cur_pic.ref_index[0][b8_xy], |
796 |
|
|
2, 2, 2, (uint8_t)LIST_NOT_USED, 1); |
797 |
|
|
} |
798 |
✓✓ |
9081359 |
if (USES_LIST(mb_type, 1)) |
799 |
|
3600635 |
write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 1); |
800 |
|
|
|
801 |
✓✓✗✗
|
6121394 |
if (sl->slice_type_nos == AV_PICTURE_TYPE_B && CABAC(h)) { |
802 |
✓✓ |
3523311 |
if (IS_8X8(mb_type)) { |
803 |
|
414730 |
uint8_t *direct_table = &h->direct_table[4 * sl->mb_xy]; |
804 |
|
414730 |
direct_table[1] = sl->sub_mb_type[1] >> 1; |
805 |
|
414730 |
direct_table[2] = sl->sub_mb_type[2] >> 1; |
806 |
|
414730 |
direct_table[3] = sl->sub_mb_type[3] >> 1; |
807 |
|
|
} |
808 |
|
|
} |
809 |
|
9081359 |
} |
810 |
|
|
|
811 |
|
261291 |
static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl) |
812 |
|
|
{ |
813 |
✓✓ |
261291 |
if (h->ps.sps->direct_8x8_inference_flag) |
814 |
|
256414 |
return !(AV_RN64A(sl->sub_mb_type) & |
815 |
|
|
((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8) * |
816 |
|
|
0x0001000100010001ULL)); |
817 |
|
|
else |
818 |
|
4877 |
return !(AV_RN64A(sl->sub_mb_type) & |
819 |
|
|
((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8 | MB_TYPE_DIRECT2) * |
820 |
|
|
0x0001000100010001ULL)); |
821 |
|
|
} |
822 |
|
|
|
823 |
|
35979 |
static inline int find_start_code(const uint8_t *buf, int buf_size, |
824 |
|
|
int buf_index, int next_avc) |
825 |
|
|
{ |
826 |
|
35979 |
uint32_t state = -1; |
827 |
|
|
|
828 |
|
35979 |
buf_index = avpriv_find_start_code(buf + buf_index, buf + next_avc + 1, &state) - buf - 1; |
829 |
|
|
|
830 |
|
35979 |
return FFMIN(buf_index, buf_size); |
831 |
|
|
} |
832 |
|
|
|
833 |
|
|
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup); |
834 |
|
|
|
835 |
|
|
int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src); |
836 |
|
|
void ff_h264_unref_picture(H264Context *h, H264Picture *pic); |
837 |
|
|
|
838 |
|
|
int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl); |
839 |
|
|
|
840 |
|
|
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height); |
841 |
|
|
|
842 |
|
|
/** |
843 |
|
|
* Submit a slice for decoding. |
844 |
|
|
* |
845 |
|
|
* Parse the slice header, starting a new field/frame if necessary. If any |
846 |
|
|
* slices are queued for the previous field, they are decoded. |
847 |
|
|
*/ |
848 |
|
|
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal); |
849 |
|
|
int ff_h264_execute_decode_slices(H264Context *h); |
850 |
|
|
int ff_h264_update_thread_context(AVCodecContext *dst, |
851 |
|
|
const AVCodecContext *src); |
852 |
|
|
|
853 |
|
|
void ff_h264_flush_change(H264Context *h); |
854 |
|
|
|
855 |
|
|
void ff_h264_free_tables(H264Context *h); |
856 |
|
|
|
857 |
|
|
void ff_h264_set_erpic(ERPicture *dst, H264Picture *src); |
858 |
|
|
|
859 |
|
|
#endif /* AVCODEC_H264DEC_H */ |