Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * MSMPEG4 backend for encoder and decoder | ||
3 | * Copyright (c) 2001 Fabrice Bellard | ||
4 | * Copyright (c) 2002-2013 Michael Niedermayer <michaelni@gmx.at> | ||
5 | * | ||
6 | * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at> | ||
7 | * | ||
8 | * This file is part of FFmpeg. | ||
9 | * | ||
10 | * FFmpeg is free software; you can redistribute it and/or | ||
11 | * modify it under the terms of the GNU Lesser General Public | ||
12 | * License as published by the Free Software Foundation; either | ||
13 | * version 2.1 of the License, or (at your option) any later version. | ||
14 | * | ||
15 | * FFmpeg is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
18 | * Lesser General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU Lesser General Public | ||
21 | * License along with FFmpeg; if not, write to the Free Software | ||
22 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
23 | */ | ||
24 | |||
25 | #include "libavutil/thread.h" | ||
26 | |||
27 | #include "avcodec.h" | ||
28 | #include "codec_internal.h" | ||
29 | #include "mpegutils.h" | ||
30 | #include "mpegvideo.h" | ||
31 | #include "mpegvideodec.h" | ||
32 | #include "msmpeg4.h" | ||
33 | #include "msmpeg4dec.h" | ||
34 | #include "libavutil/imgutils.h" | ||
35 | #include "h263.h" | ||
36 | #include "h263data.h" | ||
37 | #include "h263dec.h" | ||
38 | #include "mpeg4videodec.h" | ||
39 | #include "msmpeg4data.h" | ||
40 | #include "msmpeg4_vc1_data.h" | ||
41 | |||
42 | #define V2_INTRA_CBPC_VLC_BITS 3 | ||
43 | #define V2_MB_TYPE_VLC_BITS 7 | ||
44 | #define MV_VLC_BITS 9 | ||
45 | #define TEX_VLC_BITS 9 | ||
46 | |||
47 | #define DEFAULT_INTER_INDEX 3 | ||
48 | |||
49 | static const VLCElem *mv_tables[2]; | ||
50 | |||
51 | 5490 | static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, | |
52 | int32_t **dc_val_ptr) | ||
53 | { | ||
54 | int i; | ||
55 | |||
56 |
2/2✓ Branch 0 taken 3660 times.
✓ Branch 1 taken 1830 times.
|
5490 | if (n < 4) { |
57 | 3660 | i= 0; | |
58 | } else { | ||
59 | 1830 | i= n-3; | |
60 | } | ||
61 | |||
62 | 5490 | *dc_val_ptr= &s->last_dc[i]; | |
63 | 5490 | return s->last_dc[i]; | |
64 | } | ||
65 | |||
66 | /****************************************/ | ||
67 | /* decoding stuff */ | ||
68 | |||
69 | const VLCElem *ff_mb_non_intra_vlc[4]; | ||
70 | static VLCElem v2_dc_lum_vlc[1472]; | ||
71 | static VLCElem v2_dc_chroma_vlc[1506]; | ||
72 | static VLCElem v2_intra_cbpc_vlc[8]; | ||
73 | static VLCElem v2_mb_type_vlc[128]; | ||
74 | VLCElem ff_inter_intra_vlc[8]; | ||
75 | |||
76 | /* This is identical to H.263 except that its range is multiplied by 2. */ | ||
77 | 132268 | static int msmpeg4v2_decode_motion(H263DecContext *const h, int pred, int f_code) | |
78 | { | ||
79 | int code, val, sign, shift; | ||
80 | |||
81 | 132268 | code = get_vlc2(&h->gb, ff_h263_mv_vlc, H263_MV_VLC_BITS, 2); | |
82 | ff_dlog(h->c.avctx, "MV code %d at %d %d pred: %d\n", | ||
83 | code, h->c.mb_x,h->c.mb_y, pred); | ||
84 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 132268 times.
|
132268 | if (code < 0) |
85 | ✗ | return 0xffff; | |
86 | |||
87 |
2/2✓ Branch 0 taken 68571 times.
✓ Branch 1 taken 63697 times.
|
132268 | if (code == 0) |
88 | 68571 | return pred; | |
89 | 63697 | sign = get_bits1(&h->gb); | |
90 | 63697 | shift = f_code - 1; | |
91 | 63697 | val = code; | |
92 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 63697 times.
|
63697 | if (shift) { |
93 | ✗ | val = (val - 1) << shift; | |
94 | ✗ | val |= get_bits(&h->gb, shift); | |
95 | ✗ | val++; | |
96 | } | ||
97 |
2/2✓ Branch 0 taken 26289 times.
✓ Branch 1 taken 37408 times.
|
63697 | if (sign) |
98 | 26289 | val = -val; | |
99 | |||
100 | 63697 | val += pred; | |
101 |
2/2✓ Branch 0 taken 138 times.
✓ Branch 1 taken 63559 times.
|
63697 | if (val <= -64) |
102 | 138 | val += 64; | |
103 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 63546 times.
|
63559 | else if (val >= 64) |
104 | 13 | val -= 64; | |
105 | |||
106 | 63697 | return val; | |
107 | } | ||
108 | |||
109 | 76350 | static int msmpeg4v12_decode_mb(H263DecContext *const h) | |
110 | { | ||
111 | 76350 | MSMP4DecContext *const ms = mpv_to_msmpeg4(h); | |
112 | int cbp, code, i; | ||
113 | 76350 | uint32_t * const mb_type_ptr = &h->c.cur_pic.mb_type[h->c.mb_x + h->c.mb_y*h->c.mb_stride]; | |
114 | |||
115 |
2/2✓ Branch 0 taken 70035 times.
✓ Branch 1 taken 6315 times.
|
76350 | if (h->c.pict_type == AV_PICTURE_TYPE_P) { |
116 |
1/2✓ Branch 0 taken 70035 times.
✗ Branch 1 not taken.
|
70035 | if (ms->use_skip_mb_code) { |
117 |
2/2✓ Branch 1 taken 1159 times.
✓ Branch 2 taken 68876 times.
|
70035 | if (get_bits1(&h->gb)) { |
118 | /* skip mb */ | ||
119 | 1159 | h->c.mb_intra = 0; | |
120 |
2/2✓ Branch 0 taken 6954 times.
✓ Branch 1 taken 1159 times.
|
8113 | for(i=0;i<6;i++) |
121 | 6954 | h->c.block_last_index[i] = -1; | |
122 | 1159 | h->c.mv_dir = MV_DIR_FORWARD; | |
123 | 1159 | h->c.mv_type = MV_TYPE_16X16; | |
124 | 1159 | h->c.mv[0][0][0] = 0; | |
125 | 1159 | h->c.mv[0][0][1] = 0; | |
126 | 1159 | h->c.mb_skipped = 1; | |
127 | 1159 | *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16; | |
128 | 1159 | return 0; | |
129 | } | ||
130 | } | ||
131 | |||
132 |
2/2✓ Branch 0 taken 53160 times.
✓ Branch 1 taken 15716 times.
|
68876 | if (h->c.msmpeg4_version == MSMP4_V2) |
133 | 53160 | code = get_vlc2(&h->gb, v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 1); | |
134 | else | ||
135 | 15716 | code = get_vlc2(&h->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); | |
136 |
2/4✓ Branch 0 taken 68876 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 68876 times.
|
68876 | if(code<0 || code>7){ |
137 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", | |
138 | code, h->c.mb_x, h->c.mb_y); | ||
139 | ✗ | return -1; | |
140 | } | ||
141 | |||
142 | 68876 | h->c.mb_intra = code >>2; | |
143 | |||
144 | 68876 | cbp = code & 0x3; | |
145 | } else { | ||
146 | 6315 | h->c.mb_intra = 1; | |
147 |
2/2✓ Branch 0 taken 5985 times.
✓ Branch 1 taken 330 times.
|
6315 | if (h->c.msmpeg4_version == MSMP4_V2) |
148 | 5985 | cbp = get_vlc2(&h->gb, v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 1); | |
149 | else | ||
150 | 330 | cbp = get_vlc2(&h->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); | |
151 |
2/4✓ Branch 0 taken 6315 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6315 times.
|
6315 | if(cbp<0 || cbp>3){ |
152 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", | |
153 | cbp, h->c.mb_x, h->c.mb_y); | ||
154 | ✗ | return -1; | |
155 | } | ||
156 | } | ||
157 | |||
158 |
2/2✓ Branch 0 taken 66134 times.
✓ Branch 1 taken 9057 times.
|
75191 | if (!h->c.mb_intra) { |
159 | int mx, my, cbpy; | ||
160 | |||
161 | 66134 | cbpy = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); | |
162 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 66134 times.
|
66134 | if(cbpy<0){ |
163 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", | |
164 | cbp, h->c.mb_x, h->c.mb_y); | ||
165 | ✗ | return -1; | |
166 | } | ||
167 | |||
168 | 66134 | cbp|= cbpy<<2; | |
169 |
4/4✓ Branch 0 taken 51003 times.
✓ Branch 1 taken 15131 times.
✓ Branch 2 taken 40593 times.
✓ Branch 3 taken 10410 times.
|
66134 | if (h->c.msmpeg4_version == MSMP4_V1 || (cbp&3) != 3) |
170 | 55724 | cbp ^= 0x3C; | |
171 | |||
172 | 66134 | ff_h263_pred_motion(&h->c, 0, 0, &mx, &my); | |
173 | 66134 | mx = msmpeg4v2_decode_motion(h, mx, 1); | |
174 | 66134 | my = msmpeg4v2_decode_motion(h, my, 1); | |
175 | |||
176 | 66134 | h->c.mv_dir = MV_DIR_FORWARD; | |
177 | 66134 | h->c.mv_type = MV_TYPE_16X16; | |
178 | 66134 | h->c.mv[0][0][0] = mx; | |
179 | 66134 | h->c.mv[0][0][1] = my; | |
180 | 66134 | *mb_type_ptr = MB_TYPE_FORWARD_MV | MB_TYPE_16x16; | |
181 | } else { | ||
182 | int v; | ||
183 |
2/2✓ Branch 0 taken 8142 times.
✓ Branch 1 taken 915 times.
|
9057 | if (h->c.msmpeg4_version == MSMP4_V2) { |
184 | 8142 | h->c.ac_pred = get_bits1(&h->gb); | |
185 | 8142 | v = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); | |
186 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8142 times.
|
8142 | if (v < 0) { |
187 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "cbpy vlc invalid\n"); | |
188 | ✗ | return -1; | |
189 | } | ||
190 | 8142 | cbp|= v<<2; | |
191 | } else{ | ||
192 | 915 | h->c.ac_pred = 0; | |
193 | 915 | v = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); | |
194 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 915 times.
|
915 | if (v < 0) { |
195 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "cbpy vlc invalid\n"); | |
196 | ✗ | return -1; | |
197 | } | ||
198 | 915 | cbp|= v<<2; | |
199 |
2/2✓ Branch 0 taken 585 times.
✓ Branch 1 taken 330 times.
|
915 | if (h->c.pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C; |
200 | } | ||
201 | 9057 | *mb_type_ptr = MB_TYPE_INTRA; | |
202 | } | ||
203 | |||
204 | 75191 | h->c.bdsp.clear_blocks(h->block[0]); | |
205 |
2/2✓ Branch 0 taken 451146 times.
✓ Branch 1 taken 75191 times.
|
526337 | for (i = 0; i < 6; i++) { |
206 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 451146 times.
|
451146 | if (ff_msmpeg4_decode_block(ms, h->block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) |
207 | { | ||
208 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", | |
209 | h->c.mb_x, h->c.mb_y, i); | ||
210 | ✗ | return -1; | |
211 | } | ||
212 | } | ||
213 | 75191 | return 0; | |
214 | } | ||
215 | |||
216 | 129600 | static int msmpeg4v34_decode_mb(H263DecContext *const h) | |
217 | { | ||
218 | 129600 | MSMP4DecContext *const ms = mpv_to_msmpeg4(h); | |
219 | int cbp, code, i; | ||
220 | uint8_t *coded_val; | ||
221 | 129600 | uint32_t * const mb_type_ptr = &h->c.cur_pic.mb_type[h->c.mb_x + h->c.mb_y*h->c.mb_stride]; | |
222 | |||
223 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 129600 times.
|
129600 | if (get_bits_left(&h->gb) <= 0) |
224 | ✗ | return AVERROR_INVALIDDATA; | |
225 | |||
226 |
2/2✓ Branch 0 taken 116442 times.
✓ Branch 1 taken 13158 times.
|
129600 | if (h->c.pict_type == AV_PICTURE_TYPE_P) { |
227 |
1/2✓ Branch 0 taken 116442 times.
✗ Branch 1 not taken.
|
116442 | if (ms->use_skip_mb_code) { |
228 |
2/2✓ Branch 1 taken 1554 times.
✓ Branch 2 taken 114888 times.
|
116442 | if (get_bits1(&h->gb)) { |
229 | /* skip mb */ | ||
230 | 1554 | h->c.mb_intra = 0; | |
231 |
2/2✓ Branch 0 taken 9324 times.
✓ Branch 1 taken 1554 times.
|
10878 | for(i=0;i<6;i++) |
232 | 9324 | h->c.block_last_index[i] = -1; | |
233 | 1554 | h->c.mv_dir = MV_DIR_FORWARD; | |
234 | 1554 | h->c.mv_type = MV_TYPE_16X16; | |
235 | 1554 | h->c.mv[0][0][0] = 0; | |
236 | 1554 | h->c.mv[0][0][1] = 0; | |
237 | 1554 | h->c.mb_skipped = 1; | |
238 | 1554 | *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16; | |
239 | |||
240 | 1554 | return 0; | |
241 | } | ||
242 | } | ||
243 | |||
244 | 114888 | code = get_vlc2(&h->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX], MB_NON_INTRA_VLC_BITS, 3); | |
245 | //h->c.mb_intra = (code & 0x40) ? 0 : 1; | ||
246 | 114888 | h->c.mb_intra = (~code & 0x40) >> 6; | |
247 | |||
248 | 114888 | cbp = code & 0x3f; | |
249 | } else { | ||
250 | 13158 | h->c.mb_intra = 1; | |
251 | 13158 | code = get_vlc2(&h->gb, ff_msmp4_mb_i_vlc, MSMP4_MB_INTRA_VLC_BITS, 2); | |
252 | /* predict coded block pattern */ | ||
253 | 13158 | cbp = 0; | |
254 |
2/2✓ Branch 0 taken 78948 times.
✓ Branch 1 taken 13158 times.
|
92106 | for(i=0;i<6;i++) { |
255 | 78948 | int val = ((code >> (5 - i)) & 1); | |
256 |
2/2✓ Branch 0 taken 52632 times.
✓ Branch 1 taken 26316 times.
|
78948 | if (i < 4) { |
257 | 52632 | int pred = ff_msmpeg4_coded_block_pred(&h->c, i, &coded_val); | |
258 | 52632 | val = val ^ pred; | |
259 | 52632 | *coded_val = val; | |
260 | } | ||
261 | 78948 | cbp |= val << (5 - i); | |
262 | } | ||
263 | } | ||
264 | |||
265 |
2/2✓ Branch 0 taken 109652 times.
✓ Branch 1 taken 18394 times.
|
128046 | if (!h->c.mb_intra) { |
266 | int mx, my; | ||
267 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 109652 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
109652 | if (ms->per_mb_rl_table && cbp) { |
268 | ✗ | ms->rl_table_index = decode012(&h->gb); | |
269 | ✗ | ms->rl_chroma_table_index = ms->rl_table_index; | |
270 | } | ||
271 | 109652 | ff_h263_pred_motion(&h->c, 0, 0, &mx, &my); | |
272 | 109652 | ff_msmpeg4_decode_motion(ms, &mx, &my); | |
273 | 109652 | h->c.mv_dir = MV_DIR_FORWARD; | |
274 | 109652 | h->c.mv_type = MV_TYPE_16X16; | |
275 | 109652 | h->c.mv[0][0][0] = mx; | |
276 | 109652 | h->c.mv[0][0][1] = my; | |
277 | 109652 | *mb_type_ptr = MB_TYPE_FORWARD_MV | MB_TYPE_16x16; | |
278 | } else { | ||
279 | ff_dlog(h->c.avctx, "I at %d %d %d %06X\n", h->c.mb_x, h->c.mb_y, | ||
280 | ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0), | ||
281 | show_bits(&h->gb, 24)); | ||
282 | 18394 | h->c.ac_pred = get_bits1(&h->gb); | |
283 | 18394 | *mb_type_ptr = MB_TYPE_INTRA; | |
284 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18394 times.
|
18394 | if (h->c.inter_intra_pred) { |
285 | ✗ | h->c.h263_aic_dir = get_vlc2(&h->gb, ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 1); | |
286 | ff_dlog(h->c.avctx, "%d%d %d %d/", | ||
287 | h->c.ac_pred, h->c.h263_aic_dir, h->c.mb_x, h->c.mb_y); | ||
288 | } | ||
289 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 18394 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
18394 | if (ms->per_mb_rl_table && cbp) { |
290 | ✗ | ms->rl_table_index = decode012(&h->gb); | |
291 | ✗ | ms->rl_chroma_table_index = ms->rl_table_index; | |
292 | } | ||
293 | } | ||
294 | |||
295 | 128046 | h->c.bdsp.clear_blocks(h->block[0]); | |
296 |
2/2✓ Branch 0 taken 768276 times.
✓ Branch 1 taken 128046 times.
|
896322 | for (i = 0; i < 6; i++) { |
297 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 768276 times.
|
768276 | if (ff_msmpeg4_decode_block(ms, h->block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) |
298 | { | ||
299 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", | |
300 | h->c.mb_x, h->c.mb_y, i); | ||
301 | ✗ | return -1; | |
302 | } | ||
303 | } | ||
304 | |||
305 | 128046 | return 0; | |
306 | } | ||
307 | |||
308 | /* init all vlc decoding tables */ | ||
309 | 26 | static av_cold void msmpeg4_decode_init_static(void) | |
310 | { | ||
311 | static VLCElem vlc_buf[3714 + 2694 + 1636 + 2648 + 1532 + 2488]; | ||
312 | 26 | VLCInitState state = VLC_INIT_STATE(vlc_buf); | |
313 | |||
314 | 26 | INIT_FIRST_VLC_RL(ff_rl_table[0], 642); | |
315 | 26 | INIT_FIRST_VLC_RL(ff_rl_table[1], 1104); | |
316 | 26 | INIT_FIRST_VLC_RL(ff_rl_table[2], 554); | |
317 |
2/2✓ Branch 0 taken 832 times.
✓ Branch 1 taken 26 times.
|
858 | VLC_INIT_RL(ff_rl_table[3], 940); |
318 |
2/2✓ Branch 0 taken 832 times.
✓ Branch 1 taken 26 times.
|
858 | VLC_INIT_RL(ff_rl_table[4], 962); |
319 | /* ff_rl_table[5] coincides with ff_h263_rl_inter which has just been | ||
320 | * initialized in ff_h263_decode_init() earlier. So just copy the VLCs. */ | ||
321 | av_assert1(ff_h263_rl_inter.rl_vlc[0]); | ||
322 | 26 | memcpy(ff_rl_table[5].rl_vlc, ff_h263_rl_inter.rl_vlc, sizeof(ff_rl_table[5].rl_vlc)); | |
323 | |||
324 | 26 | VLC_INIT_STATIC_TABLE(v2_dc_lum_vlc, MSMP4_DC_VLC_BITS, 512, | |
325 | &ff_v2_dc_lum_table[0][1], 8, 4, | ||
326 | &ff_v2_dc_lum_table[0][0], 8, 4, 0); | ||
327 | 26 | VLC_INIT_STATIC_TABLE(v2_dc_chroma_vlc, MSMP4_DC_VLC_BITS, 512, | |
328 | &ff_v2_dc_chroma_table[0][1], 8, 4, | ||
329 | &ff_v2_dc_chroma_table[0][0], 8, 4, 0); | ||
330 | |||
331 | 26 | VLC_INIT_STATIC_TABLE(v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4, | |
332 | &ff_v2_intra_cbpc[0][1], 2, 1, | ||
333 | &ff_v2_intra_cbpc[0][0], 2, 1, 0); | ||
334 | 26 | VLC_INIT_STATIC_TABLE(v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8, | |
335 | &ff_v2_mb_type[0][1], 2, 1, | ||
336 | &ff_v2_mb_type[0][0], 2, 1, 0); | ||
337 | |||
338 | 26 | mv_tables[0] = ff_vlc_init_tables_from_lengths(&state, MV_VLC_BITS, | |
339 | MSMPEG4_MV_TABLES_NB_ELEMS, | ||
340 | ff_msmp4_mv_table0_lens, 1, | ||
341 | ff_msmp4_mv_table0, 2, 2, | ||
342 | 0, 0); | ||
343 | 26 | mv_tables[1] = ff_vlc_init_tables_from_lengths(&state, MV_VLC_BITS, | |
344 | MSMPEG4_MV_TABLES_NB_ELEMS, | ||
345 | ff_msmp4_mv_table1_lens, 1, | ||
346 | ff_msmp4_mv_table1, 2, 2, | ||
347 | 0, 0); | ||
348 | |||
349 |
2/2✓ Branch 0 taken 104 times.
✓ Branch 1 taken 26 times.
|
130 | for (unsigned i = 0; i < 4; i++) { |
350 | 104 | ff_mb_non_intra_vlc[i] = | |
351 | 104 | ff_vlc_init_tables_sparse(&state, MB_NON_INTRA_VLC_BITS, 128, | |
352 | 104 | &ff_wmv2_inter_table[i][0][1], 8, 4, | |
353 | 104 | &ff_wmv2_inter_table[i][0][0], 8, 4, | |
354 | NULL, 0, 0, 0); | ||
355 | } | ||
356 | |||
357 | 26 | VLC_INIT_STATIC_TABLE(ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4, | |
358 | &ff_table_inter_intra[0][1], 2, 1, | ||
359 | &ff_table_inter_intra[0][0], 2, 1, 0); | ||
360 | 26 | ff_msmp4_vc1_vlcs_init_once(); | |
361 | 26 | } | |
362 | |||
363 | 675 | static int msmpeg4_decode_picture_header(H263DecContext *const h) | |
364 | { | ||
365 | 675 | MSMP4DecContext *const ms = mpv_to_msmpeg4(h); | |
366 | int code; | ||
367 | |||
368 | // at minimum one bit per macroblock is required at least in a valid frame, | ||
369 | // we discard frames much smaller than this. Frames smaller than 1/8 of the | ||
370 | // smallest "black/skip" frame generally contain not much recoverable content | ||
371 | // while at the same time they have the highest computational requirements | ||
372 | // per byte | ||
373 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 675 times.
|
675 | if (get_bits_left(&h->gb) * 8LL < (h->c.width+15)/16 * ((h->c.height+15)/16)) |
374 | ✗ | return AVERROR_INVALIDDATA; | |
375 | |||
376 |
2/2✓ Branch 0 taken 50 times.
✓ Branch 1 taken 625 times.
|
675 | if (h->c.msmpeg4_version == MSMP4_V1) { |
377 | 50 | int start_code = get_bits_long(&h->gb, 32); | |
378 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
|
50 | if(start_code!=0x00000100){ |
379 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "invalid startcode\n"); | |
380 | ✗ | return -1; | |
381 | } | ||
382 | |||
383 | 50 | skip_bits(&h->gb, 5); // frame number */ | |
384 | } | ||
385 | |||
386 | 675 | h->c.pict_type = get_bits(&h->gb, 2) + 1; | |
387 |
2/2✓ Branch 0 taken 611 times.
✓ Branch 1 taken 64 times.
|
675 | if (h->c.pict_type != AV_PICTURE_TYPE_I && |
388 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 611 times.
|
611 | h->c.pict_type != AV_PICTURE_TYPE_P){ |
389 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "invalid picture type\n"); | |
390 | ✗ | return -1; | |
391 | } | ||
392 | 675 | h->c.chroma_qscale = h->c.qscale = get_bits(&h->gb, 5); | |
393 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 675 times.
|
675 | if (h->c.qscale == 0) { |
394 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "invalid qscale\n"); | |
395 | ✗ | return -1; | |
396 | } | ||
397 | |||
398 |
2/2✓ Branch 0 taken 64 times.
✓ Branch 1 taken 611 times.
|
675 | if (h->c.pict_type == AV_PICTURE_TYPE_I) { |
399 | 64 | code = get_bits(&h->gb, 5); | |
400 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 63 times.
|
64 | if (h->c.msmpeg4_version == MSMP4_V1) { |
401 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
|
1 | if(code==0 || code>h->c.mb_height) { |
402 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "invalid slice height %d\n", code); | |
403 | ✗ | return -1; | |
404 | } | ||
405 | |||
406 | 1 | h->slice_height = code; | |
407 | }else{ | ||
408 | /* 0x17: one slice, 0x18: two slices, ... */ | ||
409 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 63 times.
|
63 | if (code < 0x17){ |
410 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "error, slice code was %X\n", code); | |
411 | ✗ | return -1; | |
412 | } | ||
413 | |||
414 | 63 | h->slice_height = h->c.mb_height / (code - 0x16); | |
415 | } | ||
416 | |||
417 |
3/4✓ Branch 0 taken 21 times.
✓ Branch 1 taken 23 times.
✓ Branch 2 taken 20 times.
✗ Branch 3 not taken.
|
64 | switch (h->c.msmpeg4_version) { |
418 | 21 | case MSMP4_V1: | |
419 | case MSMP4_V2: | ||
420 | 21 | ms->rl_chroma_table_index = 2; | |
421 | 21 | ms->rl_table_index = 2; | |
422 | |||
423 | 21 | ms->dc_table_index = 0; //not used | |
424 | 21 | break; | |
425 | 23 | case MSMP4_V3: | |
426 | 23 | ms->rl_chroma_table_index = decode012(&h->gb); | |
427 | 23 | ms->rl_table_index = decode012(&h->gb); | |
428 | |||
429 | 23 | ms->dc_table_index = get_bits1(&h->gb); | |
430 | 23 | break; | |
431 | 20 | case MSMP4_WMV1: | |
432 | 20 | ff_msmpeg4_decode_ext_header(h, (2+5+5+17+7)/8); | |
433 | |||
434 |
1/2✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.
|
20 | if (ms->bit_rate > MBAC_BITRATE) |
435 | 20 | ms->per_mb_rl_table = get_bits1(&h->gb); | |
436 | else | ||
437 | ✗ | ms->per_mb_rl_table = 0; | |
438 | |||
439 |
1/2✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.
|
20 | if (!ms->per_mb_rl_table) { |
440 | 20 | ms->rl_chroma_table_index = decode012(&h->gb); | |
441 | 20 | ms->rl_table_index = decode012(&h->gb); | |
442 | } | ||
443 | |||
444 | 20 | ms->dc_table_index = get_bits1(&h->gb); | |
445 | 20 | h->c.inter_intra_pred= 0; | |
446 | 20 | break; | |
447 | ✗ | default: | |
448 | ✗ | av_unreachable("msmpeg4_decode_picture_header() only used by MSMP4V1-3, WMV1"); | |
449 | } | ||
450 | 64 | h->c.no_rounding = 1; | |
451 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 64 times.
|
64 | if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) |
452 | ✗ | av_log(h->c.avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n", | |
453 | h->c.qscale, | ||
454 | ms->rl_chroma_table_index, | ||
455 | ms->rl_table_index, | ||
456 | ms->dc_table_index, | ||
457 | ms->per_mb_rl_table, | ||
458 | h->slice_height); | ||
459 | } else { | ||
460 |
3/4✓ Branch 0 taken 229 times.
✓ Branch 1 taken 202 times.
✓ Branch 2 taken 180 times.
✗ Branch 3 not taken.
|
611 | switch (h->c.msmpeg4_version) { |
461 | 229 | case MSMP4_V1: | |
462 | case MSMP4_V2: | ||
463 |
2/2✓ Branch 0 taken 49 times.
✓ Branch 1 taken 180 times.
|
229 | if (h->c.msmpeg4_version == MSMP4_V1) |
464 | 49 | ms->use_skip_mb_code = 1; | |
465 | else | ||
466 | 180 | ms->use_skip_mb_code = get_bits1(&h->gb); | |
467 | 229 | ms->rl_table_index = 2; | |
468 | 229 | ms->rl_chroma_table_index = ms->rl_table_index; | |
469 | 229 | ms->dc_table_index = 0; //not used | |
470 | 229 | ms->mv_table_index = 0; | |
471 | 229 | break; | |
472 | 202 | case MSMP4_V3: | |
473 | 202 | ms->use_skip_mb_code = get_bits1(&h->gb); | |
474 | 202 | ms->rl_table_index = decode012(&h->gb); | |
475 | 202 | ms->rl_chroma_table_index = ms->rl_table_index; | |
476 | |||
477 | 202 | ms->dc_table_index = get_bits1(&h->gb); | |
478 | |||
479 | 202 | ms->mv_table_index = get_bits1(&h->gb); | |
480 | 202 | break; | |
481 | 180 | case MSMP4_WMV1: | |
482 | 180 | ms->use_skip_mb_code = get_bits1(&h->gb); | |
483 | |||
484 |
1/2✓ Branch 0 taken 180 times.
✗ Branch 1 not taken.
|
180 | if (ms->bit_rate > MBAC_BITRATE) |
485 | 180 | ms->per_mb_rl_table = get_bits1(&h->gb); | |
486 | else | ||
487 | ✗ | ms->per_mb_rl_table = 0; | |
488 | |||
489 |
1/2✓ Branch 0 taken 180 times.
✗ Branch 1 not taken.
|
180 | if (!ms->per_mb_rl_table) { |
490 | 180 | ms->rl_table_index = decode012(&h->gb); | |
491 | 180 | ms->rl_chroma_table_index = ms->rl_table_index; | |
492 | } | ||
493 | |||
494 | 180 | ms->dc_table_index = get_bits1(&h->gb); | |
495 | |||
496 | 180 | ms->mv_table_index = get_bits1(&h->gb); | |
497 |
2/2✓ Branch 0 taken 45 times.
✓ Branch 1 taken 135 times.
|
225 | h->c.inter_intra_pred = h->c.width*h->c.height < 320*240 && |
498 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 45 times.
|
45 | ms->bit_rate <= II_BITRATE; |
499 | 180 | break; | |
500 | ✗ | default: | |
501 | ✗ | av_unreachable("msmpeg4_decode_picture_header() only used by MSMP4V1-3, WMV1"); | |
502 | } | ||
503 | |||
504 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 611 times.
|
611 | if (h->c.avctx->debug&FF_DEBUG_PICT_INFO) |
505 | ✗ | av_log(h->c.avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n", | |
506 | ms->use_skip_mb_code, | ||
507 | ms->rl_table_index, | ||
508 | ms->rl_chroma_table_index, | ||
509 | ms->dc_table_index, | ||
510 | ms->mv_table_index, | ||
511 | ms->per_mb_rl_table, | ||
512 | h->c.qscale); | ||
513 | |||
514 |
2/2✓ Branch 0 taken 382 times.
✓ Branch 1 taken 229 times.
|
611 | if (ms->flipflop_rounding) { |
515 | 382 | h->c.no_rounding ^= 1; | |
516 | }else{ | ||
517 | 229 | h->c.no_rounding = 0; | |
518 | } | ||
519 | } | ||
520 | ff_dlog(h->c.avctx, "%d %d %d %d %d\n", h->c.pict_type, ms->bit_rate, | ||
521 | h->c.inter_intra_pred, h->c.width, h->c.height); | ||
522 | |||
523 | 675 | ms->esc3_level_length = 0; | |
524 | 675 | ms->esc3_run_length = 0; | |
525 | |||
526 | 675 | return 0; | |
527 | } | ||
528 | |||
529 | 64 | int ff_msmpeg4_decode_ext_header(H263DecContext *const h, int buf_size) | |
530 | { | ||
531 | 64 | MSMP4DecContext *const ms = mpv_to_msmpeg4(h); | |
532 | 64 | int left = buf_size*8 - get_bits_count(&h->gb); | |
533 |
2/2✓ Branch 0 taken 43 times.
✓ Branch 1 taken 21 times.
|
64 | int length = h->c.msmpeg4_version >= MSMP4_V3 ? 17 : 16; |
534 | /* the alt_bitstream reader could read over the end so we need to check it */ | ||
535 |
3/4✓ Branch 0 taken 63 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 63 times.
✗ Branch 3 not taken.
|
64 | if(left>=length && left<length+8) |
536 | { | ||
537 | 63 | skip_bits(&h->gb, 5); /* fps */ | |
538 | 63 | ms->bit_rate = get_bits(&h->gb, 11) * 1024; | |
539 |
2/2✓ Branch 0 taken 43 times.
✓ Branch 1 taken 20 times.
|
63 | if (h->c.msmpeg4_version >= MSMP4_V3) |
540 | 43 | ms->flipflop_rounding = get_bits1(&h->gb); | |
541 | else | ||
542 | 20 | ms->flipflop_rounding = 0; | |
543 | } | ||
544 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | else if(left<length+8) |
545 | { | ||
546 | 1 | ms->flipflop_rounding = 0; | |
547 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (h->c.msmpeg4_version != MSMP4_V2) |
548 | 1 | av_log(h->c.avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left); | |
549 | } | ||
550 | else | ||
551 | { | ||
552 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n"); | |
553 | } | ||
554 | |||
555 | 64 | return 0; | |
556 | } | ||
557 | |||
558 | 230712 | static int msmpeg4_decode_dc(MSMP4DecContext *const ms, int n, int *dir_ptr) | |
559 | { | ||
560 | 230712 | H263DecContext *const h = &ms->h; | |
561 | int level, pred; | ||
562 | |||
563 |
2/2✓ Branch 0 taken 54342 times.
✓ Branch 1 taken 176370 times.
|
230712 | if (h->c.msmpeg4_version <= MSMP4_V2) { |
564 |
2/2✓ Branch 0 taken 36228 times.
✓ Branch 1 taken 18114 times.
|
54342 | if (n < 4) { |
565 | 36228 | level = get_vlc2(&h->gb, v2_dc_lum_vlc, MSMP4_DC_VLC_BITS, 3); | |
566 | } else { | ||
567 | 18114 | level = get_vlc2(&h->gb, v2_dc_chroma_vlc, MSMP4_DC_VLC_BITS, 3); | |
568 | } | ||
569 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 54342 times.
|
54342 | if (level < 0) { |
570 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc vlc\n"); | |
571 | ✗ | *dir_ptr = 0; | |
572 | ✗ | return -1; | |
573 | } | ||
574 | 54342 | level-=256; | |
575 | } else { | ||
576 | 176370 | level = get_vlc2(&h->gb, ff_msmp4_dc_vlc[ms->dc_table_index][n >= 4], | |
577 | MSMP4_DC_VLC_BITS, 3); | ||
578 | |||
579 |
2/2✓ Branch 0 taken 48 times.
✓ Branch 1 taken 176322 times.
|
176370 | if (level == DC_MAX) { |
580 | 48 | level = get_bits(&h->gb, 8); | |
581 |
2/2✓ Branch 1 taken 6 times.
✓ Branch 2 taken 42 times.
|
48 | if (get_bits1(&h->gb)) |
582 | 6 | level = -level; | |
583 |
2/2✓ Branch 0 taken 153813 times.
✓ Branch 1 taken 22509 times.
|
176322 | } else if (level != 0) { |
584 |
2/2✓ Branch 1 taken 74512 times.
✓ Branch 2 taken 79301 times.
|
153813 | if (get_bits1(&h->gb)) |
585 | 74512 | level = -level; | |
586 | } | ||
587 | } | ||
588 | |||
589 |
2/2✓ Branch 0 taken 5490 times.
✓ Branch 1 taken 225222 times.
|
230712 | if (h->c.msmpeg4_version == MSMP4_V1) { |
590 | int32_t *dc_val; | ||
591 | 5490 | pred = msmpeg4v1_pred_dc(&h->c, n, &dc_val); | |
592 | 5490 | level += pred; | |
593 | |||
594 | /* update predictor */ | ||
595 | 5490 | *dc_val= level; | |
596 | }else{ | ||
597 | int16_t *dc_val; | ||
598 | 225222 | pred = ff_msmpeg4_pred_dc(&h->c, n, &dc_val, dir_ptr); | |
599 | 225222 | level += pred; | |
600 | |||
601 | /* update predictor */ | ||
602 |
2/2✓ Branch 0 taken 150148 times.
✓ Branch 1 taken 75074 times.
|
225222 | if (n < 4) { |
603 | 150148 | *dc_val = level * h->c.y_dc_scale; | |
604 | } else { | ||
605 | 75074 | *dc_val = level * h->c.c_dc_scale; | |
606 | } | ||
607 | } | ||
608 | |||
609 | 230712 | return level; | |
610 | } | ||
611 | |||
612 | 1472610 | int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block, | |
613 | int n, int coded, const uint8_t *scan_table) | ||
614 | { | ||
615 | 1472610 | H263DecContext *const h = &ms->h; | |
616 | int level, i, last, run, run_diff; | ||
617 | 1472610 | int dc_pred_dir = -1; //unused but its passed around, so it needs to be initialized | |
618 | const RLTable *rl; | ||
619 | const RL_VLC_ELEM *rl_vlc; | ||
620 | int qmul, qadd; | ||
621 | |||
622 |
2/2✓ Branch 0 taken 230712 times.
✓ Branch 1 taken 1241898 times.
|
1472610 | if (h->c.mb_intra) { |
623 | 230712 | qmul=1; | |
624 | 230712 | qadd=0; | |
625 | |||
626 | /* DC coef */ | ||
627 | 230712 | level = msmpeg4_decode_dc(ms, n, &dc_pred_dir); | |
628 | |||
629 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 230712 times.
|
230712 | if (level < 0){ |
630 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, h->c.qscale); | |
631 | ✗ | if (h->c.inter_intra_pred) | |
632 | ✗ | level = 0; | |
633 | } | ||
634 |
2/2✓ Branch 0 taken 153808 times.
✓ Branch 1 taken 76904 times.
|
230712 | if (n < 4) { |
635 | 153808 | rl = &ff_rl_table[ms->rl_table_index]; | |
636 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 153808 times.
|
153808 | if (level > 256 * h->c.y_dc_scale) { |
637 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", h->c.qscale); | |
638 | ✗ | if (!h->c.inter_intra_pred) | |
639 | ✗ | return -1; | |
640 | } | ||
641 | } else { | ||
642 | 76904 | rl = &ff_rl_table[3 + ms->rl_chroma_table_index]; | |
643 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 76904 times.
|
76904 | if (level > 256 * h->c.c_dc_scale) { |
644 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", h->c.qscale); | |
645 | ✗ | if (!h->c.inter_intra_pred) | |
646 | ✗ | return -1; | |
647 | } | ||
648 | } | ||
649 | 230712 | block[0] = level; | |
650 | |||
651 | 230712 | run_diff = h->c.msmpeg4_version >= MSMP4_WMV1; | |
652 | 230712 | i = 0; | |
653 |
2/2✓ Branch 0 taken 42456 times.
✓ Branch 1 taken 188256 times.
|
230712 | if (!coded) { |
654 | 42456 | goto not_coded; | |
655 | } | ||
656 |
2/2✓ Branch 0 taken 3224 times.
✓ Branch 1 taken 185032 times.
|
188256 | if (h->c.ac_pred) { |
657 |
2/2✓ Branch 0 taken 1928 times.
✓ Branch 1 taken 1296 times.
|
3224 | if (dc_pred_dir == 0) |
658 | 1928 | scan_table = h->c.permutated_intra_v_scantable; /* left */ | |
659 | else | ||
660 | 1296 | scan_table = h->c.permutated_intra_h_scantable; /* top */ | |
661 | } else { | ||
662 | 185032 | scan_table = h->c.intra_scantable.permutated; | |
663 | } | ||
664 | 188256 | rl_vlc= rl->rl_vlc[0]; | |
665 | } else { | ||
666 | 1241898 | qmul = h->c.qscale << 1; | |
667 | 1241898 | qadd = (h->c.qscale - 1) | 1; | |
668 | 1241898 | i = -1; | |
669 | 1241898 | rl = &ff_rl_table[3 + ms->rl_table_index]; | |
670 | |||
671 |
2/2✓ Branch 0 taken 306018 times.
✓ Branch 1 taken 935880 times.
|
1241898 | if (h->c.msmpeg4_version == MSMP4_V2) |
672 | 306018 | run_diff = 0; | |
673 | else | ||
674 | 935880 | run_diff = 1; | |
675 | |||
676 |
2/2✓ Branch 0 taken 633723 times.
✓ Branch 1 taken 608175 times.
|
1241898 | if (!coded) { |
677 | 633723 | h->c.block_last_index[n] = i; | |
678 | 633723 | return 0; | |
679 | } | ||
680 |
2/2✓ Branch 0 taken 420993 times.
✓ Branch 1 taken 187182 times.
|
608175 | if(!scan_table) |
681 | 420993 | scan_table = h->c.inter_scantable.permutated; | |
682 | 608175 | rl_vlc= rl->rl_vlc[h->c.qscale]; | |
683 | } | ||
684 | { | ||
685 | 796431 | OPEN_READER(re, &h->gb); | |
686 | for(;;) { | ||
687 | 9175903 | UPDATE_CACHE(re, &h->gb); | |
688 |
2/2✓ Branch 1 taken 297834 times.
✓ Branch 2 taken 4688333 times.
|
4986167 | GET_RL_VLC(level, run, re, &h->gb, rl_vlc, TEX_VLC_BITS, 2, 0); |
689 |
2/2✓ Branch 0 taken 162066 times.
✓ Branch 1 taken 4824101 times.
|
4986167 | if (level==0) { |
690 | int cache; | ||
691 | 162066 | cache= GET_CACHE(re, &h->gb); | |
692 | /* escape */ | ||
693 |
4/4✓ Branch 0 taken 140175 times.
✓ Branch 1 taken 21891 times.
✓ Branch 2 taken 74501 times.
✓ Branch 3 taken 65674 times.
|
162066 | if (h->c.msmpeg4_version == MSMP4_V1 || (cache&0x80000000)==0) { |
694 |
4/4✓ Branch 0 taken 74501 times.
✓ Branch 1 taken 21891 times.
✓ Branch 2 taken 19659 times.
✓ Branch 3 taken 54842 times.
|
96392 | if (h->c.msmpeg4_version == MSMP4_V1 || (cache&0x40000000)==0) { |
695 | /* third escape */ | ||
696 |
2/2✓ Branch 0 taken 19659 times.
✓ Branch 1 taken 21891 times.
|
41550 | if (h->c.msmpeg4_version != MSMP4_V1) |
697 | 19659 | LAST_SKIP_BITS(re, &h->gb, 2); | |
698 | 41550 | UPDATE_CACHE(re, &h->gb); | |
699 |
2/2✓ Branch 0 taken 34734 times.
✓ Branch 1 taken 6816 times.
|
41550 | if (h->c.msmpeg4_version <= MSMP4_V3) { |
700 | 34734 | last = SHOW_UBITS(re, &h->gb, 1); SKIP_CACHE(re, &h->gb, 1); | |
701 | 34734 | run = SHOW_UBITS(re, &h->gb, 6); SKIP_CACHE(re, &h->gb, 6); | |
702 | 34734 | level = SHOW_SBITS(re, &h->gb, 8); | |
703 | 34734 | SKIP_COUNTER(re, &h->gb, 1 + 6 + 8); | |
704 | }else{ | ||
705 | int sign; | ||
706 | 6816 | last = SHOW_UBITS(re, &h->gb, 1); SKIP_BITS(re, &h->gb, 1); | |
707 |
2/2✓ Branch 0 taken 384 times.
✓ Branch 1 taken 6432 times.
|
6816 | if (!ms->esc3_level_length) { |
708 | int ll; | ||
709 | ff_dlog(h->c.avctx, "ESC-3 %X at %d %d\n", | ||
710 | show_bits(&h->gb, 24), h->c.mb_x, h->c.mb_y); | ||
711 |
2/2✓ Branch 0 taken 78 times.
✓ Branch 1 taken 306 times.
|
384 | if (h->c.qscale < 8) { |
712 | 78 | ll = SHOW_UBITS(re, &h->gb, 3); SKIP_BITS(re, &h->gb, 3); | |
713 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 78 times.
|
78 | if(ll==0){ |
714 | ✗ | ll = 8+SHOW_UBITS(re, &h->gb, 1); SKIP_BITS(re, &h->gb, 1); | |
715 | } | ||
716 | }else{ | ||
717 | 306 | ll=2; | |
718 |
4/4✓ Branch 0 taken 1734 times.
✓ Branch 1 taken 280 times.
✓ Branch 3 taken 1708 times.
✓ Branch 4 taken 26 times.
|
2014 | while (ll < 8 && SHOW_UBITS(re, &h->gb, 1) == 0) { |
719 | 1708 | ll++; | |
720 | 1708 | SKIP_BITS(re, &h->gb, 1); | |
721 | } | ||
722 |
2/2✓ Branch 0 taken 26 times.
✓ Branch 1 taken 280 times.
|
306 | if (ll<8) SKIP_BITS(re, &h->gb, 1); |
723 | } | ||
724 | |||
725 | 384 | ms->esc3_level_length = ll; | |
726 | 384 | ms->esc3_run_length = SHOW_UBITS(re, &h->gb, 2) + 3; SKIP_BITS(re, &h->gb, 2); | |
727 | 384 | UPDATE_CACHE(re, &h->gb); | |
728 | } | ||
729 | 6816 | run = SHOW_UBITS(re, &h->gb, ms->esc3_run_length); | |
730 | 6816 | SKIP_BITS(re, &h->gb, ms->esc3_run_length); | |
731 | |||
732 | 6816 | sign= SHOW_UBITS(re, &h->gb, 1); | |
733 | 6816 | SKIP_BITS(re, &h->gb, 1); | |
734 | |||
735 | 6816 | level = SHOW_UBITS(re, &h->gb, ms->esc3_level_length); | |
736 | 6816 | SKIP_BITS(re, &h->gb, ms->esc3_level_length); | |
737 |
2/2✓ Branch 0 taken 3395 times.
✓ Branch 1 taken 3421 times.
|
6816 | if(sign) level= -level; |
738 | } | ||
739 | |||
740 | //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ; | ||
741 |
2/2✓ Branch 0 taken 20943 times.
✓ Branch 1 taken 20607 times.
|
41550 | if (level>0) level= level * qmul + qadd; |
742 | 20607 | else level= level * qmul - qadd; | |
743 | 41550 | i+= run + 1; | |
744 |
2/2✓ Branch 0 taken 18888 times.
✓ Branch 1 taken 22662 times.
|
41550 | if(last) i+=192; |
745 | } else { | ||
746 | /* second escape */ | ||
747 | 54842 | SKIP_BITS(re, &h->gb, 2); | |
748 |
2/2✓ Branch 1 taken 7490 times.
✓ Branch 2 taken 47352 times.
|
54842 | GET_RL_VLC(level, run, re, &h->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
749 | 54842 | i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing | |
750 | 54842 | level = (level ^ SHOW_SBITS(re, &h->gb, 1)) - SHOW_SBITS(re, &h->gb, 1); | |
751 | 54842 | LAST_SKIP_BITS(re, &h->gb, 1); | |
752 | } | ||
753 | } else { | ||
754 | /* first escape */ | ||
755 | 65674 | SKIP_BITS(re, &h->gb, 1); | |
756 |
2/2✓ Branch 1 taken 8895 times.
✓ Branch 2 taken 56779 times.
|
65674 | GET_RL_VLC(level, run, re, &h->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
757 | 65674 | i+= run; | |
758 | 65674 | level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
759 | 65674 | level = (level ^ SHOW_SBITS(re, &h->gb, 1)) - SHOW_SBITS(re, &h->gb, 1); | |
760 | 65674 | LAST_SKIP_BITS(re, &h->gb, 1); | |
761 | } | ||
762 | } else { | ||
763 | 4824101 | i+= run; | |
764 | 4824101 | level = (level ^ SHOW_SBITS(re, &h->gb, 1)) - SHOW_SBITS(re, &h->gb, 1); | |
765 | 4824101 | LAST_SKIP_BITS(re, &h->gb, 1); | |
766 | } | ||
767 |
2/2✓ Branch 0 taken 796431 times.
✓ Branch 1 taken 4189736 times.
|
4986167 | if (i > 62){ |
768 | 796431 | i-= 192; | |
769 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 796431 times.
|
796431 | if(i&(~63)){ |
770 | ✗ | const int left = get_bits_left(&h->gb); | |
771 | ✗ | if (((i + 192 == 64 && level / qmul == -1) || | |
772 | ✗ | !(h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && | |
773 | left >= 0) { | ||
774 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", | |
775 | h->c.mb_x, h->c.mb_y); | ||
776 | ✗ | i = 63; | |
777 | ✗ | break; | |
778 | }else{ | ||
779 | ✗ | av_log(h->c.avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", | |
780 | h->c.mb_x, h->c.mb_y); | ||
781 | ✗ | return -1; | |
782 | } | ||
783 | } | ||
784 | |||
785 | 796431 | block[scan_table[i]] = level; | |
786 | 796431 | break; | |
787 | } | ||
788 | |||
789 | 4189736 | block[scan_table[i]] = level; | |
790 | } | ||
791 | 796431 | CLOSE_READER(re, &h->gb); | |
792 | } | ||
793 |
2/2✓ Branch 0 taken 188256 times.
✓ Branch 1 taken 608175 times.
|
796431 | if (h->c.mb_intra) { |
794 | 188256 | not_coded: | |
795 | 230712 | ff_mpeg4_pred_ac(h, block, n, dc_pred_dir); | |
796 | } | ||
797 | 838887 | h->c.block_last_index[n] = i; | |
798 | |||
799 | 838887 | return 0; | |
800 | } | ||
801 | |||
802 | 228076 | void ff_msmpeg4_decode_motion(MSMP4DecContext *const ms, int *mx_ptr, int *my_ptr) | |
803 | { | ||
804 | 228076 | const VLCElem *const mv_vlc = mv_tables[ms->mv_table_index]; | |
805 | 228076 | H263DecContext *const h = &ms->h; | |
806 | int sym, mx, my; | ||
807 | |||
808 | 228076 | sym = get_vlc2(&h->gb, mv_vlc, MV_VLC_BITS, 2); | |
809 |
2/2✓ Branch 0 taken 226220 times.
✓ Branch 1 taken 1856 times.
|
228076 | if (sym) { |
810 | 226220 | mx = sym >> 8; | |
811 | 226220 | my = sym & 0xFF; | |
812 | } else { | ||
813 | /* Escape */ | ||
814 | 1856 | mx = get_bits(&h->gb, 6); | |
815 | 1856 | my = get_bits(&h->gb, 6); | |
816 | } | ||
817 | |||
818 | 228076 | mx += *mx_ptr - 32; | |
819 | 228076 | my += *my_ptr - 32; | |
820 | /* WARNING : they do not do exactly modulo encoding */ | ||
821 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 228054 times.
|
228076 | if (mx <= -64) |
822 | 22 | mx += 64; | |
823 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 228044 times.
|
228054 | else if (mx >= 64) |
824 | 10 | mx -= 64; | |
825 | |||
826 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 228070 times.
|
228076 | if (my <= -64) |
827 | 6 | my += 64; | |
828 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 228066 times.
|
228070 | else if (my >= 64) |
829 | 4 | my -= 64; | |
830 | 228076 | *mx_ptr = mx; | |
831 | 228076 | *my_ptr = my; | |
832 | 228076 | } | |
833 | |||
834 | 45 | av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx) | |
835 | { | ||
836 | static AVOnce init_static_once = AV_ONCE_INIT; | ||
837 | 45 | H263DecContext *const h = avctx->priv_data; | |
838 | int ret; | ||
839 | |||
840 | 45 | ret = av_image_check_size(avctx->width, avctx->height, 0, avctx); | |
841 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 45 times.
|
45 | if (ret < 0) |
842 | ✗ | return ret; | |
843 | |||
844 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 45 times.
|
45 | if (ff_h263_decode_init(avctx) < 0) |
845 | ✗ | return -1; | |
846 | |||
847 | // We unquantize inter blocks as we parse them. | ||
848 | 45 | h->c.dct_unquantize_inter = NULL; | |
849 | |||
850 | 45 | h->decode_header = msmpeg4_decode_picture_header; | |
851 | |||
852 | 45 | ff_msmpeg4_common_init(&h->c); | |
853 | |||
854 |
3/4✓ Branch 0 taken 11 times.
✓ Branch 1 taken 22 times.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
|
45 | switch (h->c.msmpeg4_version) { |
855 | 11 | case MSMP4_V1: | |
856 | case MSMP4_V2: | ||
857 | 11 | h->decode_mb = msmpeg4v12_decode_mb; | |
858 | 11 | break; | |
859 | 22 | case MSMP4_V3: | |
860 | case MSMP4_WMV1: | ||
861 | 22 | h->decode_mb = msmpeg4v34_decode_mb; | |
862 | 22 | break; | |
863 | 12 | case MSMP4_WMV2: | |
864 | 12 | break; | |
865 | ✗ | default: | |
866 | ✗ | av_unreachable("List contains all cases using ff_msmpeg4_decode_init()"); | |
867 | } | ||
868 | |||
869 | 45 | h->slice_height = h->c.mb_height; //to avoid 1/0 if the first frame is not a keyframe | |
870 | |||
871 | 45 | ff_thread_once(&init_static_once, msmpeg4_decode_init_static); | |
872 | |||
873 | 45 | return 0; | |
874 | } | ||
875 | |||
876 | const FFCodec ff_msmpeg4v1_decoder = { | ||
877 | .p.name = "msmpeg4v1", | ||
878 | CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 1"), | ||
879 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
880 | .p.id = AV_CODEC_ID_MSMPEG4V1, | ||
881 | .priv_data_size = sizeof(MSMP4DecContext), | ||
882 | .init = ff_msmpeg4_decode_init, | ||
883 | FF_CODEC_DECODE_CB(ff_h263_decode_frame), | ||
884 | .close = ff_mpv_decode_close, | ||
885 | .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1, | ||
886 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | | ||
887 | FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, | ||
888 | .p.max_lowres = 3, | ||
889 | }; | ||
890 | |||
891 | const FFCodec ff_msmpeg4v2_decoder = { | ||
892 | .p.name = "msmpeg4v2", | ||
893 | CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 2"), | ||
894 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
895 | .p.id = AV_CODEC_ID_MSMPEG4V2, | ||
896 | .priv_data_size = sizeof(MSMP4DecContext), | ||
897 | .init = ff_msmpeg4_decode_init, | ||
898 | FF_CODEC_DECODE_CB(ff_h263_decode_frame), | ||
899 | .close = ff_mpv_decode_close, | ||
900 | .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1, | ||
901 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | | ||
902 | FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, | ||
903 | .p.max_lowres = 3, | ||
904 | }; | ||
905 | |||
906 | const FFCodec ff_msmpeg4v3_decoder = { | ||
907 | .p.name = "msmpeg4", | ||
908 | CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 3"), | ||
909 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
910 | .p.id = AV_CODEC_ID_MSMPEG4V3, | ||
911 | .priv_data_size = sizeof(MSMP4DecContext), | ||
912 | .init = ff_msmpeg4_decode_init, | ||
913 | FF_CODEC_DECODE_CB(ff_h263_decode_frame), | ||
914 | .close = ff_mpv_decode_close, | ||
915 | .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1, | ||
916 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | | ||
917 | FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, | ||
918 | .p.max_lowres = 3, | ||
919 | }; | ||
920 | |||
921 | const FFCodec ff_wmv1_decoder = { | ||
922 | .p.name = "wmv1", | ||
923 | CODEC_LONG_NAME("Windows Media Video 7"), | ||
924 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
925 | .p.id = AV_CODEC_ID_WMV1, | ||
926 | .priv_data_size = sizeof(MSMP4DecContext), | ||
927 | .init = ff_msmpeg4_decode_init, | ||
928 | FF_CODEC_DECODE_CB(ff_h263_decode_frame), | ||
929 | .close = ff_mpv_decode_close, | ||
930 | .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1, | ||
931 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | | ||
932 | FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, | ||
933 | .p.max_lowres = 3, | ||
934 | }; | ||
935 |