FFmpeg
2.6.9
Main Page
Related Pages
Modules
Namespaces
Data Structures
Files
Examples
File List
Globals
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
libavcodec
mpegvideo.h
Go to the documentation of this file.
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 <
float.h
>
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 "
me_cmp.h
"
43
#include "
mpegvideodsp.h
"
44
#include "
mpegvideoencdsp.h
"
45
#include "
pixblockdsp.h
"
46
#include "
put_bits.h
"
47
#include "
ratecontrol.h
"
48
#include "
parser.h
"
49
#include "
mpeg12data.h
"
50
#include "
qpeldsp.h
"
51
#include "
rl.h
"
52
#include "
thread.h
"
53
#include "
videodsp.h
"
54
55
#include "
libavutil/opt.h
"
56
#include "
libavutil/timecode.h
"
57
58
#define FRAME_SKIPPED 100
///< return value for header parsers if frame is not coded
59
60
enum
OutputFormat
{
61
FMT_MPEG1
,
62
FMT_H261
,
63
FMT_H263
,
64
FMT_MJPEG
,
65
};
66
67
#define MAX_FCODE 7
68
#define MAX_MV 4096
69
#define MAX_DMV (2*MAX_MV)
70
71
#define MAX_THREADS 32
72
#define MAX_PICTURE_COUNT 36
73
74
#define MAX_B_FRAMES 16
75
76
#define ME_MAP_SIZE 64
77
78
#define MAX_MB_BYTES (30*16*16*3/8 + 120)
79
80
#define INPLACE_OFFSET 16
81
82
#define EDGE_WIDTH 16
83
84
/* Start codes. */
85
#define SEQ_END_CODE 0x000001b7
86
#define SEQ_START_CODE 0x000001b3
87
#define GOP_START_CODE 0x000001b8
88
#define PICTURE_START_CODE 0x00000100
89
#define SLICE_MIN_START_CODE 0x00000101
90
#define SLICE_MAX_START_CODE 0x000001af
91
#define EXT_START_CODE 0x000001b5
92
#define USER_START_CODE 0x000001b2
93
94
/* encoding scans */
95
extern
const
uint8_t
ff_alternate_horizontal_scan
[64];
96
extern
const
uint8_t
ff_alternate_vertical_scan
[64];
97
98
struct
MpegEncContext
;
99
100
/**
101
* Picture.
102
*/
103
typedef
struct
Picture
{
104
struct
AVFrame
*
f
;
105
ThreadFrame
tf
;
106
107
AVBufferRef
*
qscale_table_buf
;
108
int8_t *
qscale_table
;
109
110
AVBufferRef
*
motion_val_buf
[2];
111
int16_t (*
motion_val
[2])[2];
112
113
AVBufferRef
*
mb_type_buf
;
114
uint32_t *
mb_type
;
///< types and macros are defined in mpegutils.h
115
116
AVBufferRef
*
mbskip_table_buf
;
117
uint8_t
*
mbskip_table
;
118
119
AVBufferRef
*
ref_index_buf
[2];
120
int8_t *
ref_index
[2];
121
122
AVBufferRef
*
mb_var_buf
;
123
uint16_t *
mb_var
;
///< Table for MB variances
124
125
AVBufferRef
*
mc_mb_var_buf
;
126
uint16_t *
mc_mb_var
;
///< Table for motion compensated MB variances
127
128
int
alloc_mb_width
;
///< mb_width used to allocate tables
129
int
alloc_mb_height
;
///< mb_height used to allocate tables
130
131
AVBufferRef
*
mb_mean_buf
;
132
uint8_t
*
mb_mean
;
///< Table for MB luminance
133
134
AVBufferRef
*
hwaccel_priv_buf
;
135
/**
136
* hardware accelerator private data
137
*/
138
void
*
hwaccel_picture_private
;
139
140
int
field_picture
;
///< whether or not the picture was encoded in separate fields
141
142
int64_t
mb_var_sum
;
///< sum of MB variance for current frame
143
int64_t
mc_mb_var_sum
;
///< motion compensated MB variance for current frame
144
145
int
b_frame_score
;
146
int
needs_realloc
;
///< Picture needs to be reallocated (eg due to a frame size change)
147
148
int
reference
;
149
int
shared
;
150
151
uint64_t
error
[
AV_NUM_DATA_POINTERS
];
152
}
Picture
;
153
154
/**
155
* Motion estimation context.
156
*/
157
typedef
struct
MotionEstContext
{
158
AVCodecContext
*
avctx
;
159
int
skip
;
///< set if ME is skipped for the current MB
160
int
co_located_mv
[4][2];
///< mv from last P-frame for direct mode ME
161
int
direct_basis_mv
[4][2];
162
uint8_t
*
scratchpad
;
///< data area for the ME algo, so that the ME does not need to malloc/free
163
uint8_t
*
best_mb
;
164
uint8_t
*
temp_mb
[2];
165
uint8_t
*
temp
;
166
int
best_bits
;
167
uint32_t *
map
;
///< map to avoid duplicate evaluations
168
uint32_t *
score_map
;
///< map to store the scores
169
unsigned
map_generation
;
170
int
pre_penalty_factor
;
171
int
penalty_factor
;
/**< an estimate of the bits required to
172
code a given mv value, e.g. (1,0) takes
173
more bits than (0,0). We have to
174
estimate whether any reduction in
175
residual is worth the extra bits. */
176
int
sub_penalty_factor
;
177
int
mb_penalty_factor
;
178
int
flags
;
179
int
sub_flags
;
180
int
mb_flags
;
181
int
pre_pass
;
///< = 1 for the pre pass
182
int
dia_size
;
183
int
xmin
;
184
int
xmax
;
185
int
ymin
;
186
int
ymax
;
187
int
pred_x
;
188
int
pred_y
;
189
uint8_t
*
src
[4][4];
190
uint8_t
*
ref
[4][4];
191
int
stride
;
192
int
uvstride
;
193
/* temp variables for picture complexity calculation */
194
int64_t
mc_mb_var_sum_temp
;
195
int64_t
mb_var_sum_temp
;
196
int
scene_change_score
;
197
/* cmp, chroma_cmp;*/
198
op_pixels_func
(*
hpel_put
)[4];
199
op_pixels_func
(*
hpel_avg
)[4];
200
qpel_mc_func
(*
qpel_put
)[16];
201
qpel_mc_func
(*
qpel_avg
)[16];
202
uint8_t
(*
mv_penalty
)[
MAX_DMV
*2+1];
///< amount of bits needed to encode a MV
203
uint8_t
*
current_mv_penalty
;
204
int (*
sub_motion_search
)(
struct
MpegEncContext
*
s
,
205
int
*mx_ptr,
int
*my_ptr,
int
dmin,
206
int
src_index,
int
ref_index,
207
int
size
,
int
h);
208
}
MotionEstContext
;
209
210
/**
211
* MpegEncContext.
212
*/
213
typedef
struct
MpegEncContext
{
214
AVClass
*
class
;
215
216
int
y_dc_scale
,
c_dc_scale
;
217
int
ac_pred
;
218
int
block_last_index
[12];
///< last non zero coefficient in block
219
int
h263_aic
;
///< Advanded INTRA Coding (AIC)
220
221
/* scantables */
222
ScanTable
inter_scantable
;
///< if inter == intra then intra should be used to reduce tha cache usage
223
ScanTable
intra_scantable
;
224
ScanTable
intra_h_scantable
;
225
ScanTable
intra_v_scantable
;
226
227
/* WARNING: changes above this line require updates to hardcoded
228
* offsets used in asm. */
229
230
struct
AVCodecContext
*
avctx
;
231
/* the following parameters must be initialized before encoding */
232
int
width
,
height
;
///< picture size. must be a multiple of 16
233
int
gop_size
;
234
int
intra_only
;
///< if true, only intra pictures are generated
235
int
bit_rate
;
///< wanted bit rate
236
enum
OutputFormat
out_format
;
///< output format
237
int
h263_pred
;
///< use mpeg4/h263 ac/dc predictions
238
int
pb_frame
;
///< PB frame mode (0 = none, 1 = base, 2 = improved)
239
240
/* the following codec id fields are deprecated in favor of codec_id */
241
int
h263_plus
;
///< h263 plus headers
242
int
h263_flv
;
///< use flv h263 header
243
244
enum
AVCodecID
codec_id
;
/* see AV_CODEC_ID_xxx */
245
int
fixed_qscale
;
///< fixed qscale if non zero
246
int
encoding
;
///< true if we are encoding (vs decoding)
247
int
flags
;
///< AVCodecContext.flags (HQ, MV4, ...)
248
int
flags2
;
///< AVCodecContext.flags2
249
int
max_b_frames
;
///< max number of b-frames for encoding
250
int
luma_elim_threshold
;
251
int
chroma_elim_threshold
;
252
int
strict_std_compliance
;
///< strictly follow the std (MPEG4, ...)
253
int
workaround_bugs
;
///< workaround bugs in encoders which cannot be detected automatically
254
int
codec_tag
;
///< internal codec_tag upper case converted from avctx codec_tag
255
int
stream_codec_tag
;
///< internal stream_codec_tag upper case converted from avctx stream_codec_tag
256
/* the following fields are managed internally by the encoder */
257
258
/* sequence parameters */
259
int
context_initialized
;
260
int
input_picture_number
;
///< used to set pic->display_picture_number, should not be used for/by anything else
261
int
coded_picture_number
;
///< used to set pic->coded_picture_number, should not be used for/by anything else
262
int
picture_number
;
//FIXME remove, unclear definition
263
int
picture_in_gop_number
;
///< 0-> first pic in gop, ...
264
int
mb_width
,
mb_height
;
///< number of MBs horizontally & vertically
265
int
mb_stride
;
///< mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11
266
int
b8_stride
;
///< 2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
267
int
h_edge_pos
,
v_edge_pos
;
///< horizontal / vertical position of the right/bottom edge (pixel replication)
268
int
mb_num
;
///< number of MBs of a picture
269
ptrdiff_t
linesize
;
///< line size, in bytes, may be different from width
270
ptrdiff_t
uvlinesize
;
///< line size, for chroma in bytes, may be different from width
271
Picture
*
picture
;
///< main picture buffer
272
Picture
**
input_picture
;
///< next pictures on display order for encoding
273
Picture
**
reordered_input_picture
;
///< pointer to the next pictures in codedorder for encoding
274
275
int64_t
user_specified_pts
;
///< last non-zero pts from AVFrame which was passed into avcodec_encode_video2()
276
/**
277
* pts difference between the first and second input frame, used for
278
* calculating dts of the first frame when there's a delay */
279
int64_t
dts_delta
;
280
/**
281
* reordered pts to be used as dts for the next output frame when there's
282
* a delay */
283
int64_t
reordered_pts
;
284
285
/** bit output */
286
PutBitContext
pb
;
287
288
int
start_mb_y
;
///< start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
289
int
end_mb_y
;
///< end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
290
struct
MpegEncContext
*
thread_context
[
MAX_THREADS
];
291
int
slice_context_count
;
///< number of used thread_contexts
292
293
/**
294
* copy of the previous picture structure.
295
* note, linesize & data, might not match the previous picture (for field pictures)
296
*/
297
Picture
last_picture
;
298
299
/**
300
* copy of the next picture structure.
301
* note, linesize & data, might not match the next picture (for field pictures)
302
*/
303
Picture
next_picture
;
304
305
/**
306
* copy of the source picture structure for encoding.
307
* note, linesize & data, might not match the source picture (for field pictures)
308
*/
309
Picture
new_picture
;
310
311
/**
312
* copy of the current picture structure.
313
* note, linesize & data, might not match the current picture (for field pictures)
314
*/
315
Picture
current_picture
;
///< buffer to store the decompressed current picture
316
317
Picture
*
last_picture_ptr
;
///< pointer to the previous picture.
318
Picture
*
next_picture_ptr
;
///< pointer to the next picture (for bidir pred)
319
Picture
*
current_picture_ptr
;
///< pointer to the current picture
320
int
last_dc
[3];
///< last DC values for MPEG1
321
int16_t *
dc_val_base
;
322
int16_t *
dc_val
[3];
///< used for mpeg4 DC prediction, all 3 arrays must be continuous
323
const
uint8_t
*
y_dc_scale_table
;
///< qscale -> y_dc_scale table
324
const
uint8_t
*
c_dc_scale_table
;
///< qscale -> c_dc_scale table
325
const
uint8_t
*
chroma_qscale_table
;
///< qscale -> chroma_qscale (h263)
326
uint8_t
*
coded_block_base
;
327
uint8_t
*
coded_block
;
///< used for coded block pattern prediction (msmpeg4v3, wmv1)
328
int16_t (*
ac_val_base
)[16];
329
int16_t (*
ac_val
[3])[16];
///< used for mpeg4 AC prediction, all 3 arrays must be continuous
330
int
mb_skipped
;
///< MUST BE SET only during DECODING
331
uint8_t
*
mbskip_table
;
/**< used to avoid copy if macroblock skipped (for black regions for example)
332
and used for b-frame encoding & decoding (contains skip table of next P Frame) */
333
uint8_t
*
mbintra_table
;
///< used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding
334
uint8_t
*
cbp_table
;
///< used to store cbp, ac_pred for partitioned decoding
335
uint8_t
*
pred_dir_table
;
///< used to store pred_dir for partitioned decoding
336
uint8_t
*
edge_emu_buffer
;
///< temporary buffer for if MVs point to out-of-frame data
337
uint8_t
*
rd_scratchpad
;
///< scratchpad for rate distortion mb decision
338
uint8_t
*
obmc_scratchpad
;
339
uint8_t
*
b_scratchpad
;
///< scratchpad used for writing into write only buffers
340
341
int
qscale
;
///< QP
342
int
chroma_qscale
;
///< chroma QP
343
unsigned
int
lambda
;
///< lagrange multipler used in rate distortion
344
unsigned
int
lambda2
;
///< (lambda*lambda) >> FF_LAMBDA_SHIFT
345
int
*
lambda_table
;
346
int
adaptive_quant
;
///< use adaptive quantization
347
int
dquant
;
///< qscale difference to prev qscale
348
int
closed_gop
;
///< MPEG1/2 GOP is closed
349
int
pict_type
;
///< AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
350
int
vbv_delay
;
351
int
last_pict_type
;
//FIXME removes
352
int
last_non_b_pict_type
;
///< used for mpeg4 gmc b-frames & ratecontrol
353
int
droppable
;
354
int
frame_rate_index
;
355
AVRational
mpeg2_frame_rate_ext
;
356
int
last_lambda_for
[5];
///< last lambda for a specific pict type
357
int
skipdct
;
///< skip dct and code zero residual
358
359
/* motion compensation */
360
int
unrestricted_mv
;
///< mv can point outside of the coded picture
361
int
h263_long_vectors
;
///< use horrible h263v1 long vector mode
362
363
BlockDSPContext
bdsp
;
364
FDCTDSPContext
fdsp
;
365
H264ChromaContext
h264chroma
;
366
HpelDSPContext
hdsp
;
367
IDCTDSPContext
idsp
;
368
MECmpContext
mecc
;
369
MpegVideoDSPContext
mdsp
;
370
MpegvideoEncDSPContext
mpvencdsp
;
371
PixblockDSPContext
pdsp
;
372
QpelDSPContext
qdsp
;
373
VideoDSPContext
vdsp
;
374
H263DSPContext
h263dsp
;
375
int
f_code
;
///< forward MV resolution
376
int
b_code
;
///< backward MV resolution for B Frames (mpeg4)
377
int16_t (*
p_mv_table_base
)[2];
378
int16_t (*
b_forw_mv_table_base
)[2];
379
int16_t (*
b_back_mv_table_base
)[2];
380
int16_t (*
b_bidir_forw_mv_table_base
)[2];
381
int16_t (*
b_bidir_back_mv_table_base
)[2];
382
int16_t (*
b_direct_mv_table_base
)[2];
383
int16_t (*
p_field_mv_table_base
[2][2])[2];
384
int16_t (*
b_field_mv_table_base
[2][2][2])[2];
385
int16_t (*
p_mv_table
)[2];
///< MV table (1MV per MB) p-frame encoding
386
int16_t (*
b_forw_mv_table
)[2];
///< MV table (1MV per MB) forward mode b-frame encoding
387
int16_t (*
b_back_mv_table
)[2];
///< MV table (1MV per MB) backward mode b-frame encoding
388
int16_t (*
b_bidir_forw_mv_table
)[2];
///< MV table (1MV per MB) bidir mode b-frame encoding
389
int16_t (*
b_bidir_back_mv_table
)[2];
///< MV table (1MV per MB) bidir mode b-frame encoding
390
int16_t (*
b_direct_mv_table
)[2];
///< MV table (1MV per MB) direct mode b-frame encoding
391
int16_t (*
p_field_mv_table
[2][2])[2];
///< MV table (2MV per MB) interlaced p-frame encoding
392
int16_t (*
b_field_mv_table
[2][2][2])[2];
///< MV table (4MV per MB) interlaced b-frame encoding
393
uint8_t
(*
p_field_select_table
[2]);
394
uint8_t
(*
b_field_select_table
[2][2]);
395
int
me_method
;
///< ME algorithm
396
int
mv_dir
;
397
#define MV_DIR_FORWARD 1
398
#define MV_DIR_BACKWARD 2
399
#define MV_DIRECT 4
///< bidirectional mode where the difference equals the MV of the last P/S/I-Frame (mpeg4)
400
int mv_type;
401
#define MV_TYPE_16X16 0
///< 1 vector for the whole mb
402
#define MV_TYPE_8X8 1
///< 4 vectors (h263, mpeg4 4MV)
403
#define MV_TYPE_16X8 2
///< 2 vectors, one per 16x8 block
404
#define MV_TYPE_FIELD 3
///< 2 vectors, one per field
405
#define MV_TYPE_DMV 4
///< 2 vectors, special mpeg2 Dual Prime Vectors
406
/**motion vectors for a macroblock
407
first coordinate : 0 = forward 1 = backward
408
second " : depend on type
409
third " : 0 = x, 1 = y
410
*/
411
int
mv
[2][4][2];
412
int
field_select
[2][2];
413
int
last_mv
[2][2][2];
///< last MV, used for MV prediction in MPEG1 & B-frame MPEG4
414
uint8_t
*
fcode_tab
;
///< smallest fcode needed for each MV
415
int16_t
direct_scale_mv
[2][64];
///< precomputed to avoid divisions in ff_mpeg4_set_direct_mv
416
417
MotionEstContext
me
;
418
419
int
no_rounding
;
/**< apply no rounding to motion compensation (MPEG4, msmpeg4, ...)
420
for b-frames rounding mode is always 0 */
421
422
/* macroblock layer */
423
int
mb_x
,
mb_y
;
424
int
mb_skip_run
;
425
int
mb_intra
;
426
uint16_t *
mb_type
;
///< Table for candidate MB types for encoding (defines in mpegutils.h)
427
428
int
block_index
[6];
///< index to current MB in block based arrays with edges
429
int
block_wrap
[6];
430
uint8_t
*
dest
[3];
431
432
int
*
mb_index2xy
;
///< mb_index -> mb_x + mb_y*mb_stride
433
434
/** matrix transmitted in the bitstream */
435
uint16_t
intra_matrix
[64];
436
uint16_t
chroma_intra_matrix
[64];
437
uint16_t
inter_matrix
[64];
438
uint16_t
chroma_inter_matrix
[64];
439
440
int
intra_quant_bias
;
///< bias for the quantizer
441
int
inter_quant_bias
;
///< bias for the quantizer
442
int
min_qcoeff
;
///< minimum encodable coefficient
443
int
max_qcoeff
;
///< maximum encodable coefficient
444
int
ac_esc_length
;
///< num of bits needed to encode the longest esc
445
uint8_t
*
intra_ac_vlc_length
;
446
uint8_t
*
intra_ac_vlc_last_length
;
447
uint8_t
*
intra_chroma_ac_vlc_length
;
448
uint8_t
*
intra_chroma_ac_vlc_last_length
;
449
uint8_t
*
inter_ac_vlc_length
;
450
uint8_t
*
inter_ac_vlc_last_length
;
451
uint8_t
*
luma_dc_vlc_length
;
452
#define UNI_AC_ENC_INDEX(run,level) ((run)*128 + (level))
453
454
int
coded_score
[12];
455
456
/** precomputed matrix (combine qscale and DCT renorm) */
457
int (*
q_intra_matrix
)[64];
458
int (*
q_chroma_intra_matrix
)[64];
459
int (*
q_inter_matrix
)[64];
460
/** identical to the above but for MMX & these are not permutated, second 64 entries are bias*/
461
uint16_t (*
q_intra_matrix16
)[2][64];
462
uint16_t (*
q_chroma_intra_matrix16
)[2][64];
463
uint16_t (*
q_inter_matrix16
)[2][64];
464
465
/* noise reduction */
466
int (*
dct_error_sum
)[64];
467
int
dct_count
[2];
468
uint16_t (*
dct_offset
)[64];
469
470
/* bit rate control */
471
int64_t
total_bits
;
472
int
frame_bits
;
///< bits used for the current frame
473
int
stuffing_bits
;
///< bits used for stuffing
474
int
next_lambda
;
///< next lambda used for retrying to encode a frame
475
RateControlContext
rc_context
;
///< contains stuff only accessed in ratecontrol.c
476
477
/* statistics, used for 2-pass encoding */
478
int
mv_bits
;
479
int
header_bits
;
480
int
i_tex_bits
;
481
int
p_tex_bits
;
482
int
i_count
;
483
int
f_count
;
484
int
b_count
;
485
int
skip_count
;
486
int
misc_bits
;
///< cbp, mb_type
487
int
last_bits
;
///< temp var used for calculating the above vars
488
489
/* error concealment / resync */
490
int
resync_mb_x
;
///< x position of last resync marker
491
int
resync_mb_y
;
///< y position of last resync marker
492
GetBitContext
last_resync_gb
;
///< used to search for the next resync marker
493
int
mb_num_left
;
///< number of MBs left in this video packet (for partitioned Slices only)
494
int
next_p_frame_damaged
;
///< set if the next p frame is damaged, to avoid showing trashed b frames
495
int
err_recognition
;
496
497
ParseContext
parse_context
;
498
499
/* H.263 specific */
500
int
gob_index
;
501
int
obmc
;
///< overlapped block motion compensation
502
int
mb_info
;
///< interval for outputting info about mb offsets as side data
503
int
prev_mb_info
,
last_mb_info
;
504
uint8_t
*
mb_info_ptr
;
505
int
mb_info_size
;
506
int
ehc_mode
;
507
508
/* H.263+ specific */
509
int
umvplus
;
///< == H263+ && unrestricted_mv
510
int
h263_aic_dir
;
///< AIC direction: 0 = left, 1 = top
511
int
h263_slice_structured
;
512
int
alt_inter_vlc
;
///< alternative inter vlc
513
int
modified_quant
;
514
int
loop_filter
;
515
int
custom_pcf
;
516
517
/* mpeg4 specific */
518
///< number of bits to represent the fractional part of time (encoder only)
519
int
time_increment_bits
;
520
int
last_time_base
;
521
int
time_base
;
///< time in seconds of last I,P,S Frame
522
int64_t
time
;
///< time of current frame
523
int64_t
last_non_b_time
;
524
uint16_t
pp_time
;
///< time distance between the last 2 p,s,i frames
525
uint16_t
pb_time
;
///< time distance between the last b and p,s,i frame
526
uint16_t
pp_field_time
;
527
uint16_t
pb_field_time
;
///< like above, just for interlaced
528
int
real_sprite_warping_points
;
529
int
sprite_offset
[2][2];
///< sprite offset[isChroma][isMVY]
530
int
sprite_delta
[2][2];
///< sprite_delta [isY][isMVY]
531
int
mcsel
;
532
int
quant_precision
;
533
int
quarter_sample
;
///< 1->qpel, 0->half pel ME/MC
534
int
aspect_ratio_info
;
//FIXME remove
535
int
sprite_warping_accuracy
;
536
int
data_partitioning
;
///< data partitioning flag from header
537
int
partitioned_frame
;
///< is current frame partitioned
538
int
low_delay
;
///< no reordering needed / has no b-frames
539
int
vo_type
;
540
PutBitContext
tex_pb
;
///< used for data partitioned VOPs
541
PutBitContext
pb2
;
///< used for data partitioned VOPs
542
int
mpeg_quant
;
543
int
padding_bug_score
;
///< used to detect the VERY common padding bug in MPEG4
544
545
/* divx specific, used to workaround (many) bugs in divx5 */
546
int
divx_packed
;
547
uint8_t
*
bitstream_buffer
;
//Divx 5.01 puts several frames in a single one, this is used to reorder them
548
int
bitstream_buffer_size
;
549
unsigned
int
allocated_bitstream_buffer_size
;
550
551
/* RV10 specific */
552
int
rv10_version
;
///< RV10 version: 0 or 3
553
int
rv10_first_dc_coded
[3];
554
555
/* MJPEG specific */
556
struct
MJpegContext
*
mjpeg_ctx
;
557
int
esc_pos
;
558
559
/* MSMPEG4 specific */
560
int
mv_table_index
;
561
int
rl_table_index
;
562
int
rl_chroma_table_index
;
563
int
dc_table_index
;
564
int
use_skip_mb_code
;
565
int
slice_height
;
///< in macroblocks
566
int
first_slice_line
;
///< used in mpeg4 too to handle resync markers
567
int
flipflop_rounding
;
568
int
msmpeg4_version
;
///< 0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
569
int
per_mb_rl_table
;
570
int
esc3_level_length
;
571
int
esc3_run_length
;
572
/** [mb_intra][isChroma][level][run][last] */
573
int (*
ac_stats
)[2][
MAX_LEVEL
+1][
MAX_RUN
+1][2];
574
int
inter_intra_pred
;
575
int
mspel
;
576
577
/* decompression specific */
578
GetBitContext
gb
;
579
580
/* Mpeg1 specific */
581
int
gop_picture_number
;
///< index of the first picture of a GOP based on fake_pic_num & mpeg1 specific
582
int
last_mv_dir
;
///< last mv_dir, used for b frame encoding
583
uint8_t
*
vbv_delay_ptr
;
///< pointer to vbv_delay in the bitstream
584
585
/* MPEG-2-specific - I wished not to have to support this mess. */
586
int
progressive_sequence
;
587
int
mpeg_f_code
[2][2];
588
589
// picture structure defines are loaded from mpegutils.h
590
int
picture_structure
;
591
592
int
intra_dc_precision
;
593
int
frame_pred_frame_dct
;
594
int
top_field_first
;
595
int
concealment_motion_vectors
;
596
int
q_scale_type
;
597
int
intra_vlc_format
;
598
int
alternate_scan
;
599
int
seq_disp_ext
;
600
int
repeat_first_field
;
601
int
chroma_420_type
;
602
int
chroma_format
;
603
#define CHROMA_420 1
604
#define CHROMA_422 2
605
#define CHROMA_444 3
606
int
chroma_x_shift
;
//depend on pix_format, that depend on chroma_format
607
int
chroma_y_shift
;
608
609
int
progressive_frame
;
610
int
full_pel
[2];
611
int
interlaced_dct
;
612
int
first_field
;
///< is 1 for the first field of a field picture 0 otherwise
613
int
drop_frame_timecode
;
///< timecode is in drop frame format.
614
int
scan_offset
;
///< reserve space for SVCD scan offset user data.
615
616
/* RTP specific */
617
int
rtp_mode
;
618
619
char
*
tc_opt_str
;
///< timecode option string
620
AVTimecode
tc
;
///< timecode context
621
622
uint8_t
*
ptr_lastgob
;
623
int
swap_uv
;
//vcr2 codec is an MPEG-2 variant with U and V swapped
624
int
pack_pblocks
;
//xvmc needs to keep blocks without gaps.
625
int16_t (*
pblocks
[12])[64];
626
627
int16_t (*
block
)[64];
///< points to one of the following blocks
628
int16_t (*
blocks
)[12][64];
// for HQ mode we need to keep the best block
629
int (*
decode_mb
)(
struct
MpegEncContext
*
s
, int16_t
block
[6][64]);
// used by some codecs to avoid a switch()
630
#define SLICE_OK 0
631
#define SLICE_ERROR -1
632
#define SLICE_END -2
///<end marker found
633
#define SLICE_NOEND -3
///<no end marker or error found but mb count exceeded
634
635
void
(*
dct_unquantize_mpeg1_intra
)(
struct
MpegEncContext
*
s
,
636
int16_t *
block
/*align 16*/
,
int
n
,
int
qscale
);
637
void
(*
dct_unquantize_mpeg1_inter
)(
struct
MpegEncContext
*
s
,
638
int16_t *
block
/*align 16*/
,
int
n
,
int
qscale
);
639
void
(*
dct_unquantize_mpeg2_intra
)(
struct
MpegEncContext
*
s
,
640
int16_t *
block
/*align 16*/
,
int
n
,
int
qscale
);
641
void
(*
dct_unquantize_mpeg2_inter
)(
struct
MpegEncContext
*
s
,
642
int16_t *
block
/*align 16*/
,
int
n
,
int
qscale
);
643
void
(*
dct_unquantize_h263_intra
)(
struct
MpegEncContext
*
s
,
644
int16_t *
block
/*align 16*/
,
int
n
,
int
qscale
);
645
void
(*
dct_unquantize_h263_inter
)(
struct
MpegEncContext
*
s
,
646
int16_t *
block
/*align 16*/
,
int
n
,
int
qscale
);
647
void
(*
dct_unquantize_intra
)(
struct
MpegEncContext
*
s
,
// unquantizer to use (mpeg4 can use both)
648
int16_t *
block
/*align 16*/
,
int
n
,
int
qscale
);
649
void
(*
dct_unquantize_inter
)(
struct
MpegEncContext
*
s
,
// unquantizer to use (mpeg4 can use both)
650
int16_t *
block
/*align 16*/
,
int
n
,
int
qscale
);
651
int (*
dct_quantize
)(
struct
MpegEncContext
*
s
, int16_t *
block
/*align 16*/
,
int
n
,
int
qscale
,
int
*overflow);
652
int (*
fast_dct_quantize
)(
struct
MpegEncContext
*
s
, int16_t *
block
/*align 16*/
,
int
n
,
int
qscale
,
int
*overflow);
653
void
(*
denoise_dct
)(
struct
MpegEncContext
*
s
, int16_t *
block
);
654
655
int
mpv_flags
;
///< flags set by private options
656
int
quantizer_noise_shaping
;
657
658
/**
659
* ratecontrol qmin qmax limiting method
660
* 0-> clipping, 1-> use a nice continuous function to limit qscale within qmin/qmax.
661
*/
662
float
rc_qsquish
;
663
float
rc_qmod_amp
;
664
int
rc_qmod_freq
;
665
float
rc_initial_cplx
;
666
float
rc_buffer_aggressivity
;
667
float
border_masking
;
668
int
lmin
,
lmax
;
669
670
char
*
rc_eq
;
671
672
/* temp buffers for rate control */
673
float
*
cplx_tab
, *
bits_tab
;
674
675
/* flag to indicate a reinitialization is required, e.g. after
676
* a frame size change */
677
int
context_reinit
;
678
679
ERContext
er
;
680
681
int
error_rate
;
682
683
/* temporary frames used by b_frame_strategy = 2 */
684
AVFrame
*
tmp_frames
[
MAX_B_FRAMES
+ 2];
685
}
MpegEncContext
;
686
687
/* mpegvideo_enc common options */
688
#define FF_MPV_FLAG_SKIP_RD 0x0001
689
#define FF_MPV_FLAG_STRICT_GOP 0x0002
690
#define FF_MPV_FLAG_QP_RD 0x0004
691
#define FF_MPV_FLAG_CBP_RD 0x0008
692
#define FF_MPV_FLAG_NAQ 0x0010
693
#define FF_MPV_FLAG_MV0 0x0020
694
695
#ifndef FF_MPV_OFFSET
696
#define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)
697
#endif
698
#define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
699
#define FF_MPV_COMMON_OPTS \
700
{ "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" },\
701
{ "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" },\
702
{ "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" },\
703
{ "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" },\
704
{ "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" },\
705
{ "naq", "normalize adaptive quantization", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_NAQ }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
706
{ "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" },\
707
{ "luma_elim_threshold", "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)",\
708
FF_MPV_OFFSET(luma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\
709
{ "chroma_elim_threshold", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)",\
710
FF_MPV_OFFSET(chroma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\
711
{ "quantizer_noise_shaping", NULL, FF_MPV_OFFSET(quantizer_noise_shaping), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FF_MPV_OPT_FLAGS },\
712
{ "error_rate", "Simulate errors in the bitstream to test error concealment.", \
713
FF_MPV_OFFSET(error_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FF_MPV_OPT_FLAGS },\
714
{"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)", \
715
FF_MPV_OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0, 99, FF_MPV_OPT_FLAGS}, \
716
{"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}, \
717
{"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}, \
718
{"rc_eq", "Set rate control equation. When computing the expression, besides the standard functions " \
719
"defined in the section 'Expression Evaluation', the following functions are available: " \
720
"bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv " \
721
"fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.", \
722
FF_MPV_OFFSET(rc_eq), AV_OPT_TYPE_STRING, .flags = FF_MPV_OPT_FLAGS }, \
723
{"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}, \
724
{"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}, \
725
{"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}, \
726
{"lmin", "minimum Lagrange factor (VBR)", FF_MPV_OFFSET(lmin), AV_OPT_TYPE_INT, {.i64 = 2*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS }, \
727
{"lmax", "maximum Lagrange factor (VBR)", FF_MPV_OFFSET(lmax), AV_OPT_TYPE_INT, {.i64 = 31*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS }, \
728
729
extern
const
AVOption
ff_mpv_generic_options
[];
730
731
#define FF_MPV_GENERIC_CLASS(name) \
732
static const AVClass name ## _class = {\
733
.class_name = #name " encoder",\
734
.item_name = av_default_item_name,\
735
.option = ff_mpv_generic_options,\
736
.version = LIBAVUTIL_VERSION_INT,\
737
};
738
739
/**
740
* Set the given MpegEncContext to common defaults (same for encoding
741
* and decoding). The changed fields will not depend upon the prior
742
* state of the MpegEncContext.
743
*/
744
void
ff_mpv_common_defaults
(
MpegEncContext
*
s
);
745
746
void
ff_dct_encode_init_x86
(
MpegEncContext
*
s
);
747
748
int
ff_mpv_common_init
(
MpegEncContext
*
s
);
749
void
ff_mpv_common_init_arm
(
MpegEncContext
*
s
);
750
void
ff_mpv_common_init_axp
(
MpegEncContext
*
s
);
751
void
ff_mpv_common_init_neon
(
MpegEncContext
*
s
);
752
void
ff_mpv_common_init_ppc
(
MpegEncContext
*
s
);
753
void
ff_mpv_common_init_x86
(
MpegEncContext
*
s
);
754
755
int
ff_mpv_common_frame_size_change
(
MpegEncContext
*
s
);
756
void
ff_mpv_common_end
(
MpegEncContext
*
s
);
757
758
void
ff_mpv_decode_defaults
(
MpegEncContext
*
s
);
759
void
ff_mpv_decode_init
(
MpegEncContext
*
s
,
AVCodecContext
*
avctx
);
760
void
ff_mpv_decode_mb
(
MpegEncContext
*
s
, int16_t
block
[12][64]);
761
void
ff_mpv_report_decode_progress
(
MpegEncContext
*
s
);
762
763
int
ff_mpv_frame_start
(
MpegEncContext
*
s
,
AVCodecContext
*
avctx
);
764
void
ff_mpv_frame_end
(
MpegEncContext
*
s
);
765
766
int
ff_mpv_lowest_referenced_row
(
MpegEncContext
*
s
,
int
dir);
767
768
int
ff_mpv_encode_init
(
AVCodecContext
*
avctx
);
769
void
ff_mpv_encode_init_x86
(
MpegEncContext
*
s
);
770
771
int
ff_mpv_encode_end
(
AVCodecContext
*
avctx
);
772
int
ff_mpv_encode_picture
(
AVCodecContext
*
avctx
,
AVPacket
*
pkt
,
773
const
AVFrame
*
frame
,
int
*got_packet);
774
int
ff_mpv_reallocate_putbitbuffer
(
MpegEncContext
*
s
,
size_t
threshold,
size_t
size_increase);
775
776
void
ff_clean_intra_table_entries
(
MpegEncContext
*
s
);
777
void
ff_mpeg_draw_horiz_band
(
MpegEncContext
*
s
,
int
y
,
int
h);
778
void
ff_mpeg_flush
(
AVCodecContext
*
avctx
);
779
780
void
ff_print_debug_info
(
MpegEncContext
*
s
,
Picture
*p,
AVFrame
*pict);
781
void
ff_print_debug_info2
(
AVCodecContext
*
avctx
,
AVFrame
*pict,
uint8_t
*
mbskip_table
,
782
uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
783
int
*
low_delay
,
784
int
mb_width
,
int
mb_height
,
int
mb_stride
,
int
quarter_sample
);
785
786
int
ff_mpv_export_qp_table
(
MpegEncContext
*
s
,
AVFrame
*f,
Picture
*p,
int
qp_type);
787
788
void
ff_write_quant_matrix
(
PutBitContext
*
pb
, uint16_t *matrix);
789
int
ff_find_unused_picture
(
MpegEncContext
*
s
,
int
shared);
790
int
ff_update_duplicate_context
(
MpegEncContext
*dst,
MpegEncContext
*
src
);
791
int
ff_mpeg_update_thread_context
(
AVCodecContext
*dst,
const
AVCodecContext
*
src
);
792
void
ff_set_qscale
(
MpegEncContext
*
s
,
int
qscale
);
793
794
void
ff_mpv_idct_init
(
MpegEncContext
*
s
);
795
int
ff_dct_encode_init
(
MpegEncContext
*
s
);
796
void
ff_convert_matrix
(
MpegEncContext
*
s
,
int
(*qmat)[64], uint16_t (*qmat16)[2][64],
797
const
uint16_t *quant_matrix,
int
bias,
int
qmin,
int
qmax,
int
intra);
798
int
ff_dct_quantize_c
(
MpegEncContext
*s, int16_t *
block
,
int
n
,
int
qscale
,
int
*overflow);
799
800
void
ff_init_block_index
(
MpegEncContext
*s);
801
802
void
ff_mpv_motion
(
MpegEncContext
*s,
803
uint8_t
*dest_y,
uint8_t
*dest_cb,
804
uint8_t
*dest_cr,
int
dir,
805
uint8_t
**ref_picture,
806
op_pixels_func
(*pix_op)[4],
807
qpel_mc_func
(*qpix_op)[16]);
808
809
/**
810
* Allocate a Picture.
811
* The pixels are allocated/set by calling get_buffer() if shared = 0.
812
*/
813
int
ff_alloc_picture
(
MpegEncContext
*s,
Picture
*pic,
int
shared);
814
815
/**
816
* permute block according to permuatation.
817
* @param last last non zero element in scantable order
818
*/
819
void
ff_block_permute
(int16_t *
block
,
uint8_t
*permutation,
const
uint8_t
*scantable,
int
last);
820
821
static
inline
void
ff_update_block_index
(
MpegEncContext
*s){
822
const
int
block_size= 8 >> s->
avctx
->
lowres
;
823
824
s->
block_index
[0]+=2;
825
s->
block_index
[1]+=2;
826
s->
block_index
[2]+=2;
827
s->
block_index
[3]+=2;
828
s->
block_index
[4]++;
829
s->
block_index
[5]++;
830
s->
dest
[0]+= 2*block_size;
831
s->
dest
[1]+= block_size;
832
s->
dest
[2]+= block_size;
833
}
834
835
static
inline
int
get_bits_diff
(
MpegEncContext
*s){
836
const
int
bits
=
put_bits_count
(&s->
pb
);
837
const
int
last= s->
last_bits
;
838
839
s->
last_bits
=
bits
;
840
841
return
bits - last;
842
}
843
844
static
inline
int
ff_h263_round_chroma
(
int
x){
845
static
const
uint8_t
h263_chroma_roundtab[16] = {
846
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
847
0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
848
};
849
return
h263_chroma_roundtab[x & 0xf] + (x >> 3);
850
}
851
852
/* motion_est.c */
853
void
ff_estimate_p_frame_motion
(
MpegEncContext
* s,
854
int
mb_x
,
int
mb_y
);
855
void
ff_estimate_b_frame_motion
(
MpegEncContext
* s,
856
int
mb_x
,
int
mb_y
);
857
int
ff_get_best_fcode
(
MpegEncContext
* s, int16_t (*mv_table)[2],
int
type
);
858
void
ff_fix_long_p_mvs
(
MpegEncContext
* s);
859
void
ff_fix_long_mvs
(
MpegEncContext
* s,
uint8_t
*field_select_table,
int
field_select
,
860
int16_t (*mv_table)[2],
int
f_code
,
int
type
,
int
truncate);
861
int
ff_init_me
(
MpegEncContext
*s);
862
int
ff_pre_estimate_p_frame_motion
(
MpegEncContext
* s,
int
mb_x
,
int
mb_y
);
863
int
ff_epzs_motion_search
(
MpegEncContext
* s,
int
*mx_ptr,
int
*my_ptr,
864
int
P[10][2],
int
src_index,
int
ref_index, int16_t (*
last_mv
)[2],
865
int
ref_mv_scale,
int
size
,
int
h);
866
int
ff_get_mb_score
(
MpegEncContext
* s,
int
mx,
int
my,
int
src_index,
867
int
ref_index,
int
size
,
int
h,
int
add_rate);
868
869
/* mpeg12.c */
870
extern
const
uint8_t
ff_mpeg1_dc_scale_table
[128];
871
extern
const
uint8_t
*
const
ff_mpeg2_dc_scale_table
[4];
872
873
void
ff_mpeg1_encode_picture_header
(
MpegEncContext
*s,
int
picture_number
);
874
void
ff_mpeg1_encode_mb
(
MpegEncContext
*s,
875
int16_t
block
[8][64],
876
int
motion_x,
int
motion_y);
877
void
ff_mpeg1_encode_init
(
MpegEncContext
*s);
878
void
ff_mpeg1_encode_slice_header
(
MpegEncContext
*s);
879
880
extern
const
uint8_t
ff_aic_dc_scale_table
[32];
881
extern
const
uint8_t
ff_h263_chroma_qscale_table
[32];
882
883
/* rv10.c */
884
int
ff_rv10_encode_picture_header
(
MpegEncContext
*s,
int
picture_number
);
885
int
ff_rv_decode_dc
(
MpegEncContext
*s,
int
n
);
886
void
ff_rv20_encode_picture_header
(
MpegEncContext
*s,
int
picture_number
);
887
888
889
/* msmpeg4.c */
890
void
ff_msmpeg4_encode_picture_header
(
MpegEncContext
* s,
int
picture_number
);
891
void
ff_msmpeg4_encode_ext_header
(
MpegEncContext
* s);
892
void
ff_msmpeg4_encode_mb
(
MpegEncContext
* s,
893
int16_t
block
[6][64],
894
int
motion_x,
int
motion_y);
895
int
ff_msmpeg4_decode_picture_header
(
MpegEncContext
* s);
896
int
ff_msmpeg4_decode_ext_header
(
MpegEncContext
* s,
int
buf_size);
897
int
ff_msmpeg4_decode_init
(
AVCodecContext
*avctx);
898
int
ff_msmpeg4_encode_init
(
MpegEncContext
*s);
899
int
ff_wmv2_decode_picture_header
(
MpegEncContext
* s);
900
int
ff_wmv2_decode_secondary_picture_header
(
MpegEncContext
* s);
901
void
ff_wmv2_add_mb
(
MpegEncContext
*s, int16_t
block
[6][64],
uint8_t
*dest_y,
uint8_t
*dest_cb,
uint8_t
*dest_cr);
902
void
ff_mspel_motion
(
MpegEncContext
*s,
903
uint8_t
*dest_y,
uint8_t
*dest_cb,
uint8_t
*dest_cr,
904
uint8_t
**ref_picture,
op_pixels_func
(*pix_op)[4],
905
int
motion_x,
int
motion_y,
int
h);
906
int
ff_wmv2_encode_picture_header
(
MpegEncContext
* s,
int
picture_number
);
907
void
ff_wmv2_encode_mb
(
MpegEncContext
* s,
908
int16_t
block
[6][64],
909
int
motion_x,
int
motion_y);
910
911
int
ff_mpeg_ref_picture
(
MpegEncContext
*s,
Picture
*dst,
Picture
*
src
);
912
void
ff_mpeg_unref_picture
(
MpegEncContext
*s,
Picture
*
picture
);
913
void
ff_free_picture_tables
(
Picture
*pic);
914
915
916
#endif
/* AVCODEC_MPEGVIDEO_H */
Generated on Tue Jun 21 2022 16:28:02 for FFmpeg by
1.8.1.2