Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * MPEG4 encoder/decoder internal header. | |
3 | * Copyright (c) 2000,2001 Fabrice Bellard | |
4 | * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at> | |
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 | #ifndef AVCODEC_MPEG4VIDEO_H | |
24 | #define AVCODEC_MPEG4VIDEO_H | |
25 | ||
26 | #include <stdint.h> | |
27 | ||
28 | #include "get_bits.h" | |
29 | #include "mpegvideo.h" | |
30 | #include "rl.h" | |
31 | ||
32 | // shapes | |
33 | #define RECT_SHAPE 0 | |
34 | #define BIN_SHAPE 1 | |
35 | #define BIN_ONLY_SHAPE 2 | |
36 | #define GRAY_SHAPE 3 | |
37 | ||
38 | #define SIMPLE_VO_TYPE 1 | |
39 | #define CORE_VO_TYPE 3 | |
40 | #define MAIN_VO_TYPE 4 | |
41 | #define NBIT_VO_TYPE 5 | |
42 | #define ARTS_VO_TYPE 10 | |
43 | #define ACE_VO_TYPE 12 | |
44 | #define ADV_SIMPLE_VO_TYPE 17 | |
45 | ||
46 | // aspect_ratio_info | |
47 | #define EXTENDED_PAR 15 | |
48 | ||
49 | //vol_sprite_usage / sprite_enable | |
50 | #define STATIC_SPRITE 1 | |
51 | #define GMC_SPRITE 2 | |
52 | ||
53 | #define MOTION_MARKER 0x1F001 | |
54 | #define DC_MARKER 0x6B001 | |
55 | ||
56 | #define VOS_STARTCODE 0x1B0 | |
57 | #define USER_DATA_STARTCODE 0x1B2 | |
58 | #define GOP_STARTCODE 0x1B3 | |
59 | #define VISUAL_OBJ_STARTCODE 0x1B5 | |
60 | #define VOP_STARTCODE 0x1B6 | |
61 | ||
62 | typedef struct Mpeg4DecContext { | |
63 | MpegEncContext m; | |
64 | ||
65 | /// number of bits to represent the fractional part of time | |
66 | int time_increment_bits; | |
67 | int shape; | |
68 | int vol_sprite_usage; | |
69 | int sprite_brightness_change; | |
70 | int num_sprite_warping_points; | |
71 | /// sprite trajectory points | |
72 | uint16_t sprite_traj[4][2]; | |
73 | /// sprite shift [isChroma] | |
74 | int sprite_shift[2]; | |
75 | ||
76 | // reversible vlc | |
77 | int rvlc; | |
78 | /// could this stream contain resync markers | |
79 | int resync_marker; | |
80 | /// time distance of first I -> B, used for interlaced B-frames | |
81 | int t_frame; | |
82 | ||
83 | int new_pred; | |
84 | int enhancement_type; | |
85 | int scalability; | |
86 | int use_intra_dc_vlc; | |
87 | ||
88 | /// QP above which the ac VLC should be used for intra dc | |
89 | int intra_dc_threshold; | |
90 | ||
91 | /* bug workarounds */ | |
92 | int divx_version; | |
93 | int divx_build; | |
94 | int xvid_build; | |
95 | int lavc_build; | |
96 | ||
97 | /// flag for having shown the warning about invalid Divx B-frames | |
98 | int showed_packed_warning; | |
99 | /** does the stream contain the low_delay flag, | |
100 | * used to work around buggy encoders. */ | |
101 | int vol_control_parameters; | |
102 | int cplx_estimation_trash_i; | |
103 | int cplx_estimation_trash_p; | |
104 | int cplx_estimation_trash_b; | |
105 | } Mpeg4DecContext; | |
106 | ||
107 | /* dc encoding for mpeg4 */ | |
108 | extern const uint8_t ff_mpeg4_DCtab_lum[13][2]; | |
109 | extern const uint8_t ff_mpeg4_DCtab_chrom[13][2]; | |
110 | ||
111 | extern const uint16_t ff_mpeg4_intra_vlc[103][2]; | |
112 | extern const int8_t ff_mpeg4_intra_level[102]; | |
113 | extern const int8_t ff_mpeg4_intra_run[102]; | |
114 | ||
115 | extern RLTable ff_mpeg4_rl_intra; | |
116 | ||
117 | /* Note this is identical to the intra rvlc except that it is reordered. */ | |
118 | extern RLTable ff_rvlc_rl_inter; | |
119 | extern RLTable ff_rvlc_rl_intra; | |
120 | ||
121 | extern const uint16_t ff_sprite_trajectory_tab[15][2]; | |
122 | extern const uint8_t ff_mb_type_b_tab[4][2]; | |
123 | ||
124 | /* these matrixes will be permuted for the idct */ | |
125 | extern const int16_t ff_mpeg4_default_intra_matrix[64]; | |
126 | extern const int16_t ff_mpeg4_default_non_intra_matrix[64]; | |
127 | ||
128 | extern const uint8_t ff_mpeg4_y_dc_scale_table[32]; | |
129 | extern const uint8_t ff_mpeg4_c_dc_scale_table[32]; | |
130 | extern const uint16_t ff_mpeg4_resync_prefix[8]; | |
131 | ||
132 | extern const uint8_t ff_mpeg4_dc_threshold[8]; | |
133 | ||
134 | void ff_mpeg4_encode_mb(MpegEncContext *s, | |
135 | int16_t block[6][64], | |
136 | int motion_x, int motion_y); | |
137 | void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, | |
138 | int dir); | |
139 | void ff_set_mpeg4_time(MpegEncContext *s); | |
140 | void ff_mpeg4_encode_picture_header(MpegEncContext *s, int picture_number); | |
141 | ||
142 | int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb); | |
143 | void ff_mpeg4_encode_video_packet_header(MpegEncContext *s); | |
144 | void ff_mpeg4_clean_buffers(MpegEncContext *s); | |
145 | void ff_mpeg4_stuffing(PutBitContext *pbc); | |
146 | void ff_mpeg4_init_partitions(MpegEncContext *s); | |
147 | void ff_mpeg4_merge_partitions(MpegEncContext *s); | |
148 | void ff_clean_mpeg4_qscales(MpegEncContext *s); | |
149 | int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx); | |
150 | int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s); | |
151 | int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx); | |
152 | void ff_mpeg4_init_direct_mv(MpegEncContext *s); | |
153 | void ff_mpeg4videodec_static_init(void); | |
154 | int ff_mpeg4_workaround_bugs(AVCodecContext *avctx); | |
155 | int ff_mpeg4_frame_end(AVCodecContext *avctx, const uint8_t *buf, int buf_size); | |
156 | ||
157 | /** | |
158 | * | |
159 | * @return the mb_type | |
160 | */ | |
161 | int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my); | |
162 | ||
163 | extern uint8_t ff_mpeg4_static_rl_table_store[3][2][2 * MAX_RUN + MAX_LEVEL + 3]; | |
164 | ||
165 | #if 0 //3IV1 is quite rare and it slows things down a tiny bit | |
166 | #define IS_3IV1 s->codec_tag == AV_RL32("3IV1") | |
167 | #else | |
168 | #define IS_3IV1 0 | |
169 | #endif | |
170 | ||
171 | /** | |
172 | * Predict the dc. | |
173 | * encoding quantized level -> quantized diff | |
174 | * decoding quantized diff -> quantized level | |
175 | * @param n block index (0-3 are luma, 4-5 are chroma) | |
176 | * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
177 | */ | |
178 | static inline int ff_mpeg4_pred_dc(MpegEncContext *s, int n, int level, | |
179 | int *dir_ptr, int encoding) | |
180 | { | |
181 | int a, b, c, wrap, pred, scale, ret; | |
182 | int16_t *dc_val; | |
183 | ||
184 | /* find prediction */ | |
185 | if (n < 4) | |
186 | scale = s->y_dc_scale; | |
187 | else | |
188 | scale = s->c_dc_scale; | |
189 | if (IS_3IV1) | |
190 | scale = 8; | |
191 | ||
192 | wrap = s->block_wrap[n]; | |
193 | dc_val = s->dc_val[0] + s->block_index[n]; | |
194 | ||
195 | /* B C | |
196 | * A X | |
197 | */ | |
198 | a = dc_val[-1]; | |
199 | b = dc_val[-1 - wrap]; | |
200 | c = dc_val[-wrap]; | |
201 | ||
202 | /* outside slice handling (we can't do that by memset as we need the | |
203 | * dc for error resilience) */ | |
204 | if (s->first_slice_line && n != 3) { | |
205 | if (n != 2) | |
206 | b = c = 1024; | |
207 | if (n != 1 && s->mb_x == s->resync_mb_x) | |
208 | b = a = 1024; | |
209 | } | |
210 | if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1) { | |
211 | if (n == 0 || n == 4 || n == 5) | |
212 | b = 1024; | |
213 | } | |
214 | ||
215 | if (abs(a - b) < abs(b - c)) { | |
216 | pred = c; | |
217 | *dir_ptr = 1; /* top */ | |
218 | } else { | |
219 | pred = a; | |
220 | *dir_ptr = 0; /* left */ | |
221 | } | |
222 | /* we assume pred is positive */ | |
223 | pred = FASTDIV((pred + (scale >> 1)), scale); | |
224 | ||
225 | if (encoding) { | |
226 | ret = level - pred; | |
227 | } else { | |
228 | level += pred; | |
229 | ret = level; | |
230 | if (s->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) { | |
231 | if (level < 0) { | |
232 | av_log(s->avctx, AV_LOG_ERROR, | |
233 | "dc<0 at %dx%d\n", s->mb_x, s->mb_y); | |
234 | return -1; | |
235 | } | |
236 | if (level * scale > 2048 + scale) { | |
237 | av_log(s->avctx, AV_LOG_ERROR, | |
238 | "dc overflow at %dx%d\n", s->mb_x, s->mb_y); | |
239 | return -1; | |
240 | } | |
241 | } | |
242 | } | |
243 | level *= scale; | |
244 | if (level & (~2047)) { | |
245 | if (level < 0) | |
246 | level = 0; | |
247 | else if (!(s->workaround_bugs & FF_BUG_DC_CLIP)) | |
248 | level = 2047; | |
249 | } | |
250 | dc_val[0] = level; | |
251 | ||
252 | return ret; | |
253 | } | |
254 | ||
255 | #endif /* AVCODEC_MPEG4VIDEO_H */ |