Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6147 | serge | 1 | /* |
2 | * Generic DCT based hybrid video encoder |
||
3 | * Copyright (c) 2000, 2001, 2002 Fabrice Bellard |
||
4 | * Copyright (c) 2002-2004 Michael Niedermayer |
||
5 | * |
||
6 | * This file is part of FFmpeg. |
||
7 | * |
||
8 | * FFmpeg is free software; you can redistribute it and/or |
||
9 | * modify it under the terms of the GNU Lesser General Public |
||
10 | * License as published by the Free Software Foundation; either |
||
11 | * version 2.1 of the License, or (at your option) any later version. |
||
12 | * |
||
13 | * FFmpeg is distributed in the hope that it will be useful, |
||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
16 | * Lesser General Public License for more details. |
||
17 | * |
||
18 | * You should have received a copy of the GNU Lesser General Public |
||
19 | * License along with FFmpeg; if not, write to the Free Software |
||
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
21 | */ |
||
22 | |||
23 | /** |
||
24 | * @file |
||
25 | * mpegvideo header. |
||
26 | */ |
||
27 | |||
28 | #ifndef AVCODEC_MPEGVIDEO_H |
||
29 | #define AVCODEC_MPEGVIDEO_H |
||
30 | |||
31 | #include |
||
32 | |||
33 | #include "avcodec.h" |
||
34 | #include "blockdsp.h" |
||
35 | #include "error_resilience.h" |
||
36 | #include "fdctdsp.h" |
||
37 | #include "get_bits.h" |
||
38 | #include "h264chroma.h" |
||
39 | #include "h263dsp.h" |
||
40 | #include "hpeldsp.h" |
||
41 | #include "idctdsp.h" |
||
42 | #include "internal.h" |
||
43 | #include "me_cmp.h" |
||
44 | #include "motion_est.h" |
||
45 | #include "mpegpicture.h" |
||
46 | #include "mpegvideodsp.h" |
||
47 | #include "mpegvideoencdsp.h" |
||
48 | #include "pixblockdsp.h" |
||
49 | #include "put_bits.h" |
||
50 | #include "ratecontrol.h" |
||
51 | #include "parser.h" |
||
52 | #include "mpegutils.h" |
||
53 | #include "mpeg12data.h" |
||
54 | #include "qpeldsp.h" |
||
55 | #include "thread.h" |
||
56 | #include "videodsp.h" |
||
57 | |||
58 | #include "libavutil/opt.h" |
||
59 | #include "libavutil/timecode.h" |
||
60 | |||
61 | #define FRAME_SKIPPED 100 ///< return value for header parsers if frame is not coded |
||
62 | |||
63 | #define MAX_FCODE 7 |
||
64 | |||
65 | #define MAX_THREADS 32 |
||
66 | |||
67 | #define MAX_B_FRAMES 16 |
||
68 | |||
69 | #define ME_MAP_SIZE 64 |
||
70 | |||
71 | #define MAX_MB_BYTES (30*16*16*3/8 + 120) |
||
72 | |||
73 | #define INPLACE_OFFSET 16 |
||
74 | |||
75 | /* Start codes. */ |
||
76 | #define SEQ_END_CODE 0x000001b7 |
||
77 | #define SEQ_START_CODE 0x000001b3 |
||
78 | #define GOP_START_CODE 0x000001b8 |
||
79 | #define PICTURE_START_CODE 0x00000100 |
||
80 | #define SLICE_MIN_START_CODE 0x00000101 |
||
81 | #define SLICE_MAX_START_CODE 0x000001af |
||
82 | #define EXT_START_CODE 0x000001b5 |
||
83 | #define USER_START_CODE 0x000001b2 |
||
84 | |||
85 | /** |
||
86 | * MpegEncContext. |
||
87 | */ |
||
88 | typedef struct MpegEncContext { |
||
89 | AVClass *class; |
||
90 | |||
91 | int y_dc_scale, c_dc_scale; |
||
92 | int ac_pred; |
||
93 | int block_last_index[12]; ///< last non zero coefficient in block |
||
94 | int h263_aic; ///< Advanded INTRA Coding (AIC) |
||
95 | |||
96 | /* scantables */ |
||
97 | ScanTable inter_scantable; ///< if inter == intra then intra should be used to reduce tha cache usage |
||
98 | ScanTable intra_scantable; |
||
99 | ScanTable intra_h_scantable; |
||
100 | ScanTable intra_v_scantable; |
||
101 | |||
102 | /* WARNING: changes above this line require updates to hardcoded |
||
103 | * offsets used in asm. */ |
||
104 | |||
105 | struct AVCodecContext *avctx; |
||
106 | /* the following parameters must be initialized before encoding */ |
||
107 | int width, height;///< picture size. must be a multiple of 16 |
||
108 | int gop_size; |
||
109 | int intra_only; ///< if true, only intra pictures are generated |
||
110 | int64_t bit_rate; ///< wanted bit rate |
||
111 | enum OutputFormat out_format; ///< output format |
||
112 | int h263_pred; ///< use mpeg4/h263 ac/dc predictions |
||
113 | int pb_frame; ///< PB frame mode (0 = none, 1 = base, 2 = improved) |
||
114 | |||
115 | /* the following codec id fields are deprecated in favor of codec_id */ |
||
116 | int h263_plus; ///< h263 plus headers |
||
117 | int h263_flv; ///< use flv h263 header |
||
118 | |||
119 | enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */ |
||
120 | int fixed_qscale; ///< fixed qscale if non zero |
||
121 | int encoding; ///< true if we are encoding (vs decoding) |
||
122 | int max_b_frames; ///< max number of b-frames for encoding |
||
123 | int luma_elim_threshold; |
||
124 | int chroma_elim_threshold; |
||
125 | int strict_std_compliance; ///< strictly follow the std (MPEG4, ...) |
||
126 | int workaround_bugs; ///< workaround bugs in encoders which cannot be detected automatically |
||
127 | int codec_tag; ///< internal codec_tag upper case converted from avctx codec_tag |
||
128 | /* the following fields are managed internally by the encoder */ |
||
129 | |||
130 | /* sequence parameters */ |
||
131 | int context_initialized; |
||
132 | int input_picture_number; ///< used to set pic->display_picture_number, should not be used for/by anything else |
||
133 | int coded_picture_number; ///< used to set pic->coded_picture_number, should not be used for/by anything else |
||
134 | int picture_number; //FIXME remove, unclear definition |
||
135 | int picture_in_gop_number; ///< 0-> first pic in gop, ... |
||
136 | int mb_width, mb_height; ///< number of MBs horizontally & vertically |
||
137 | int mb_stride; ///< mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 |
||
138 | int b8_stride; ///< 2*mb_width+1 used for some 8x8 block arrays to allow simple addressing |
||
139 | int h_edge_pos, v_edge_pos;///< horizontal / vertical position of the right/bottom edge (pixel replication) |
||
140 | int mb_num; ///< number of MBs of a picture |
||
141 | ptrdiff_t linesize; ///< line size, in bytes, may be different from width |
||
142 | ptrdiff_t uvlinesize; ///< line size, for chroma in bytes, may be different from width |
||
143 | Picture *picture; ///< main picture buffer |
||
144 | Picture **input_picture; ///< next pictures on display order for encoding |
||
145 | Picture **reordered_input_picture; ///< pointer to the next pictures in codedorder for encoding |
||
146 | |||
147 | int64_t user_specified_pts; ///< last non-zero pts from AVFrame which was passed into avcodec_encode_video2() |
||
148 | /** |
||
149 | * pts difference between the first and second input frame, used for |
||
150 | * calculating dts of the first frame when there's a delay */ |
||
151 | int64_t dts_delta; |
||
152 | /** |
||
153 | * reordered pts to be used as dts for the next output frame when there's |
||
154 | * a delay */ |
||
155 | int64_t reordered_pts; |
||
156 | |||
157 | /** bit output */ |
||
158 | PutBitContext pb; |
||
159 | |||
160 | int start_mb_y; ///< start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) |
||
161 | int end_mb_y; ///< end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) |
||
162 | struct MpegEncContext *thread_context[MAX_THREADS]; |
||
163 | int slice_context_count; ///< number of used thread_contexts |
||
164 | |||
165 | /** |
||
166 | * copy of the previous picture structure. |
||
167 | * note, linesize & data, might not match the previous picture (for field pictures) |
||
168 | */ |
||
169 | Picture last_picture; |
||
170 | |||
171 | /** |
||
172 | * copy of the next picture structure. |
||
173 | * note, linesize & data, might not match the next picture (for field pictures) |
||
174 | */ |
||
175 | Picture next_picture; |
||
176 | |||
177 | /** |
||
178 | * copy of the source picture structure for encoding. |
||
179 | * note, linesize & data, might not match the source picture (for field pictures) |
||
180 | */ |
||
181 | Picture new_picture; |
||
182 | |||
183 | /** |
||
184 | * copy of the current picture structure. |
||
185 | * note, linesize & data, might not match the current picture (for field pictures) |
||
186 | */ |
||
187 | Picture current_picture; ///< buffer to store the decompressed current picture |
||
188 | |||
189 | Picture *last_picture_ptr; ///< pointer to the previous picture. |
||
190 | Picture *next_picture_ptr; ///< pointer to the next picture (for bidir pred) |
||
191 | Picture *current_picture_ptr; ///< pointer to the current picture |
||
192 | int last_dc[3]; ///< last DC values for MPEG1 |
||
193 | int16_t *dc_val_base; |
||
194 | int16_t *dc_val[3]; ///< used for mpeg4 DC prediction, all 3 arrays must be continuous |
||
195 | const uint8_t *y_dc_scale_table; ///< qscale -> y_dc_scale table |
||
196 | const uint8_t *c_dc_scale_table; ///< qscale -> c_dc_scale table |
||
197 | const uint8_t *chroma_qscale_table; ///< qscale -> chroma_qscale (h263) |
||
198 | uint8_t *coded_block_base; |
||
199 | uint8_t *coded_block; ///< used for coded block pattern prediction (msmpeg4v3, wmv1) |
||
200 | int16_t (*ac_val_base)[16]; |
||
201 | int16_t (*ac_val[3])[16]; ///< used for mpeg4 AC prediction, all 3 arrays must be continuous |
||
202 | int mb_skipped; ///< MUST BE SET only during DECODING |
||
203 | uint8_t *mbskip_table; /**< used to avoid copy if macroblock skipped (for black regions for example) |
||
204 | and used for b-frame encoding & decoding (contains skip table of next P Frame) */ |
||
205 | uint8_t *mbintra_table; ///< used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding |
||
206 | uint8_t *cbp_table; ///< used to store cbp, ac_pred for partitioned decoding |
||
207 | uint8_t *pred_dir_table; ///< used to store pred_dir for partitioned decoding |
||
208 | |||
209 | ScratchpadContext sc; |
||
210 | |||
211 | int qscale; ///< QP |
||
212 | int chroma_qscale; ///< chroma QP |
||
213 | unsigned int lambda; ///< lagrange multipler used in rate distortion |
||
214 | unsigned int lambda2; ///< (lambda*lambda) >> FF_LAMBDA_SHIFT |
||
215 | int *lambda_table; |
||
216 | int adaptive_quant; ///< use adaptive quantization |
||
217 | int dquant; ///< qscale difference to prev qscale |
||
218 | int closed_gop; ///< MPEG1/2 GOP is closed |
||
219 | int pict_type; ///< AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ... |
||
220 | int vbv_delay; |
||
221 | int last_pict_type; //FIXME removes |
||
222 | int last_non_b_pict_type; ///< used for mpeg4 gmc b-frames & ratecontrol |
||
223 | int droppable; |
||
224 | int frame_rate_index; |
||
225 | AVRational mpeg2_frame_rate_ext; |
||
226 | int last_lambda_for[5]; ///< last lambda for a specific pict type |
||
227 | int skipdct; ///< skip dct and code zero residual |
||
228 | |||
229 | /* motion compensation */ |
||
230 | int unrestricted_mv; ///< mv can point outside of the coded picture |
||
231 | int h263_long_vectors; ///< use horrible h263v1 long vector mode |
||
232 | |||
233 | BlockDSPContext bdsp; |
||
234 | FDCTDSPContext fdsp; |
||
235 | H264ChromaContext h264chroma; |
||
236 | HpelDSPContext hdsp; |
||
237 | IDCTDSPContext idsp; |
||
238 | MECmpContext mecc; |
||
239 | MpegVideoDSPContext mdsp; |
||
240 | MpegvideoEncDSPContext mpvencdsp; |
||
241 | PixblockDSPContext pdsp; |
||
242 | QpelDSPContext qdsp; |
||
243 | VideoDSPContext vdsp; |
||
244 | H263DSPContext h263dsp; |
||
245 | int f_code; ///< forward MV resolution |
||
246 | int b_code; ///< backward MV resolution for B Frames (mpeg4) |
||
247 | int16_t (*p_mv_table_base)[2]; |
||
248 | int16_t (*b_forw_mv_table_base)[2]; |
||
249 | int16_t (*b_back_mv_table_base)[2]; |
||
250 | int16_t (*b_bidir_forw_mv_table_base)[2]; |
||
251 | int16_t (*b_bidir_back_mv_table_base)[2]; |
||
252 | int16_t (*b_direct_mv_table_base)[2]; |
||
253 | int16_t (*p_field_mv_table_base[2][2])[2]; |
||
254 | int16_t (*b_field_mv_table_base[2][2][2])[2]; |
||
255 | int16_t (*p_mv_table)[2]; ///< MV table (1MV per MB) p-frame encoding |
||
256 | int16_t (*b_forw_mv_table)[2]; ///< MV table (1MV per MB) forward mode b-frame encoding |
||
257 | int16_t (*b_back_mv_table)[2]; ///< MV table (1MV per MB) backward mode b-frame encoding |
||
258 | int16_t (*b_bidir_forw_mv_table)[2]; ///< MV table (1MV per MB) bidir mode b-frame encoding |
||
259 | int16_t (*b_bidir_back_mv_table)[2]; ///< MV table (1MV per MB) bidir mode b-frame encoding |
||
260 | int16_t (*b_direct_mv_table)[2]; ///< MV table (1MV per MB) direct mode b-frame encoding |
||
261 | int16_t (*p_field_mv_table[2][2])[2]; ///< MV table (2MV per MB) interlaced p-frame encoding |
||
262 | int16_t (*b_field_mv_table[2][2][2])[2];///< MV table (4MV per MB) interlaced b-frame encoding |
||
263 | uint8_t (*p_field_select_table[2]); |
||
264 | uint8_t (*b_field_select_table[2][2]); |
||
265 | #if FF_API_MOTION_EST |
||
266 | int me_method; ///< ME algorithm |
||
267 | #endif |
||
268 | int motion_est; ///< ME algorithm |
||
269 | int mv_dir; |
||
270 | #define MV_DIR_FORWARD 1 |
||
271 | #define MV_DIR_BACKWARD 2 |
||
272 | #define MV_DIRECT 4 ///< bidirectional mode where the difference equals the MV of the last P/S/I-Frame (mpeg4) |
||
273 | int mv_type; |
||
274 | #define MV_TYPE_16X16 0 ///< 1 vector for the whole mb |
||
275 | #define MV_TYPE_8X8 1 ///< 4 vectors (h263, mpeg4 4MV) |
||
276 | #define MV_TYPE_16X8 2 ///< 2 vectors, one per 16x8 block |
||
277 | #define MV_TYPE_FIELD 3 ///< 2 vectors, one per field |
||
278 | #define MV_TYPE_DMV 4 ///< 2 vectors, special mpeg2 Dual Prime Vectors |
||
279 | /**motion vectors for a macroblock |
||
280 | first coordinate : 0 = forward 1 = backward |
||
281 | second " : depend on type |
||
282 | third " : 0 = x, 1 = y |
||
283 | */ |
||
284 | int mv[2][4][2]; |
||
285 | int field_select[2][2]; |
||
286 | int last_mv[2][2][2]; ///< last MV, used for MV prediction in MPEG1 & B-frame MPEG4 |
||
287 | uint8_t *fcode_tab; ///< smallest fcode needed for each MV |
||
288 | int16_t direct_scale_mv[2][64]; ///< precomputed to avoid divisions in ff_mpeg4_set_direct_mv |
||
289 | |||
290 | MotionEstContext me; |
||
291 | |||
292 | int no_rounding; /**< apply no rounding to motion compensation (MPEG4, msmpeg4, ...) |
||
293 | for b-frames rounding mode is always 0 */ |
||
294 | |||
295 | /* macroblock layer */ |
||
296 | int mb_x, mb_y; |
||
297 | int mb_skip_run; |
||
298 | int mb_intra; |
||
299 | uint16_t *mb_type; ///< Table for candidate MB types for encoding (defines in mpegutils.h) |
||
300 | |||
301 | int block_index[6]; ///< index to current MB in block based arrays with edges |
||
302 | int block_wrap[6]; |
||
303 | uint8_t *dest[3]; |
||
304 | |||
305 | int *mb_index2xy; ///< mb_index -> mb_x + mb_y*mb_stride |
||
306 | |||
307 | /** matrix transmitted in the bitstream */ |
||
308 | uint16_t intra_matrix[64]; |
||
309 | uint16_t chroma_intra_matrix[64]; |
||
310 | uint16_t inter_matrix[64]; |
||
311 | uint16_t chroma_inter_matrix[64]; |
||
312 | |||
313 | int intra_quant_bias; ///< bias for the quantizer |
||
314 | int inter_quant_bias; ///< bias for the quantizer |
||
315 | int min_qcoeff; ///< minimum encodable coefficient |
||
316 | int max_qcoeff; ///< maximum encodable coefficient |
||
317 | int ac_esc_length; ///< num of bits needed to encode the longest esc |
||
318 | uint8_t *intra_ac_vlc_length; |
||
319 | uint8_t *intra_ac_vlc_last_length; |
||
320 | uint8_t *intra_chroma_ac_vlc_length; |
||
321 | uint8_t *intra_chroma_ac_vlc_last_length; |
||
322 | uint8_t *inter_ac_vlc_length; |
||
323 | uint8_t *inter_ac_vlc_last_length; |
||
324 | uint8_t *luma_dc_vlc_length; |
||
325 | #define UNI_AC_ENC_INDEX(run,level) ((run)*128 + (level)) |
||
326 | |||
327 | int coded_score[12]; |
||
328 | |||
329 | /** precomputed matrix (combine qscale and DCT renorm) */ |
||
330 | int (*q_intra_matrix)[64]; |
||
331 | int (*q_chroma_intra_matrix)[64]; |
||
332 | int (*q_inter_matrix)[64]; |
||
333 | /** identical to the above but for MMX & these are not permutated, second 64 entries are bias*/ |
||
334 | uint16_t (*q_intra_matrix16)[2][64]; |
||
335 | uint16_t (*q_chroma_intra_matrix16)[2][64]; |
||
336 | uint16_t (*q_inter_matrix16)[2][64]; |
||
337 | |||
338 | /* noise reduction */ |
||
339 | int (*dct_error_sum)[64]; |
||
340 | int dct_count[2]; |
||
341 | uint16_t (*dct_offset)[64]; |
||
342 | |||
343 | /* bit rate control */ |
||
344 | int64_t total_bits; |
||
345 | int frame_bits; ///< bits used for the current frame |
||
346 | int stuffing_bits; ///< bits used for stuffing |
||
347 | int next_lambda; ///< next lambda used for retrying to encode a frame |
||
348 | RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c |
||
349 | |||
350 | /* statistics, used for 2-pass encoding */ |
||
351 | int mv_bits; |
||
352 | int header_bits; |
||
353 | int i_tex_bits; |
||
354 | int p_tex_bits; |
||
355 | int i_count; |
||
356 | int f_count; |
||
357 | int b_count; |
||
358 | int skip_count; |
||
359 | int misc_bits; ///< cbp, mb_type |
||
360 | int last_bits; ///< temp var used for calculating the above vars |
||
361 | |||
362 | /* error concealment / resync */ |
||
363 | int resync_mb_x; ///< x position of last resync marker |
||
364 | int resync_mb_y; ///< y position of last resync marker |
||
365 | GetBitContext last_resync_gb; ///< used to search for the next resync marker |
||
366 | int mb_num_left; ///< number of MBs left in this video packet (for partitioned Slices only) |
||
367 | int next_p_frame_damaged; ///< set if the next p frame is damaged, to avoid showing trashed b frames |
||
368 | |||
369 | ParseContext parse_context; |
||
370 | |||
371 | /* H.263 specific */ |
||
372 | int gob_index; |
||
373 | int obmc; ///< overlapped block motion compensation |
||
374 | int mb_info; ///< interval for outputting info about mb offsets as side data |
||
375 | int prev_mb_info, last_mb_info; |
||
376 | uint8_t *mb_info_ptr; |
||
377 | int mb_info_size; |
||
378 | int ehc_mode; |
||
379 | int rc_strategy; |
||
380 | |||
381 | /* H.263+ specific */ |
||
382 | int umvplus; ///< == H263+ && unrestricted_mv |
||
383 | int h263_aic_dir; ///< AIC direction: 0 = left, 1 = top |
||
384 | int h263_slice_structured; |
||
385 | int alt_inter_vlc; ///< alternative inter vlc |
||
386 | int modified_quant; |
||
387 | int loop_filter; |
||
388 | int custom_pcf; |
||
389 | |||
390 | /* mpeg4 specific */ |
||
391 | ///< number of bits to represent the fractional part of time (encoder only) |
||
392 | int time_increment_bits; |
||
393 | int last_time_base; |
||
394 | int time_base; ///< time in seconds of last I,P,S Frame |
||
395 | int64_t time; ///< time of current frame |
||
396 | int64_t last_non_b_time; |
||
397 | uint16_t pp_time; ///< time distance between the last 2 p,s,i frames |
||
398 | uint16_t pb_time; ///< time distance between the last b and p,s,i frame |
||
399 | uint16_t pp_field_time; |
||
400 | uint16_t pb_field_time; ///< like above, just for interlaced |
||
401 | int real_sprite_warping_points; |
||
402 | int sprite_offset[2][2]; ///< sprite offset[isChroma][isMVY] |
||
403 | int sprite_delta[2][2]; ///< sprite_delta [isY][isMVY] |
||
404 | int mcsel; |
||
405 | int quant_precision; |
||
406 | int quarter_sample; ///< 1->qpel, 0->half pel ME/MC |
||
407 | int aspect_ratio_info; //FIXME remove |
||
408 | int sprite_warping_accuracy; |
||
409 | int data_partitioning; ///< data partitioning flag from header |
||
410 | int partitioned_frame; ///< is current frame partitioned |
||
411 | int low_delay; ///< no reordering needed / has no b-frames |
||
412 | int vo_type; |
||
413 | PutBitContext tex_pb; ///< used for data partitioned VOPs |
||
414 | PutBitContext pb2; ///< used for data partitioned VOPs |
||
415 | int mpeg_quant; |
||
416 | int padding_bug_score; ///< used to detect the VERY common padding bug in MPEG4 |
||
417 | |||
418 | /* divx specific, used to workaround (many) bugs in divx5 */ |
||
419 | int divx_packed; |
||
420 | uint8_t *bitstream_buffer; //Divx 5.01 puts several frames in a single one, this is used to reorder them |
||
421 | int bitstream_buffer_size; |
||
422 | unsigned int allocated_bitstream_buffer_size; |
||
423 | |||
424 | /* RV10 specific */ |
||
425 | int rv10_version; ///< RV10 version: 0 or 3 |
||
426 | int rv10_first_dc_coded[3]; |
||
427 | |||
428 | /* MJPEG specific */ |
||
429 | struct MJpegContext *mjpeg_ctx; |
||
430 | int esc_pos; |
||
431 | |||
432 | /* MSMPEG4 specific */ |
||
433 | int mv_table_index; |
||
434 | int rl_table_index; |
||
435 | int rl_chroma_table_index; |
||
436 | int dc_table_index; |
||
437 | int use_skip_mb_code; |
||
438 | int slice_height; ///< in macroblocks |
||
439 | int first_slice_line; ///< used in mpeg4 too to handle resync markers |
||
440 | int flipflop_rounding; |
||
441 | int msmpeg4_version; ///< 0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8 |
||
442 | int per_mb_rl_table; |
||
443 | int esc3_level_length; |
||
444 | int esc3_run_length; |
||
445 | /** [mb_intra][isChroma][level][run][last] */ |
||
446 | int (*ac_stats)[2][MAX_LEVEL+1][MAX_RUN+1][2]; |
||
447 | int inter_intra_pred; |
||
448 | int mspel; |
||
449 | |||
450 | /* decompression specific */ |
||
451 | GetBitContext gb; |
||
452 | |||
453 | /* Mpeg1 specific */ |
||
454 | int gop_picture_number; ///< index of the first picture of a GOP based on fake_pic_num & mpeg1 specific |
||
455 | int last_mv_dir; ///< last mv_dir, used for b frame encoding |
||
456 | uint8_t *vbv_delay_ptr; ///< pointer to vbv_delay in the bitstream |
||
457 | |||
458 | /* MPEG-2-specific - I wished not to have to support this mess. */ |
||
459 | int progressive_sequence; |
||
460 | int mpeg_f_code[2][2]; |
||
461 | |||
462 | // picture structure defines are loaded from mpegutils.h |
||
463 | int picture_structure; |
||
464 | |||
465 | int intra_dc_precision; |
||
466 | int frame_pred_frame_dct; |
||
467 | int top_field_first; |
||
468 | int concealment_motion_vectors; |
||
469 | int q_scale_type; |
||
470 | int intra_vlc_format; |
||
471 | int alternate_scan; |
||
472 | int seq_disp_ext; |
||
473 | int repeat_first_field; |
||
474 | int chroma_420_type; |
||
475 | int chroma_format; |
||
476 | #define CHROMA_420 1 |
||
477 | #define CHROMA_422 2 |
||
478 | #define CHROMA_444 3 |
||
479 | int chroma_x_shift;//depend on pix_format, that depend on chroma_format |
||
480 | int chroma_y_shift; |
||
481 | |||
482 | int progressive_frame; |
||
483 | int full_pel[2]; |
||
484 | int interlaced_dct; |
||
485 | int first_field; ///< is 1 for the first field of a field picture 0 otherwise |
||
486 | int drop_frame_timecode; ///< timecode is in drop frame format. |
||
487 | int scan_offset; ///< reserve space for SVCD scan offset user data. |
||
488 | |||
489 | /* RTP specific */ |
||
490 | int rtp_mode; |
||
491 | |||
492 | char *tc_opt_str; ///< timecode option string |
||
493 | AVTimecode tc; ///< timecode context |
||
494 | |||
495 | uint8_t *ptr_lastgob; |
||
496 | int swap_uv; //vcr2 codec is an MPEG-2 variant with U and V swapped |
||
497 | int pack_pblocks; //xvmc needs to keep blocks without gaps. |
||
498 | int16_t (*pblocks[12])[64]; |
||
499 | |||
500 | int16_t (*block)[64]; ///< points to one of the following blocks |
||
501 | int16_t (*blocks)[12][64]; // for HQ mode we need to keep the best block |
||
502 | int (*decode_mb)(struct MpegEncContext *s, int16_t block[6][64]); // used by some codecs to avoid a switch() |
||
503 | #define SLICE_OK 0 |
||
504 | #define SLICE_ERROR -1 |
||
505 | #define SLICE_END -2 /// |
||
506 | #define SLICE_NOEND -3 /// |
||
507 | |||
508 | void (*dct_unquantize_mpeg1_intra)(struct MpegEncContext *s, |
||
509 | int16_t *block/*align 16*/, int n, int qscale); |
||
510 | void (*dct_unquantize_mpeg1_inter)(struct MpegEncContext *s, |
||
511 | int16_t *block/*align 16*/, int n, int qscale); |
||
512 | void (*dct_unquantize_mpeg2_intra)(struct MpegEncContext *s, |
||
513 | int16_t *block/*align 16*/, int n, int qscale); |
||
514 | void (*dct_unquantize_mpeg2_inter)(struct MpegEncContext *s, |
||
515 | int16_t *block/*align 16*/, int n, int qscale); |
||
516 | void (*dct_unquantize_h263_intra)(struct MpegEncContext *s, |
||
517 | int16_t *block/*align 16*/, int n, int qscale); |
||
518 | void (*dct_unquantize_h263_inter)(struct MpegEncContext *s, |
||
519 | int16_t *block/*align 16*/, int n, int qscale); |
||
520 | void (*dct_unquantize_intra)(struct MpegEncContext *s, // unquantizer to use (mpeg4 can use both) |
||
521 | int16_t *block/*align 16*/, int n, int qscale); |
||
522 | void (*dct_unquantize_inter)(struct MpegEncContext *s, // unquantizer to use (mpeg4 can use both) |
||
523 | int16_t *block/*align 16*/, int n, int qscale); |
||
524 | int (*dct_quantize)(struct MpegEncContext *s, int16_t *block/*align 16*/, int n, int qscale, int *overflow); |
||
525 | int (*fast_dct_quantize)(struct MpegEncContext *s, int16_t *block/*align 16*/, int n, int qscale, int *overflow); |
||
526 | void (*denoise_dct)(struct MpegEncContext *s, int16_t *block); |
||
527 | |||
528 | int mpv_flags; ///< flags set by private options |
||
529 | int quantizer_noise_shaping; |
||
530 | |||
531 | /** |
||
532 | * ratecontrol qmin qmax limiting method |
||
533 | * 0-> clipping, 1-> use a nice continuous function to limit qscale within qmin/qmax. |
||
534 | */ |
||
535 | float rc_qsquish; |
||
536 | float rc_qmod_amp; |
||
537 | int rc_qmod_freq; |
||
538 | float rc_initial_cplx; |
||
539 | float rc_buffer_aggressivity; |
||
540 | float border_masking; |
||
541 | int lmin, lmax; |
||
542 | int vbv_ignore_qmax; |
||
543 | |||
544 | char *rc_eq; |
||
545 | |||
546 | /* temp buffers for rate control */ |
||
547 | float *cplx_tab, *bits_tab; |
||
548 | |||
549 | /* flag to indicate a reinitialization is required, e.g. after |
||
550 | * a frame size change */ |
||
551 | int context_reinit; |
||
552 | |||
553 | ERContext er; |
||
554 | |||
555 | int error_rate; |
||
556 | |||
557 | /* temporary frames used by b_frame_strategy = 2 */ |
||
558 | AVFrame *tmp_frames[MAX_B_FRAMES + 2]; |
||
559 | } MpegEncContext; |
||
560 | |||
561 | /* mpegvideo_enc common options */ |
||
562 | #define FF_MPV_FLAG_SKIP_RD 0x0001 |
||
563 | #define FF_MPV_FLAG_STRICT_GOP 0x0002 |
||
564 | #define FF_MPV_FLAG_QP_RD 0x0004 |
||
565 | #define FF_MPV_FLAG_CBP_RD 0x0008 |
||
566 | #define FF_MPV_FLAG_NAQ 0x0010 |
||
567 | #define FF_MPV_FLAG_MV0 0x0020 |
||
568 | |||
569 | #ifndef FF_MPV_OFFSET |
||
570 | #define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x) |
||
571 | #endif |
||
572 | #define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM) |
||
573 | #define FF_MPV_COMMON_OPTS \ |
||
574 | { "mpv_flags", "Flags common for all mpegvideo-based encoders.", FF_MPV_OFFSET(mpv_flags), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "mpv_flags" },\ |
||
575 | { "skip_rd", "RD optimal MB level residual skipping", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_SKIP_RD }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ |
||
576 | { "strict_gop", "Strictly enforce gop size", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_STRICT_GOP }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ |
||
577 | { "qp_rd", "Use rate distortion optimization for qp selection", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_QP_RD }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ |
||
578 | { "cbp_rd", "use rate distortion optimization for CBP", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_CBP_RD }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ |
||
579 | { "naq", "normalize adaptive quantization", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_NAQ }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ |
||
580 | { "mv0", "always try a mb with mv=<0,0>", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_MV0 }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ |
||
581 | { "luma_elim_threshold", "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)",\ |
||
582 | FF_MPV_OFFSET(luma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\ |
||
583 | { "chroma_elim_threshold", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)",\ |
||
584 | FF_MPV_OFFSET(chroma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\ |
||
585 | { "quantizer_noise_shaping", NULL, FF_MPV_OFFSET(quantizer_noise_shaping), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FF_MPV_OPT_FLAGS },\ |
||
586 | { "error_rate", "Simulate errors in the bitstream to test error concealment.", \ |
||
587 | FF_MPV_OFFSET(error_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FF_MPV_OPT_FLAGS },\ |
||
588 | {"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)", \ |
||
589 | FF_MPV_OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0, 99, FF_MPV_OPT_FLAGS}, \ |
||
590 | {"rc_qmod_amp", "experimental quantizer modulation", FF_MPV_OFFSET(rc_qmod_amp), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \ |
||
591 | {"rc_qmod_freq", "experimental quantizer modulation", FF_MPV_OFFSET(rc_qmod_freq), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS}, \ |
||
592 | {"rc_eq", "Set rate control equation. When computing the expression, besides the standard functions " \ |
||
593 | "defined in the section 'Expression Evaluation', the following functions are available: " \ |
||
594 | "bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv " \ |
||
595 | "fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.", \ |
||
596 | FF_MPV_OFFSET(rc_eq), AV_OPT_TYPE_STRING, .flags = FF_MPV_OPT_FLAGS }, \ |
||
597 | {"rc_init_cplx", "initial complexity for 1-pass encoding", FF_MPV_OFFSET(rc_initial_cplx), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \ |
||
598 | {"rc_buf_aggressivity", "currently useless", FF_MPV_OFFSET(rc_buffer_aggressivity), AV_OPT_TYPE_FLOAT, {.dbl = 1.0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \ |
||
599 | {"border_mask", "increase the quantizer for macroblocks close to borders", FF_MPV_OFFSET(border_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \ |
||
600 | {"lmin", "minimum Lagrange factor (VBR)", FF_MPV_OFFSET(lmin), AV_OPT_TYPE_INT, {.i64 = 2*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS }, \ |
||
601 | {"lmax", "maximum Lagrange factor (VBR)", FF_MPV_OFFSET(lmax), AV_OPT_TYPE_INT, {.i64 = 31*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS }, \ |
||
602 | {"ibias", "intra quant bias", FF_MPV_OFFSET(intra_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \ |
||
603 | {"pbias", "inter quant bias", FF_MPV_OFFSET(inter_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \ |
||
604 | {"rc_strategy", "ratecontrol method", FF_MPV_OFFSET(rc_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, FF_MPV_OPT_FLAGS }, \ |
||
605 | {"motion_est", "motion estimation algorithm", FF_MPV_OFFSET(motion_est), AV_OPT_TYPE_INT, {.i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_XONE, FF_MPV_OPT_FLAGS, "motion_est" }, \ |
||
606 | { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \ |
||
607 | { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \ |
||
608 | { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \ |
||
609 | |||
610 | extern const AVOption ff_mpv_generic_options[]; |
||
611 | |||
612 | /** |
||
613 | * Set the given MpegEncContext to common defaults (same for encoding |
||
614 | * and decoding). The changed fields will not depend upon the prior |
||
615 | * state of the MpegEncContext. |
||
616 | */ |
||
617 | void ff_mpv_common_defaults(MpegEncContext *s); |
||
618 | |||
619 | void ff_dct_encode_init_x86(MpegEncContext *s); |
||
620 | |||
621 | int ff_mpv_common_init(MpegEncContext *s); |
||
622 | void ff_mpv_common_init_arm(MpegEncContext *s); |
||
623 | void ff_mpv_common_init_axp(MpegEncContext *s); |
||
624 | void ff_mpv_common_init_neon(MpegEncContext *s); |
||
625 | void ff_mpv_common_init_ppc(MpegEncContext *s); |
||
626 | void ff_mpv_common_init_x86(MpegEncContext *s); |
||
627 | void ff_mpv_common_init_mips(MpegEncContext *s); |
||
628 | |||
629 | int ff_mpv_common_frame_size_change(MpegEncContext *s); |
||
630 | void ff_mpv_common_end(MpegEncContext *s); |
||
631 | |||
632 | void ff_mpv_decode_defaults(MpegEncContext *s); |
||
633 | void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx); |
||
634 | void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64]); |
||
635 | void ff_mpv_report_decode_progress(MpegEncContext *s); |
||
636 | |||
637 | int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx); |
||
638 | void ff_mpv_frame_end(MpegEncContext *s); |
||
639 | |||
640 | int ff_mpv_encode_init(AVCodecContext *avctx); |
||
641 | void ff_mpv_encode_init_x86(MpegEncContext *s); |
||
642 | |||
643 | int ff_mpv_encode_end(AVCodecContext *avctx); |
||
644 | int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, |
||
645 | const AVFrame *frame, int *got_packet); |
||
646 | int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase); |
||
647 | |||
648 | void ff_clean_intra_table_entries(MpegEncContext *s); |
||
649 | void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h); |
||
650 | void ff_mpeg_flush(AVCodecContext *avctx); |
||
651 | |||
652 | void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict); |
||
653 | void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table, |
||
654 | uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2], |
||
655 | int *low_delay, |
||
656 | int mb_width, int mb_height, int mb_stride, int quarter_sample); |
||
657 | |||
658 | int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type); |
||
659 | |||
660 | void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix); |
||
661 | |||
662 | int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src); |
||
663 | int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src); |
||
664 | void ff_set_qscale(MpegEncContext * s, int qscale); |
||
665 | |||
666 | void ff_mpv_idct_init(MpegEncContext *s); |
||
667 | int ff_dct_encode_init(MpegEncContext *s); |
||
668 | void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[2][64], |
||
669 | const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra); |
||
670 | int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow); |
||
671 | |||
672 | void ff_init_block_index(MpegEncContext *s); |
||
673 | |||
674 | void ff_mpv_motion(MpegEncContext *s, |
||
675 | uint8_t *dest_y, uint8_t *dest_cb, |
||
676 | uint8_t *dest_cr, int dir, |
||
677 | uint8_t **ref_picture, |
||
678 | op_pixels_func (*pix_op)[4], |
||
679 | qpel_mc_func (*qpix_op)[16]); |
||
680 | |||
681 | static inline void ff_update_block_index(MpegEncContext *s){ |
||
682 | const int block_size= 8 >> s->avctx->lowres; |
||
683 | |||
684 | s->block_index[0]+=2; |
||
685 | s->block_index[1]+=2; |
||
686 | s->block_index[2]+=2; |
||
687 | s->block_index[3]+=2; |
||
688 | s->block_index[4]++; |
||
689 | s->block_index[5]++; |
||
690 | s->dest[0]+= 2*block_size; |
||
691 | s->dest[1]+= block_size; |
||
692 | s->dest[2]+= block_size; |
||
693 | } |
||
694 | |||
695 | static inline int get_bits_diff(MpegEncContext *s){ |
||
696 | const int bits= put_bits_count(&s->pb); |
||
697 | const int last= s->last_bits; |
||
698 | |||
699 | s->last_bits = bits; |
||
700 | |||
701 | return bits - last; |
||
702 | } |
||
703 | |||
704 | #endif /* AVCODEC_MPEGVIDEO_H */0,0>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>=>>>=>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> |