Mercurial > libavcodec.hg
annotate msmpeg4.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | 81a9f883a17a |
children | 0d88e3f89379 |
rev | line source |
---|---|
0 | 1 /* |
2 * MSMPEG4 backend for ffmpeg encoder and decoder | |
429 | 3 * Copyright (c) 2001 Fabrice Bellard. |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1651
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 5 * |
429 | 6 * This library is free software; you can redistribute it and/or |
7 * modify it under the terms of the GNU Lesser General Public | |
8 * License as published by the Free Software Foundation; either | |
9 * version 2 of the License, or (at your option) any later version. | |
0 | 10 * |
429 | 11 * This library is distributed in the hope that it will be useful, |
0 | 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 * Lesser General Public License for more details. | |
0 | 15 * |
429 | 16 * You should have received a copy of the GNU Lesser General Public |
17 * License along with this library; if not, write to the Free Software | |
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
411
5c8b3a717929
workaround dc_scale bug in old ffmpeg msmpeg4v3 encoder (set workaround_bugs=1 for this)
michaelni
parents:
396
diff
changeset
|
19 * |
457 | 20 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at> |
0 | 21 */ |
1106 | 22 |
23 /** | |
24 * @file msmpeg4.c | |
25 * MSMPEG4 backend for ffmpeg encoder and decoder. | |
26 */ | |
27 | |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
347
diff
changeset
|
28 #include "avcodec.h" |
0 | 29 #include "dsputil.h" |
30 #include "mpegvideo.h" | |
411
5c8b3a717929
workaround dc_scale bug in old ffmpeg msmpeg4v3 encoder (set workaround_bugs=1 for this)
michaelni
parents:
396
diff
changeset
|
31 |
0 | 32 /* |
33 * You can also call this codec : MPEG4 with a twist ! | |
34 * | |
35 * TODO: | |
36 * - (encoding) select best mv table (two choices) | |
37 * - (encoding) select best vlc/dc table | |
38 */ | |
39 //#define DEBUG | |
40 | |
531 | 41 #define DC_VLC_BITS 9 |
42 #define CBPY_VLC_BITS 6 | |
43 #define INTER_INTRA_VLC_BITS 3 | |
44 #define V1_INTRA_CBPC_VLC_BITS 6 | |
45 #define V1_INTER_CBPC_VLC_BITS 6 | |
46 #define V2_INTRA_CBPC_VLC_BITS 3 | |
47 #define V2_MB_TYPE_VLC_BITS 7 | |
48 #define MV_VLC_BITS 9 | |
49 #define V2_MV_VLC_BITS 9 | |
50 #define TEX_VLC_BITS 9 | |
51 #define MB_NON_INTRA_VLC_BITS 9 | |
52 #define MB_INTRA_VLC_BITS 9 | |
53 | |
578 | 54 #define II_BITRATE 128*1024 |
55 #define MBAC_BITRATE 50*1024 | |
56 | |
936 | 57 #define DEFAULT_INTER_INDEX 3 |
58 | |
1064 | 59 static uint32_t v2_dc_lum_table[512][2]; |
60 static uint32_t v2_dc_chroma_table[512][2]; | |
307 | 61 |
499 | 62 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n); |
63 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
936 | 64 int n, int coded, const uint8_t *scantable); |
0 | 65 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
66 static int msmpeg4_decode_motion(MpegEncContext * s, | |
67 int *mx_ptr, int *my_ptr); | |
310 | 68 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val); |
468 | 69 static void init_h263_dc_for_msmpeg4(void); |
519 | 70 static inline void msmpeg4_memsetw(short *tab, int val, int n); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
71 #ifdef CONFIG_ENCODERS |
601 | 72 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
73 #endif //CONFIG_ENCODERS |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
74 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
75 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]); |
936 | 76 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]); |
0 | 77 |
2474 | 78 /* vc9 externs */ |
79 extern uint8_t wmv3_dc_scale_table[32]; | |
601 | 80 |
0 | 81 #ifdef DEBUG |
82 int intra_count = 0; | |
83 int frame_count = 0; | |
84 #endif | |
85 | |
86 #include "msmpeg4data.h" | |
87 | |
1325 | 88 #ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references |
1064 | 89 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2]; |
1325 | 90 #endif //CONFIG_ENCODERS |
601 | 91 |
0 | 92 #ifdef STATS |
93 | |
94 const char *st_names[ST_NB] = { | |
95 "unknown", | |
96 "dc", | |
97 "intra_ac", | |
98 "inter_ac", | |
99 "intra_mb", | |
100 "inter_mb", | |
101 "mv", | |
102 }; | |
103 | |
104 int st_current_index = 0; | |
105 unsigned int st_bit_counts[ST_NB]; | |
106 unsigned int st_out_bit_counts[ST_NB]; | |
107 | |
108 #define set_stat(var) st_current_index = var; | |
109 | |
110 void print_stats(void) | |
111 { | |
112 unsigned int total; | |
113 int i; | |
114 | |
115 printf("Input:\n"); | |
116 total = 0; | |
117 for(i=0;i<ST_NB;i++) | |
118 total += st_bit_counts[i]; | |
119 if (total == 0) | |
120 total = 1; | |
121 for(i=0;i<ST_NB;i++) { | |
122 printf("%-10s : %10.1f %5.1f%%\n", | |
123 st_names[i], | |
124 (double)st_bit_counts[i] / 8.0, | |
125 (double)st_bit_counts[i] * 100.0 / total); | |
126 } | |
127 printf("%-10s : %10.1f %5.1f%%\n", | |
128 "total", | |
129 (double)total / 8.0, | |
130 100.0); | |
131 | |
132 printf("Output:\n"); | |
133 total = 0; | |
134 for(i=0;i<ST_NB;i++) | |
135 total += st_out_bit_counts[i]; | |
136 if (total == 0) | |
137 total = 1; | |
138 for(i=0;i<ST_NB;i++) { | |
139 printf("%-10s : %10.1f %5.1f%%\n", | |
140 st_names[i], | |
141 (double)st_out_bit_counts[i] / 8.0, | |
142 (double)st_out_bit_counts[i] * 100.0 / total); | |
143 } | |
144 printf("%-10s : %10.1f %5.1f%%\n", | |
145 "total", | |
146 (double)total / 8.0, | |
147 100.0); | |
148 } | |
149 | |
150 #else | |
151 | |
152 #define set_stat(var) | |
153 | |
154 #endif | |
155 | |
499 | 156 static void common_init(MpegEncContext * s) |
157 { | |
158 static int inited=0; | |
159 | |
160 switch(s->msmpeg4_version){ | |
161 case 1: | |
162 case 2: | |
163 s->y_dc_scale_table= | |
164 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
165 break; | |
166 case 3: | |
167 if(s->workaround_bugs){ | |
168 s->y_dc_scale_table= old_ff_y_dc_scale_table; | |
169 s->c_dc_scale_table= old_ff_c_dc_scale_table; | |
170 } else{ | |
171 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; | |
172 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
173 } | |
174 break; | |
175 case 4: | |
936 | 176 case 5: |
499 | 177 s->y_dc_scale_table= wmv1_y_dc_scale_table; |
178 s->c_dc_scale_table= wmv1_c_dc_scale_table; | |
179 break; | |
2474 | 180 case 6: |
181 s->y_dc_scale_table= wmv3_dc_scale_table; | |
182 s->c_dc_scale_table= wmv3_dc_scale_table; | |
183 break; | |
184 | |
499 | 185 } |
186 | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
187 |
936 | 188 if(s->msmpeg4_version>=4){ |
1273 | 189 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]); |
190 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]); | |
191 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]); | |
192 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]); | |
499 | 193 } |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
194 //Note the default tables are set in common_init in mpegvideo.c |
499 | 195 |
196 if(!inited){ | |
197 inited=1; | |
198 | |
199 init_h263_dc_for_msmpeg4(); | |
200 } | |
201 } | |
202 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
203 #ifdef CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
204 |
0 | 205 /* build the table which associate a (x,y) motion vector to a vlc */ |
206 static void init_mv_table(MVTable *tab) | |
207 { | |
208 int i, x, y; | |
209 | |
1064 | 210 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096); |
0 | 211 /* mark all entries as not used */ |
212 for(i=0;i<4096;i++) | |
213 tab->table_mv_index[i] = tab->n; | |
214 | |
215 for(i=0;i<tab->n;i++) { | |
216 x = tab->table_mvx[i]; | |
217 y = tab->table_mvy[i]; | |
218 tab->table_mv_index[(x << 6) | y] = i; | |
219 } | |
220 } | |
221 | |
222 static void code012(PutBitContext *pb, int n) | |
223 { | |
224 if (n == 0) { | |
225 put_bits(pb, 1, 0); | |
226 } else { | |
227 put_bits(pb, 1, 1); | |
228 put_bits(pb, 1, (n >= 2)); | |
229 } | |
230 } | |
231 | |
499 | 232 void ff_msmpeg4_encode_init(MpegEncContext *s) |
233 { | |
234 static int init_done=0; | |
235 int i; | |
236 | |
237 common_init(s); | |
238 if(s->msmpeg4_version>=4){ | |
239 s->min_qcoeff= -255; | |
240 s->max_qcoeff= 255; | |
241 } | |
242 | |
243 if (!init_done) { | |
244 /* init various encoding tables */ | |
245 init_done = 1; | |
246 init_mv_table(&mv_tables[0]); | |
247 init_mv_table(&mv_tables[1]); | |
248 for(i=0;i<NB_RL_TABLES;i++) | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
249 init_rl(&rl_table[i], 1); |
601 | 250 |
251 for(i=0; i<NB_RL_TABLES; i++){ | |
252 int level; | |
253 for(level=0; level<=MAX_LEVEL; level++){ | |
254 int run; | |
255 for(run=0; run<=MAX_RUN; run++){ | |
256 int last; | |
257 for(last=0; last<2; last++){ | |
774
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
258 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0); |
601 | 259 } |
260 } | |
261 } | |
262 } | |
499 | 263 } |
264 } | |
265 | |
266 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){ | |
267 int size=0; | |
268 int code; | |
269 int run_diff= intra ? 0 : 1; | |
270 | |
271 code = get_rl_index(rl, last, run, level); | |
272 size+= rl->table_vlc[code][1]; | |
273 if (code == rl->n) { | |
274 int level1, run1; | |
275 | |
276 level1 = level - rl->max_level[last][run]; | |
277 if (level1 < 1) | |
278 goto esc2; | |
279 code = get_rl_index(rl, last, run, level1); | |
280 if (code == rl->n) { | |
281 esc2: | |
282 size++; | |
283 if (level > MAX_LEVEL) | |
284 goto esc3; | |
285 run1 = run - rl->max_run[last][level] - run_diff; | |
286 if (run1 < 0) | |
287 goto esc3; | |
288 code = get_rl_index(rl, last, run1, level); | |
289 if (code == rl->n) { | |
290 esc3: | |
291 /* third escape */ | |
292 size+=1+1+6+8; | |
293 } else { | |
294 /* second escape */ | |
295 size+= 1+1+ rl->table_vlc[code][1]; | |
296 } | |
297 } else { | |
298 /* first escape */ | |
299 size+= 1+1+ rl->table_vlc[code][1]; | |
300 } | |
301 } else { | |
302 size++; | |
303 } | |
304 return size; | |
305 } | |
306 | |
307 static void find_best_tables(MpegEncContext * s) | |
308 { | |
309 int i; | |
310 int best =-1, best_size =9999999; | |
311 int chroma_best=-1, best_chroma_size=9999999; | |
601 | 312 |
499 | 313 for(i=0; i<3; i++){ |
314 int level; | |
315 int chroma_size=0; | |
316 int size=0; | |
317 | |
318 if(i>0){// ;) | |
319 size++; | |
320 chroma_size++; | |
321 } | |
322 for(level=0; level<=MAX_LEVEL; level++){ | |
323 int run; | |
324 for(run=0; run<=MAX_RUN; run++){ | |
325 int last; | |
601 | 326 const int last_size= size + chroma_size; |
499 | 327 for(last=0; last<2; last++){ |
328 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last]; | |
329 int intra_luma_count = s->ac_stats[1][0][level][run][last]; | |
330 int intra_chroma_count= s->ac_stats[1][1][level][run][last]; | |
601 | 331 |
499 | 332 if(s->pict_type==I_TYPE){ |
774
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
333 size += intra_luma_count *rl_length[i ][level][run][last]; |
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
334 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last]; |
499 | 335 }else{ |
774
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
336 size+= intra_luma_count *rl_length[i ][level][run][last] |
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
337 +intra_chroma_count*rl_length[i+3][level][run][last] |
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
338 +inter_count *rl_length[i+3][level][run][last]; |
499 | 339 } |
340 } | |
601 | 341 if(last_size == size+chroma_size) break; |
499 | 342 } |
343 } | |
344 if(size<best_size){ | |
345 best_size= size; | |
346 best= i; | |
347 } | |
348 if(chroma_size<best_chroma_size){ | |
349 best_chroma_size= chroma_size; | |
350 chroma_best= i; | |
351 } | |
352 } | |
601 | 353 |
499 | 354 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n", |
355 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size); | |
356 | |
357 if(s->pict_type==P_TYPE) chroma_best= best; | |
358 | |
359 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2); | |
360 | |
361 s->rl_table_index = best; | |
362 s->rl_chroma_table_index= chroma_best; | |
363 | |
364 if(s->pict_type != s->last_non_b_pict_type){ | |
365 s->rl_table_index= 2; | |
366 if(s->pict_type==I_TYPE) | |
367 s->rl_chroma_table_index= 1; | |
368 else | |
369 s->rl_chroma_table_index= 2; | |
370 } | |
371 | |
372 } | |
373 | |
457 | 374 /* write MSMPEG4 compatible frame header */ |
0 | 375 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number) |
376 { | |
499 | 377 find_best_tables(s); |
0 | 378 |
379 align_put_bits(&s->pb); | |
380 put_bits(&s->pb, 2, s->pict_type - 1); | |
381 | |
382 put_bits(&s->pb, 5, s->qscale); | |
499 | 383 if(s->msmpeg4_version<=2){ |
384 s->rl_table_index = 2; | |
385 s->rl_chroma_table_index = 2; | |
386 } | |
310 | 387 |
0 | 388 s->dc_table_index = 1; |
389 s->mv_table_index = 1; /* only if P frame */ | |
390 s->use_skip_mb_code = 1; /* only if P frame */ | |
499 | 391 s->per_mb_rl_table = 0; |
759 | 392 if(s->msmpeg4_version==4) |
393 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE); | |
936 | 394 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height); |
499 | 395 |
0 | 396 if (s->pict_type == I_TYPE) { |
519 | 397 s->slice_height= s->mb_height/1; |
398 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height); | |
499 | 399 |
400 if(s->msmpeg4_version==4){ | |
401 msmpeg4_encode_ext_header(s); | |
578 | 402 if(s->bit_rate>MBAC_BITRATE) |
519 | 403 put_bits(&s->pb, 1, s->per_mb_rl_table); |
499 | 404 } |
0 | 405 |
457 | 406 if(s->msmpeg4_version>2){ |
499 | 407 if(!s->per_mb_rl_table){ |
408 code012(&s->pb, s->rl_chroma_table_index); | |
409 code012(&s->pb, s->rl_table_index); | |
410 } | |
0 | 411 |
310 | 412 put_bits(&s->pb, 1, s->dc_table_index); |
413 } | |
0 | 414 } else { |
415 put_bits(&s->pb, 1, s->use_skip_mb_code); | |
416 | |
578 | 417 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE) |
499 | 418 put_bits(&s->pb, 1, s->per_mb_rl_table); |
419 | |
457 | 420 if(s->msmpeg4_version>2){ |
499 | 421 if(!s->per_mb_rl_table) |
422 code012(&s->pb, s->rl_table_index); | |
0 | 423 |
310 | 424 put_bits(&s->pb, 1, s->dc_table_index); |
0 | 425 |
310 | 426 put_bits(&s->pb, 1, s->mv_table_index); |
427 } | |
0 | 428 } |
429 | |
499 | 430 s->esc3_level_length= 0; |
431 s->esc3_run_length= 0; | |
0 | 432 |
433 #ifdef DEBUG | |
434 intra_count = 0; | |
435 printf("*****frame %d:\n", frame_count++); | |
436 #endif | |
437 } | |
438 | |
208 | 439 void msmpeg4_encode_ext_header(MpegEncContext * s) |
440 { | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
441 put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29 |
208 | 442 |
847 | 443 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047)); |
208 | 444 |
1163 | 445 if(s->msmpeg4_version>=3) |
457 | 446 put_bits(&s->pb, 1, s->flipflop_rounding); |
1163 | 447 else |
448 assert(s->flipflop_rounding==0); | |
208 | 449 } |
450 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
451 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
452 |
0 | 453 /* predict coded block */ |
1064 | 454 static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr) |
0 | 455 { |
299 | 456 int xy, wrap, pred, a, b, c; |
0 | 457 |
299 | 458 xy = s->block_index[n]; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1739
diff
changeset
|
459 wrap = s->b8_stride; |
0 | 460 |
461 /* B C | |
462 * A X | |
463 */ | |
299 | 464 a = s->coded_block[xy - 1 ]; |
465 b = s->coded_block[xy - 1 - wrap]; | |
466 c = s->coded_block[xy - wrap]; | |
0 | 467 |
468 if (b == c) { | |
469 pred = a; | |
470 } else { | |
471 pred = c; | |
472 } | |
473 | |
474 /* store value */ | |
299 | 475 *coded_block_ptr = &s->coded_block[xy]; |
0 | 476 |
477 return pred; | |
478 } | |
479 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
480 #ifdef CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
481 |
0 | 482 static void msmpeg4_encode_motion(MpegEncContext * s, |
483 int mx, int my) | |
484 { | |
485 int code; | |
486 MVTable *mv; | |
487 | |
488 /* modulo encoding */ | |
489 /* WARNING : you cannot reach all the MVs even with the modulo | |
490 encoding. This is a somewhat strange compromise they took !!! */ | |
491 if (mx <= -64) | |
492 mx += 64; | |
493 else if (mx >= 64) | |
494 mx -= 64; | |
495 if (my <= -64) | |
496 my += 64; | |
497 else if (my >= 64) | |
498 my -= 64; | |
499 | |
500 mx += 32; | |
501 my += 32; | |
502 #if 0 | |
503 if ((unsigned)mx >= 64 || | |
504 (unsigned)my >= 64) | |
505 fprintf(stderr, "error mx=%d my=%d\n", mx, my); | |
506 #endif | |
507 mv = &mv_tables[s->mv_table_index]; | |
508 | |
509 code = mv->table_mv_index[(mx << 6) | my]; | |
510 set_stat(ST_MV); | |
511 put_bits(&s->pb, | |
512 mv->table_mv_bits[code], | |
513 mv->table_mv_code[code]); | |
514 if (code == mv->n) { | |
515 /* escape : code litterally */ | |
516 put_bits(&s->pb, 6, mx); | |
517 put_bits(&s->pb, 6, my); | |
518 } | |
519 } | |
520 | |
519 | 521 static inline void handle_slices(MpegEncContext *s){ |
522 if (s->mb_x == 0) { | |
523 if (s->slice_height && (s->mb_y % s->slice_height) == 0) { | |
983 | 524 if(s->msmpeg4_version < 4){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
525 ff_mpeg4_clean_buffers(s); |
519 | 526 } |
527 s->first_slice_line = 1; | |
528 } else { | |
529 s->first_slice_line = 0; | |
530 } | |
531 } | |
532 } | |
533 | |
0 | 534 void msmpeg4_encode_mb(MpegEncContext * s, |
535 DCTELEM block[6][64], | |
536 int motion_x, int motion_y) | |
537 { | |
538 int cbp, coded_cbp, i; | |
539 int pred_x, pred_y; | |
1064 | 540 uint8_t *coded_block; |
0 | 541 |
519 | 542 handle_slices(s); |
543 | |
0 | 544 if (!s->mb_intra) { |
545 /* compute cbp */ | |
546 set_stat(ST_INTER_MB); | |
547 cbp = 0; | |
548 for (i = 0; i < 6; i++) { | |
549 if (s->block_last_index[i] >= 0) | |
550 cbp |= 1 << (5 - i); | |
551 } | |
552 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) { | |
553 /* skip macroblock */ | |
554 put_bits(&s->pb, 1, 1); | |
1164 | 555 s->last_bits++; |
556 s->misc_bits++; | |
1216 | 557 s->skip_count++; |
1164 | 558 |
0 | 559 return; |
560 } | |
561 if (s->use_skip_mb_code) | |
562 put_bits(&s->pb, 1, 0); /* mb coded */ | |
563 | |
457 | 564 if(s->msmpeg4_version<=2){ |
310 | 565 put_bits(&s->pb, |
566 v2_mb_type[cbp&3][1], | |
567 v2_mb_type[cbp&3][0]); | |
568 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C; | |
569 else coded_cbp= cbp; | |
0 | 570 |
310 | 571 put_bits(&s->pb, |
572 cbpy_tab[coded_cbp>>2][1], | |
573 cbpy_tab[coded_cbp>>2][0]); | |
1164 | 574 |
575 s->misc_bits += get_bits_diff(s); | |
576 | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1739
diff
changeset
|
577 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
310 | 578 msmpeg4v2_encode_motion(s, motion_x - pred_x); |
579 msmpeg4v2_encode_motion(s, motion_y - pred_y); | |
580 }else{ | |
581 put_bits(&s->pb, | |
582 table_mb_non_intra[cbp + 64][1], | |
583 table_mb_non_intra[cbp + 64][0]); | |
584 | |
1164 | 585 s->misc_bits += get_bits_diff(s); |
586 | |
310 | 587 /* motion vector */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1739
diff
changeset
|
588 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
310 | 589 msmpeg4_encode_motion(s, motion_x - pred_x, |
590 motion_y - pred_y); | |
591 } | |
1164 | 592 |
593 s->mv_bits += get_bits_diff(s); | |
594 | |
595 for (i = 0; i < 6; i++) { | |
596 msmpeg4_encode_block(s, block[i], i); | |
597 } | |
598 s->p_tex_bits += get_bits_diff(s); | |
0 | 599 } else { |
600 /* compute cbp */ | |
601 cbp = 0; | |
602 coded_cbp = 0; | |
603 for (i = 0; i < 6; i++) { | |
604 int val, pred; | |
605 val = (s->block_last_index[i] >= 1); | |
606 cbp |= val << (5 - i); | |
607 if (i < 4) { | |
608 /* predict value for close blocks only for luma */ | |
609 pred = coded_block_pred(s, i, &coded_block); | |
610 *coded_block = val; | |
611 val = val ^ pred; | |
612 } | |
613 coded_cbp |= val << (5 - i); | |
614 } | |
615 #if 0 | |
616 if (coded_cbp) | |
617 printf("cbp=%x %x\n", cbp, coded_cbp); | |
618 #endif | |
619 | |
457 | 620 if(s->msmpeg4_version<=2){ |
310 | 621 if (s->pict_type == I_TYPE) { |
622 put_bits(&s->pb, | |
623 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]); | |
624 } else { | |
625 if (s->use_skip_mb_code) | |
626 put_bits(&s->pb, 1, 0); /* mb coded */ | |
627 put_bits(&s->pb, | |
628 v2_mb_type[(cbp&3) + 4][1], | |
629 v2_mb_type[(cbp&3) + 4][0]); | |
630 } | |
631 put_bits(&s->pb, 1, 0); /* no AC prediction yet */ | |
0 | 632 put_bits(&s->pb, |
310 | 633 cbpy_tab[cbp>>2][1], |
634 cbpy_tab[cbp>>2][0]); | |
635 }else{ | |
636 if (s->pict_type == I_TYPE) { | |
637 set_stat(ST_INTRA_MB); | |
638 put_bits(&s->pb, | |
2474 | 639 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]); |
310 | 640 } else { |
641 if (s->use_skip_mb_code) | |
642 put_bits(&s->pb, 1, 0); /* mb coded */ | |
643 put_bits(&s->pb, | |
644 table_mb_non_intra[cbp][1], | |
645 table_mb_non_intra[cbp][0]); | |
646 } | |
647 set_stat(ST_INTRA_MB); | |
648 put_bits(&s->pb, 1, 0); /* no AC prediction yet */ | |
578 | 649 if(s->inter_intra_pred){ |
650 s->h263_aic_dir=0; | |
651 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]); | |
652 } | |
0 | 653 } |
1164 | 654 s->misc_bits += get_bits_diff(s); |
0 | 655 |
1164 | 656 for (i = 0; i < 6; i++) { |
657 msmpeg4_encode_block(s, block[i], i); | |
658 } | |
659 s->i_tex_bits += get_bits_diff(s); | |
1216 | 660 s->i_count++; |
0 | 661 } |
662 } | |
663 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
664 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
665 |
499 | 666 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, |
1064 | 667 int32_t **dc_val_ptr) |
457 | 668 { |
669 int i; | |
670 | |
671 if (n < 4) { | |
672 i= 0; | |
673 } else { | |
674 i= n-3; | |
675 } | |
676 | |
677 *dc_val_ptr= &s->last_dc[i]; | |
678 return s->last_dc[i]; | |
679 } | |
680 | |
519 | 681 static int get_dc(uint8_t *src, int stride, int scale) |
682 { | |
683 int y; | |
684 int sum=0; | |
685 for(y=0; y<8; y++){ | |
686 int x; | |
687 for(x=0; x<8; x++){ | |
688 sum+=src[x + y*stride]; | |
689 } | |
690 } | |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1255
diff
changeset
|
691 return FASTDIV((sum + (scale>>1)), scale); |
519 | 692 } |
693 | |
0 | 694 /* dir = 0: left, dir = 1: top prediction */ |
499 | 695 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, |
1064 | 696 uint16_t **dc_val_ptr, int *dir_ptr) |
0 | 697 { |
299 | 698 int a, b, c, wrap, pred, scale; |
1064 | 699 int16_t *dc_val; |
0 | 700 |
701 /* find prediction */ | |
702 if (n < 4) { | |
703 scale = s->y_dc_scale; | |
704 } else { | |
705 scale = s->c_dc_scale; | |
706 } | |
457 | 707 |
299 | 708 wrap = s->block_wrap[n]; |
709 dc_val= s->dc_val[0] + s->block_index[n]; | |
0 | 710 |
711 /* B C | |
712 * A X | |
713 */ | |
299 | 714 a = dc_val[ - 1]; |
715 b = dc_val[ - 1 - wrap]; | |
716 c = dc_val[ - wrap]; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
717 |
983 | 718 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
719 b=c=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
720 } |
0 | 721 |
722 /* XXX: the following solution consumes divisions, but it does not | |
723 necessitate to modify mpegvideo.c. The problem comes from the | |
724 fact they decided to store the quantized DC (which would lead | |
725 to problems if Q could vary !) */ | |
2293
15cfba1b97b5
adapting existing mmx/mmx2/sse/3dnow optimizations so they work on x86_64 patch by (Aurelien Jacobs <aurel at gnuage dot org>)
michael
parents:
2031
diff
changeset
|
726 #if (defined(ARCH_X86) || defined(ARCH_X86_64)) && !defined PIC |
204 | 727 asm volatile( |
728 "movl %3, %%eax \n\t" | |
729 "shrl $1, %%eax \n\t" | |
730 "addl %%eax, %2 \n\t" | |
731 "addl %%eax, %1 \n\t" | |
732 "addl %0, %%eax \n\t" | |
225
ae145876789d
use multiply instead of divides for DC prediction on X86
michaelni
parents:
221
diff
changeset
|
733 "mull %4 \n\t" |
ae145876789d
use multiply instead of divides for DC prediction on X86
michaelni
parents:
221
diff
changeset
|
734 "movl %%edx, %0 \n\t" |
204 | 735 "movl %1, %%eax \n\t" |
225
ae145876789d
use multiply instead of divides for DC prediction on X86
michaelni
parents:
221
diff
changeset
|
736 "mull %4 \n\t" |
ae145876789d
use multiply instead of divides for DC prediction on X86
michaelni
parents:
221
diff
changeset
|
737 "movl %%edx, %1 \n\t" |
204 | 738 "movl %2, %%eax \n\t" |
225
ae145876789d
use multiply instead of divides for DC prediction on X86
michaelni
parents:
221
diff
changeset
|
739 "mull %4 \n\t" |
ae145876789d
use multiply instead of divides for DC prediction on X86
michaelni
parents:
221
diff
changeset
|
740 "movl %%edx, %2 \n\t" |
228 | 741 : "+b" (a), "+c" (b), "+D" (c) |
742 : "g" (scale), "S" (inverse[scale]) | |
204 | 743 : "%eax", "%edx" |
744 ); | |
221 | 745 #else |
746 /* #elif defined (ARCH_ALPHA) */ | |
214
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
747 /* Divisions are extremely costly on Alpha; optimize the most |
221 | 748 common case. But they are costly everywhere... |
749 */ | |
214
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
750 if (scale == 8) { |
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
751 a = (a + (8 >> 1)) / 8; |
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
752 b = (b + (8 >> 1)) / 8; |
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
753 c = (c + (8 >> 1)) / 8; |
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
754 } else { |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1255
diff
changeset
|
755 a = FASTDIV((a + (scale >> 1)), scale); |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1255
diff
changeset
|
756 b = FASTDIV((b + (scale >> 1)), scale); |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1255
diff
changeset
|
757 c = FASTDIV((c + (scale >> 1)), scale); |
214
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
758 } |
204 | 759 #endif |
0 | 760 /* XXX: WARNING: they did not choose the same test as MPEG4. This |
761 is very important ! */ | |
501
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
762 if(s->msmpeg4_version>3){ |
519 | 763 if(s->inter_intra_pred){ |
764 uint8_t *dest; | |
765 int wrap; | |
766 | |
767 if(n==1){ | |
768 pred=a; | |
769 *dir_ptr = 0; | |
770 }else if(n==2){ | |
771 pred=c; | |
772 *dir_ptr = 1; | |
773 }else if(n==3){ | |
774 if (abs(a - b) < abs(b - c)) { | |
775 pred = c; | |
776 *dir_ptr = 1; | |
777 } else { | |
778 pred = a; | |
779 *dir_ptr = 0; | |
780 } | |
781 }else{ | |
782 if(n<4){ | |
783 wrap= s->linesize; | |
903 | 784 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8; |
519 | 785 }else{ |
556 | 786 wrap= s->uvlinesize; |
903 | 787 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8; |
519 | 788 } |
789 if(s->mb_x==0) a= (1024 + (scale>>1))/scale; | |
790 else a= get_dc(dest-8, wrap, scale*8); | |
791 if(s->mb_y==0) c= (1024 + (scale>>1))/scale; | |
792 else c= get_dc(dest-8*wrap, wrap, scale*8); | |
793 | |
794 if (s->h263_aic_dir==0) { | |
795 pred= a; | |
796 *dir_ptr = 0; | |
797 }else if (s->h263_aic_dir==1) { | |
798 if(n==0){ | |
799 pred= c; | |
800 *dir_ptr = 1; | |
801 }else{ | |
802 pred= a; | |
803 *dir_ptr = 0; | |
804 } | |
805 }else if (s->h263_aic_dir==2) { | |
806 if(n==0){ | |
807 pred= a; | |
808 *dir_ptr = 0; | |
809 }else{ | |
810 pred= c; | |
811 *dir_ptr = 1; | |
812 } | |
813 } else { | |
814 pred= c; | |
815 *dir_ptr = 1; | |
816 } | |
817 } | |
818 }else{ | |
819 if (abs(a - b) < abs(b - c)) { | |
820 pred = c; | |
821 *dir_ptr = 1; | |
822 } else { | |
823 pred = a; | |
824 *dir_ptr = 0; | |
825 } | |
501
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
826 } |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
827 }else{ |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
828 if (abs(a - b) <= abs(b - c)) { |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
829 pred = c; |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
830 *dir_ptr = 1; |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
831 } else { |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
832 pred = a; |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
833 *dir_ptr = 0; |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
834 } |
0 | 835 } |
836 | |
837 /* update predictor */ | |
299 | 838 *dc_val_ptr = &dc_val[0]; |
0 | 839 return pred; |
840 } | |
841 | |
842 #define DC_MAX 119 | |
843 | |
844 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr) | |
845 { | |
846 int sign, code; | |
847 int pred; | |
848 | |
457 | 849 if(s->msmpeg4_version==1){ |
1064 | 850 int32_t *dc_val; |
457 | 851 pred = msmpeg4v1_pred_dc(s, n, &dc_val); |
852 | |
853 /* update predictor */ | |
854 *dc_val= level; | |
855 }else{ | |
1064 | 856 uint16_t *dc_val; |
501
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
857 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); |
457 | 858 |
859 /* update predictor */ | |
860 if (n < 4) { | |
861 *dc_val = level * s->y_dc_scale; | |
862 } else { | |
863 *dc_val = level * s->c_dc_scale; | |
864 } | |
0 | 865 } |
866 | |
867 /* do the prediction */ | |
868 level -= pred; | |
869 | |
457 | 870 if(s->msmpeg4_version<=2){ |
310 | 871 if (n < 4) { |
872 put_bits(&s->pb, | |
873 v2_dc_lum_table[level+256][1], | |
874 v2_dc_lum_table[level+256][0]); | |
875 }else{ | |
876 put_bits(&s->pb, | |
877 v2_dc_chroma_table[level+256][1], | |
878 v2_dc_chroma_table[level+256][0]); | |
879 } | |
880 }else{ | |
881 sign = 0; | |
882 if (level < 0) { | |
883 level = -level; | |
884 sign = 1; | |
885 } | |
886 code = level; | |
887 if (code > DC_MAX) | |
888 code = DC_MAX; | |
0 | 889 |
310 | 890 if (s->dc_table_index == 0) { |
891 if (n < 4) { | |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
892 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]); |
310 | 893 } else { |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
894 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]); |
310 | 895 } |
0 | 896 } else { |
310 | 897 if (n < 4) { |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
898 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]); |
310 | 899 } else { |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
900 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]); |
310 | 901 } |
0 | 902 } |
310 | 903 |
904 if (code == DC_MAX) | |
905 put_bits(&s->pb, 8, level); | |
906 | |
907 if (level != 0) { | |
908 put_bits(&s->pb, 1, sign); | |
909 } | |
0 | 910 } |
911 } | |
912 | |
913 /* Encoding of a block. Very similar to MPEG4 except for a different | |
914 escape coding (same as H263) and more vlc tables. | |
915 */ | |
499 | 916 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
0 | 917 { |
918 int level, run, last, i, j, last_index; | |
919 int last_non_zero, sign, slevel; | |
920 int code, run_diff, dc_pred_dir; | |
921 const RLTable *rl; | |
1064 | 922 const uint8_t *scantable; |
0 | 923 |
924 if (s->mb_intra) { | |
925 set_stat(ST_DC); | |
926 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir); | |
927 i = 1; | |
928 if (n < 4) { | |
929 rl = &rl_table[s->rl_table_index]; | |
930 } else { | |
931 rl = &rl_table[3 + s->rl_chroma_table_index]; | |
932 } | |
933 run_diff = 0; | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
934 scantable= s->intra_scantable.permutated; |
0 | 935 set_stat(ST_INTRA_AC); |
936 } else { | |
937 i = 0; | |
938 rl = &rl_table[3 + s->rl_table_index]; | |
457 | 939 if(s->msmpeg4_version<=2) |
310 | 940 run_diff = 0; |
941 else | |
942 run_diff = 1; | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
943 scantable= s->inter_scantable.permutated; |
0 | 944 set_stat(ST_INTER_AC); |
945 } | |
946 | |
499 | 947 /* recalculate block_last_index for M$ wmv1 */ |
936 | 948 if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){ |
499 | 949 for(last_index=63; last_index>=0; last_index--){ |
950 if(block[scantable[last_index]]) break; | |
951 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
952 s->block_last_index[n]= last_index; |
499 | 953 }else |
954 last_index = s->block_last_index[n]; | |
0 | 955 /* AC coefs */ |
956 last_non_zero = i - 1; | |
957 for (; i <= last_index; i++) { | |
499 | 958 j = scantable[i]; |
0 | 959 level = block[j]; |
960 if (level) { | |
961 run = i - last_non_zero - 1; | |
962 last = (i == last_index); | |
963 sign = 0; | |
964 slevel = level; | |
965 if (level < 0) { | |
966 sign = 1; | |
967 level = -level; | |
968 } | |
601 | 969 |
499 | 970 if(level<=MAX_LEVEL && run<=MAX_RUN){ |
971 s->ac_stats[s->mb_intra][n>3][level][run][last]++; | |
972 } | |
973 #if 0 | |
974 else | |
975 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like | |
976 #endif | |
0 | 977 code = get_rl_index(rl, last, run, level); |
978 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
979 if (code == rl->n) { | |
980 int level1, run1; | |
981 | |
982 level1 = level - rl->max_level[last][run]; | |
983 if (level1 < 1) | |
984 goto esc2; | |
985 code = get_rl_index(rl, last, run, level1); | |
986 if (code == rl->n) { | |
987 esc2: | |
988 put_bits(&s->pb, 1, 0); | |
989 if (level > MAX_LEVEL) | |
990 goto esc3; | |
991 run1 = run - rl->max_run[last][level] - run_diff; | |
992 if (run1 < 0) | |
993 goto esc3; | |
994 code = get_rl_index(rl, last, run1, level); | |
995 if (code == rl->n) { | |
996 esc3: | |
997 /* third escape */ | |
998 put_bits(&s->pb, 1, 0); | |
999 put_bits(&s->pb, 1, last); | |
936 | 1000 if(s->msmpeg4_version>=4){ |
499 | 1001 if(s->esc3_level_length==0){ |
1002 s->esc3_level_length=8; | |
1003 s->esc3_run_length= 6; | |
1004 if(s->qscale<8) | |
1005 put_bits(&s->pb, 6, 3); | |
1006 else | |
1007 put_bits(&s->pb, 8, 3); | |
1008 } | |
1009 put_bits(&s->pb, s->esc3_run_length, run); | |
1010 put_bits(&s->pb, 1, sign); | |
1011 put_bits(&s->pb, s->esc3_level_length, level); | |
1012 }else{ | |
1013 put_bits(&s->pb, 6, run); | |
1014 put_bits(&s->pb, 8, slevel & 0xff); | |
1015 } | |
0 | 1016 } else { |
1017 /* second escape */ | |
1018 put_bits(&s->pb, 1, 1); | |
1019 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
1020 put_bits(&s->pb, 1, sign); | |
1021 } | |
1022 } else { | |
1023 /* first escape */ | |
1024 put_bits(&s->pb, 1, 1); | |
1025 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
1026 put_bits(&s->pb, 1, sign); | |
1027 } | |
1028 } else { | |
1029 put_bits(&s->pb, 1, sign); | |
1030 } | |
1031 last_non_zero = i; | |
1032 } | |
1033 } | |
1034 } | |
1035 | |
1036 /****************************************/ | |
1037 /* decoding stuff */ | |
1038 | |
936 | 1039 static VLC mb_non_intra_vlc[4]; |
2474 | 1040 VLC ff_msmp4_mb_i_vlc; |
1041 VLC ff_msmp4_dc_luma_vlc[2]; | |
1042 VLC ff_msmp4_dc_chroma_vlc[2]; | |
307 | 1043 static VLC v2_dc_lum_vlc; |
1044 static VLC v2_dc_chroma_vlc; | |
1045 static VLC cbpy_vlc; | |
1046 static VLC v2_intra_cbpc_vlc; | |
1047 static VLC v2_mb_type_vlc; | |
1048 static VLC v2_mv_vlc; | |
457 | 1049 static VLC v1_intra_cbpc_vlc; |
1050 static VLC v1_inter_cbpc_vlc; | |
519 | 1051 static VLC inter_intra_vlc; |
307 | 1052 |
1053 /* this table is practically identical to the one from h263 except that its inverted */ | |
468 | 1054 static void init_h263_dc_for_msmpeg4(void) |
307 | 1055 { |
1056 int level, uni_code, uni_len; | |
1057 | |
309 | 1058 for(level=-256; level<256; level++){ |
307 | 1059 int size, v, l; |
1060 /* find number of bits */ | |
1061 size = 0; | |
1062 v = abs(level); | |
1063 while (v) { | |
1064 v >>= 1; | |
1065 size++; | |
1066 } | |
1067 | |
1068 if (level < 0) | |
1069 l= (-level) ^ ((1 << size) - 1); | |
1070 else | |
1071 l= level; | |
1072 | |
1073 /* luminance h263 */ | |
1074 uni_code= DCtab_lum[size][0]; | |
1075 uni_len = DCtab_lum[size][1]; | |
1076 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility | |
1077 | |
1078 if (size > 0) { | |
1079 uni_code<<=size; uni_code|=l; | |
1080 uni_len+=size; | |
1081 if (size > 8){ | |
1082 uni_code<<=1; uni_code|=1; | |
1083 uni_len++; | |
1084 } | |
1085 } | |
1086 v2_dc_lum_table[level+256][0]= uni_code; | |
1087 v2_dc_lum_table[level+256][1]= uni_len; | |
1088 | |
1089 /* chrominance h263 */ | |
1090 uni_code= DCtab_chrom[size][0]; | |
1091 uni_len = DCtab_chrom[size][1]; | |
1092 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility | |
1093 | |
1094 if (size > 0) { | |
1095 uni_code<<=size; uni_code|=l; | |
1096 uni_len+=size; | |
1097 if (size > 8){ | |
1098 uni_code<<=1; uni_code|=1; | |
1099 uni_len++; | |
1100 } | |
1101 } | |
1102 v2_dc_chroma_table[level+256][0]= uni_code; | |
1103 v2_dc_chroma_table[level+256][1]= uni_len; | |
1104 | |
1105 } | |
1106 } | |
0 | 1107 |
1108 /* init all vlc decoding tables */ | |
499 | 1109 int ff_msmpeg4_decode_init(MpegEncContext *s) |
0 | 1110 { |
483 | 1111 static int done = 0; |
0 | 1112 int i; |
1113 MVTable *mv; | |
1114 | |
499 | 1115 common_init(s); |
483 | 1116 |
1117 if (!done) { | |
1118 done = 1; | |
0 | 1119 |
483 | 1120 for(i=0;i<NB_RL_TABLES;i++) { |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1121 init_rl(&rl_table[i], 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1122 init_vlc_rl(&rl_table[i], 1); |
483 | 1123 } |
1124 for(i=0;i<2;i++) { | |
1125 mv = &mv_tables[i]; | |
531 | 1126 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1, |
483 | 1127 mv->table_mv_bits, 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1128 mv->table_mv_code, 2, 2, 1); |
483 | 1129 } |
1130 | |
2474 | 1131 init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120, |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1132 &ff_table0_dc_lum[0][1], 8, 4, |
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1133 &ff_table0_dc_lum[0][0], 8, 4, 1); |
2474 | 1134 init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120, |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1135 &ff_table0_dc_chroma[0][1], 8, 4, |
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1136 &ff_table0_dc_chroma[0][0], 8, 4, 1); |
2474 | 1137 init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120, |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1138 &ff_table1_dc_lum[0][1], 8, 4, |
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1139 &ff_table1_dc_lum[0][0], 8, 4, 1); |
2474 | 1140 init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120, |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1141 &ff_table1_dc_chroma[0][1], 8, 4, |
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1142 &ff_table1_dc_chroma[0][0], 8, 4, 1); |
307 | 1143 |
531 | 1144 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512, |
483 | 1145 &v2_dc_lum_table[0][1], 8, 4, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1146 &v2_dc_lum_table[0][0], 8, 4, 1); |
531 | 1147 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512, |
483 | 1148 &v2_dc_chroma_table[0][1], 8, 4, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1149 &v2_dc_chroma_table[0][0], 8, 4, 1); |
307 | 1150 |
531 | 1151 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16, |
483 | 1152 &cbpy_tab[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1153 &cbpy_tab[0][0], 2, 1, 1); |
531 | 1154 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4, |
483 | 1155 &v2_intra_cbpc[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1156 &v2_intra_cbpc[0][0], 2, 1, 1); |
531 | 1157 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8, |
483 | 1158 &v2_mb_type[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1159 &v2_mb_type[0][0], 2, 1, 1); |
531 | 1160 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33, |
483 | 1161 &mvtab[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1162 &mvtab[0][0], 2, 1, 1); |
0 | 1163 |
936 | 1164 for(i=0; i<4; i++){ |
1165 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128, | |
1166 &wmv2_inter_table[i][0][1], 8, 4, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1167 &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name? |
936 | 1168 } |
1169 | |
2474 | 1170 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64, |
1171 &ff_msmp4_mb_i_table[0][1], 4, 2, | |
1172 &ff_msmp4_mb_i_table[0][0], 4, 2, 1); | |
457 | 1173 |
531 | 1174 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8, |
483 | 1175 intra_MCBPC_bits, 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1176 intra_MCBPC_code, 1, 1, 1); |
531 | 1177 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25, |
483 | 1178 inter_MCBPC_bits, 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1179 inter_MCBPC_code, 1, 1, 1); |
519 | 1180 |
531 | 1181 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4, |
519 | 1182 &table_inter_intra[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2293
diff
changeset
|
1183 &table_inter_intra[0][0], 2, 1, 1); |
483 | 1184 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1185 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1186 switch(s->msmpeg4_version){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1187 case 1: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1188 case 2: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1189 s->decode_mb= msmpeg4v12_decode_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1190 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1191 case 3: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1192 case 4: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1193 s->decode_mb= msmpeg4v34_decode_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1194 break; |
936 | 1195 case 5: |
1196 s->decode_mb= wmv2_decode_mb; | |
2474 | 1197 case 6: |
1198 //FIXME + TODO VC9 decode mb | |
936 | 1199 break; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1200 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1201 |
769
9f8c4905928b
fixing decoding of streams with no keyframe at the start
michaelni
parents:
759
diff
changeset
|
1202 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe |
9f8c4905928b
fixing decoding of streams with no keyframe at the start
michaelni
parents:
759
diff
changeset
|
1203 |
0 | 1204 return 0; |
1205 } | |
1206 | |
307 | 1207 int msmpeg4_decode_picture_header(MpegEncContext * s) |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1208 { |
499 | 1209 int code; |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1210 |
311 | 1211 #if 0 |
1212 { | |
1213 int i; | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
983
diff
changeset
|
1214 for(i=0; i<s->gb.size_in_bits; i++) |
311 | 1215 printf("%d", get_bits1(&s->gb)); |
1216 // get_bits1(&s->gb); | |
1217 printf("END\n"); | |
1218 return -1; | |
1219 } | |
1220 #endif | |
457 | 1221 |
1222 if(s->msmpeg4_version==1){ | |
1223 int start_code, num; | |
1224 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16); | |
1225 if(start_code!=0x00000100){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1226 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n"); |
457 | 1227 return -1; |
1228 } | |
1229 | |
1230 num= get_bits(&s->gb, 5); // frame number */ | |
1231 } | |
1232 | |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1233 s->pict_type = get_bits(&s->gb, 2) + 1; |
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1234 if (s->pict_type != I_TYPE && |
457 | 1235 s->pict_type != P_TYPE){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1236 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n"); |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1237 return -1; |
457 | 1238 } |
519 | 1239 #if 0 |
1240 { | |
1241 static int had_i=0; | |
1242 if(s->pict_type == I_TYPE) had_i=1; | |
1243 if(!had_i) return -1; | |
1244 } | |
1245 #endif | |
1651 | 1246 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
1063
fdeac9642346
check for qscale==0 (fixes 1/0 on one corrupted stream)
michaelni
parents:
1057
diff
changeset
|
1247 if(s->qscale==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1248 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n"); |
1063
fdeac9642346
check for qscale==0 (fixes 1/0 on one corrupted stream)
michaelni
parents:
1057
diff
changeset
|
1249 return -1; |
fdeac9642346
check for qscale==0 (fixes 1/0 on one corrupted stream)
michaelni
parents:
1057
diff
changeset
|
1250 } |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1251 |
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1252 if (s->pict_type == I_TYPE) { |
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1253 code = get_bits(&s->gb, 5); |
457 | 1254 if(s->msmpeg4_version==1){ |
1255 if(code==0 || code>s->mb_height){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1256 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code); |
457 | 1257 return -1; |
1258 } | |
1259 | |
1260 s->slice_height = code; | |
1261 }else{ | |
1262 /* 0x17: one slice, 0x18: two slices, ... */ | |
519 | 1263 if (code < 0x17){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1264 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code); |
457 | 1265 return -1; |
519 | 1266 } |
457 | 1267 |
1268 s->slice_height = s->mb_height / (code - 0x16); | |
1269 } | |
311 | 1270 |
1271 switch(s->msmpeg4_version){ | |
457 | 1272 case 1: |
311 | 1273 case 2: |
307 | 1274 s->rl_chroma_table_index = 2; |
1275 s->rl_table_index = 2; | |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1276 |
307 | 1277 s->dc_table_index = 0; //not used |
311 | 1278 break; |
1279 case 3: | |
307 | 1280 s->rl_chroma_table_index = decode012(&s->gb); |
1281 s->rl_table_index = decode012(&s->gb); | |
0 | 1282 |
307 | 1283 s->dc_table_index = get_bits1(&s->gb); |
311 | 1284 break; |
1285 case 4: | |
499 | 1286 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8); |
1287 | |
578 | 1288 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb); |
1289 else s->per_mb_rl_table= 0; | |
519 | 1290 |
499 | 1291 if(!s->per_mb_rl_table){ |
1292 s->rl_chroma_table_index = decode012(&s->gb); | |
1293 s->rl_table_index = decode012(&s->gb); | |
311 | 1294 } |
1295 | |
499 | 1296 s->dc_table_index = get_bits1(&s->gb); |
519 | 1297 s->inter_intra_pred= 0; |
311 | 1298 break; |
307 | 1299 } |
0 | 1300 s->no_rounding = 1; |
1388 | 1301 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1302 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n", |
200 | 1303 s->qscale, |
1304 s->rl_chroma_table_index, | |
1305 s->rl_table_index, | |
499 | 1306 s->dc_table_index, |
519 | 1307 s->per_mb_rl_table, |
1388 | 1308 s->slice_height); |
0 | 1309 } else { |
457 | 1310 switch(s->msmpeg4_version){ |
1311 case 1: | |
1312 case 2: | |
1313 if(s->msmpeg4_version==1) | |
1314 s->use_skip_mb_code = 1; | |
1315 else | |
1316 s->use_skip_mb_code = get_bits1(&s->gb); | |
307 | 1317 s->rl_table_index = 2; |
1318 s->rl_chroma_table_index = s->rl_table_index; | |
1319 s->dc_table_index = 0; //not used | |
1320 s->mv_table_index = 0; | |
457 | 1321 break; |
1322 case 3: | |
1323 s->use_skip_mb_code = get_bits1(&s->gb); | |
307 | 1324 s->rl_table_index = decode012(&s->gb); |
1325 s->rl_chroma_table_index = s->rl_table_index; | |
0 | 1326 |
307 | 1327 s->dc_table_index = get_bits1(&s->gb); |
1328 | |
1329 s->mv_table_index = get_bits1(&s->gb); | |
457 | 1330 break; |
499 | 1331 case 4: |
1332 s->use_skip_mb_code = get_bits1(&s->gb); | |
519 | 1333 |
578 | 1334 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb); |
1335 else s->per_mb_rl_table= 0; | |
519 | 1336 |
499 | 1337 if(!s->per_mb_rl_table){ |
1338 s->rl_table_index = decode012(&s->gb); | |
1339 s->rl_chroma_table_index = s->rl_table_index; | |
1340 } | |
1341 | |
1342 s->dc_table_index = get_bits1(&s->gb); | |
1343 | |
1344 s->mv_table_index = get_bits1(&s->gb); | |
578 | 1345 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE); |
499 | 1346 break; |
307 | 1347 } |
1388 | 1348 |
1349 if(s->avctx->debug&FF_DEBUG_PICT_INFO) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1350 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n", |
200 | 1351 s->use_skip_mb_code, |
1352 s->rl_table_index, | |
1353 s->rl_chroma_table_index, | |
1354 s->dc_table_index, | |
499 | 1355 s->mv_table_index, |
519 | 1356 s->per_mb_rl_table, |
1388 | 1357 s->qscale); |
1358 | |
208 | 1359 if(s->flipflop_rounding){ |
1360 s->no_rounding ^= 1; | |
1361 }else{ | |
1362 s->no_rounding = 0; | |
1363 } | |
0 | 1364 } |
936 | 1365 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height); |
499 | 1366 |
1367 s->esc3_level_length= 0; | |
1368 s->esc3_run_length= 0; | |
307 | 1369 |
0 | 1370 #ifdef DEBUG |
1371 printf("*****frame %d:\n", frame_count++); | |
1372 #endif | |
1373 return 0; | |
1374 } | |
1375 | |
208 | 1376 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size) |
1377 { | |
457 | 1378 int left= buf_size*8 - get_bits_count(&s->gb); |
1379 int length= s->msmpeg4_version>=3 ? 17 : 16; | |
208 | 1380 /* the alt_bitstream reader could read over the end so we need to check it */ |
457 | 1381 if(left>=length && left<length+8) |
208 | 1382 { |
251
75091bfc577b
fixing msmpeg4 decoding if fps < 16 (i thought it was a indicator for the ext header, its the fps indeed)
michaelni
parents:
246
diff
changeset
|
1383 int fps; |
75091bfc577b
fixing msmpeg4 decoding if fps < 16 (i thought it was a indicator for the ext header, its the fps indeed)
michaelni
parents:
246
diff
changeset
|
1384 |
75091bfc577b
fixing msmpeg4 decoding if fps < 16 (i thought it was a indicator for the ext header, its the fps indeed)
michaelni
parents:
246
diff
changeset
|
1385 fps= get_bits(&s->gb, 5); |
578 | 1386 s->bit_rate= get_bits(&s->gb, 11)*1024; |
457 | 1387 if(s->msmpeg4_version>=3) |
1388 s->flipflop_rounding= get_bits1(&s->gb); | |
1389 else | |
1390 s->flipflop_rounding= 0; | |
251
75091bfc577b
fixing msmpeg4 decoding if fps < 16 (i thought it was a indicator for the ext header, its the fps indeed)
michaelni
parents:
246
diff
changeset
|
1391 |
578 | 1392 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding); |
457 | 1393 } |
1394 else if(left<length+8) | |
1395 { | |
1396 s->flipflop_rounding= 0; | |
1399 | 1397 if(s->msmpeg4_version != 2) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1398 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left); |
208 | 1399 } |
1400 else | |
1401 { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1402 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n"); |
208 | 1403 } |
251
75091bfc577b
fixing msmpeg4 decoding if fps < 16 (i thought it was a indicator for the ext header, its the fps indeed)
michaelni
parents:
246
diff
changeset
|
1404 |
208 | 1405 return 0; |
1406 } | |
1407 | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
1408 static inline void msmpeg4_memsetw(short *tab, int val, int n) |
0 | 1409 { |
1410 int i; | |
1411 for(i=0;i<n;i++) | |
1412 tab[i] = val; | |
1413 } | |
1414 | |
310 | 1415 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val) |
1416 { | |
1417 int range, bit_size, sign, code, bits; | |
1418 | |
1419 if (val == 0) { | |
1420 /* zero vector */ | |
1421 code = 0; | |
1422 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
1423 } else { | |
1424 bit_size = s->f_code - 1; | |
1425 range = 1 << bit_size; | |
1426 if (val <= -64) | |
1427 val += 64; | |
1428 else if (val >= 64) | |
1429 val -= 64; | |
1430 | |
1431 if (val >= 0) { | |
1432 sign = 0; | |
1433 } else { | |
1434 val = -val; | |
1435 sign = 1; | |
1436 } | |
1437 val--; | |
1438 code = (val >> bit_size) + 1; | |
1439 bits = val & (range - 1); | |
1440 | |
1441 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); | |
1442 if (bit_size > 0) { | |
1443 put_bits(&s->pb, bit_size, bits); | |
1444 } | |
1445 } | |
1446 } | |
1447 | |
307 | 1448 /* this is identical to h263 except that its range is multiplied by 2 */ |
1449 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code) | |
1450 { | |
1451 int code, val, sign, shift; | |
1452 | |
531 | 1453 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2); |
457 | 1454 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred); |
307 | 1455 if (code < 0) |
1456 return 0xffff; | |
1457 | |
1458 if (code == 0) | |
1459 return pred; | |
1460 sign = get_bits1(&s->gb); | |
1461 shift = f_code - 1; | |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1216
diff
changeset
|
1462 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1216
diff
changeset
|
1463 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1216
diff
changeset
|
1464 val = (val - 1) << shift; |
307 | 1465 val |= get_bits(&s->gb, shift); |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1216
diff
changeset
|
1466 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1216
diff
changeset
|
1467 } |
307 | 1468 if (sign) |
1469 val = -val; | |
457 | 1470 |
307 | 1471 val += pred; |
1472 if (val <= -64) | |
1473 val += 64; | |
1474 else if (val >= 64) | |
1475 val -= 64; | |
1476 | |
1477 return val; | |
1478 } | |
1479 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1480 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) |
307 | 1481 { |
1482 int cbp, code, i; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1483 |
307 | 1484 if (s->pict_type == P_TYPE) { |
1485 if (s->use_skip_mb_code) { | |
1486 if (get_bits1(&s->gb)) { | |
1487 /* skip mb */ | |
1488 s->mb_intra = 0; | |
1489 for(i=0;i<6;i++) | |
1490 s->block_last_index[i] = -1; | |
1491 s->mv_dir = MV_DIR_FORWARD; | |
1492 s->mv_type = MV_TYPE_16X16; | |
1493 s->mv[0][0][0] = 0; | |
1494 s->mv[0][0][1] = 0; | |
1495 s->mb_skiped = 1; | |
1496 return 0; | |
1497 } | |
1498 } | |
1499 | |
457 | 1500 if(s->msmpeg4_version==2) |
531 | 1501 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1); |
457 | 1502 else |
531 | 1503 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3); |
457 | 1504 if(code<0 || code>7){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1505 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y); |
457 | 1506 return -1; |
1507 } | |
1508 | |
307 | 1509 s->mb_intra = code >>2; |
1510 | |
1511 cbp = code & 0x3; | |
1512 } else { | |
1513 s->mb_intra = 1; | |
457 | 1514 if(s->msmpeg4_version==2) |
531 | 1515 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1); |
457 | 1516 else |
531 | 1517 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1); |
457 | 1518 if(cbp<0 || cbp>3){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1519 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y); |
457 | 1520 return -1; |
1521 } | |
307 | 1522 } |
1523 | |
1524 if (!s->mb_intra) { | |
457 | 1525 int mx, my, cbpy; |
1526 | |
531 | 1527 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
457 | 1528 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1529 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y); |
457 | 1530 return -1; |
1531 } | |
307 | 1532 |
457 | 1533 cbp|= cbpy<<2; |
1534 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C; | |
307 | 1535 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1739
diff
changeset
|
1536 h263_pred_motion(s, 0, 0, &mx, &my); |
307 | 1537 mx= msmpeg4v2_decode_motion(s, mx, 1); |
1538 my= msmpeg4v2_decode_motion(s, my, 1); | |
1539 | |
1540 s->mv_dir = MV_DIR_FORWARD; | |
1541 s->mv_type = MV_TYPE_16X16; | |
1542 s->mv[0][0][0] = mx; | |
1543 s->mv[0][0][1] = my; | |
1544 } else { | |
457 | 1545 if(s->msmpeg4_version==2){ |
1546 s->ac_pred = get_bits1(&s->gb); | |
531 | 1547 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors |
457 | 1548 } else{ |
1549 s->ac_pred = 0; | |
531 | 1550 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors |
457 | 1551 if(s->pict_type==P_TYPE) cbp^=0x3C; |
1552 } | |
307 | 1553 } |
1554 | |
1555 for (i = 0; i < 6; i++) { | |
936 | 1556 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) |
307 | 1557 { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1558 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); |
307 | 1559 return -1; |
1560 } | |
1561 } | |
1562 return 0; | |
1563 } | |
1564 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1565 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) |
0 | 1566 { |
1567 int cbp, code, i; | |
1064 | 1568 uint8_t *coded_val; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
1569 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]; |
0 | 1570 |
1571 if (s->pict_type == P_TYPE) { | |
1572 set_stat(ST_INTER_MB); | |
1573 if (s->use_skip_mb_code) { | |
21 | 1574 if (get_bits1(&s->gb)) { |
0 | 1575 /* skip mb */ |
1576 s->mb_intra = 0; | |
1577 for(i=0;i<6;i++) | |
1578 s->block_last_index[i] = -1; | |
1579 s->mv_dir = MV_DIR_FORWARD; | |
1580 s->mv_type = MV_TYPE_16X16; | |
1581 s->mv[0][0][0] = 0; | |
1582 s->mv[0][0][1] = 0; | |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1583 s->mb_skiped = 1; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
1584 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
1585 |
0 | 1586 return 0; |
1587 } | |
1588 } | |
1589 | |
936 | 1590 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3); |
0 | 1591 if (code < 0) |
1592 return -1; | |
246 | 1593 //s->mb_intra = (code & 0x40) ? 0 : 1; |
1594 s->mb_intra = (~code & 0x40) >> 6; | |
0 | 1595 |
1596 cbp = code & 0x3f; | |
1597 } else { | |
1598 set_stat(ST_INTRA_MB); | |
1599 s->mb_intra = 1; | |
2474 | 1600 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2); |
0 | 1601 if (code < 0) |
1602 return -1; | |
1603 /* predict coded block pattern */ | |
1604 cbp = 0; | |
1605 for(i=0;i<6;i++) { | |
246 | 1606 int val = ((code >> (5 - i)) & 1); |
0 | 1607 if (i < 4) { |
246 | 1608 int pred = coded_block_pred(s, i, &coded_val); |
0 | 1609 val = val ^ pred; |
1610 *coded_val = val; | |
1611 } | |
1612 cbp |= val << (5 - i); | |
1613 } | |
1614 } | |
1615 | |
1616 if (!s->mb_intra) { | |
1617 int mx, my; | |
499 | 1618 //printf("P at %d %d\n", s->mb_x, s->mb_y); |
1619 if(s->per_mb_rl_table && cbp){ | |
1620 s->rl_table_index = decode012(&s->gb); | |
1621 s->rl_chroma_table_index = s->rl_table_index; | |
1622 } | |
0 | 1623 set_stat(ST_MV); |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1739
diff
changeset
|
1624 h263_pred_motion(s, 0, 0, &mx, &my); |
0 | 1625 if (msmpeg4_decode_motion(s, &mx, &my) < 0) |
1626 return -1; | |
1627 s->mv_dir = MV_DIR_FORWARD; | |
1628 s->mv_type = MV_TYPE_16X16; | |
1629 s->mv[0][0][0] = mx; | |
1630 s->mv[0][0][1] = my; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
1631 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16; |
0 | 1632 } else { |
499 | 1633 //printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24)); |
0 | 1634 set_stat(ST_INTRA_MB); |
21 | 1635 s->ac_pred = get_bits1(&s->gb); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
1636 *mb_type_ptr = MB_TYPE_INTRA; |
519 | 1637 if(s->inter_intra_pred){ |
531 | 1638 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1); |
519 | 1639 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y); |
1640 } | |
499 | 1641 if(s->per_mb_rl_table && cbp){ |
1642 s->rl_table_index = decode012(&s->gb); | |
1643 s->rl_chroma_table_index = s->rl_table_index; | |
1644 } | |
0 | 1645 } |
1646 | |
1647 for (i = 0; i < 6; i++) { | |
936 | 1648 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) |
246 | 1649 { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1650 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); |
457 | 1651 return -1; |
246 | 1652 } |
0 | 1653 } |
501
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
1654 |
0 | 1655 return 0; |
1656 } | |
563 | 1657 //#define ERROR_DETAILS |
499 | 1658 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, |
936 | 1659 int n, int coded, const uint8_t *scan_table) |
0 | 1660 { |
542 | 1661 int level, i, last, run, run_diff; |
0 | 1662 int dc_pred_dir; |
1663 RLTable *rl; | |
542 | 1664 RL_VLC_ELEM *rl_vlc; |
200 | 1665 int qmul, qadd; |
0 | 1666 |
1667 if (s->mb_intra) { | |
200 | 1668 qmul=1; |
1669 qadd=0; | |
1670 | |
0 | 1671 /* DC coef */ |
1672 set_stat(ST_DC); | |
1673 level = msmpeg4_decode_dc(s, n, &dc_pred_dir); | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
1674 |
457 | 1675 if (level < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1676 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale); |
519 | 1677 if(s->inter_intra_pred) level=0; |
1678 else return -1; | |
457 | 1679 } |
0 | 1680 if (n < 4) { |
1681 rl = &rl_table[s->rl_table_index]; | |
457 | 1682 if(level > 256*s->y_dc_scale){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1683 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale); |
519 | 1684 if(!s->inter_intra_pred) return -1; |
457 | 1685 } |
0 | 1686 } else { |
1687 rl = &rl_table[3 + s->rl_chroma_table_index]; | |
457 | 1688 if(level > 256*s->c_dc_scale){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1689 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale); |
519 | 1690 if(!s->inter_intra_pred) return -1; |
457 | 1691 } |
0 | 1692 } |
457 | 1693 block[0] = level; |
200 | 1694 |
0 | 1695 run_diff = 0; |
542 | 1696 i = 0; |
0 | 1697 if (!coded) { |
1698 goto not_coded; | |
1699 } | |
1700 if (s->ac_pred) { | |
1701 if (dc_pred_dir == 0) | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
1702 scan_table = s->intra_v_scantable.permutated; /* left */ |
0 | 1703 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
1704 scan_table = s->intra_h_scantable.permutated; /* top */ |
0 | 1705 } else { |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
1706 scan_table = s->intra_scantable.permutated; |
0 | 1707 } |
1708 set_stat(ST_INTRA_AC); | |
542 | 1709 rl_vlc= rl->rl_vlc[0]; |
0 | 1710 } else { |
200 | 1711 qmul = s->qscale << 1; |
1712 qadd = (s->qscale - 1) | 1; | |
542 | 1713 i = -1; |
0 | 1714 rl = &rl_table[3 + s->rl_table_index]; |
307 | 1715 |
1716 if(s->msmpeg4_version==2) | |
1717 run_diff = 0; | |
1718 else | |
1719 run_diff = 1; | |
1720 | |
0 | 1721 if (!coded) { |
542 | 1722 s->block_last_index[n] = i; |
0 | 1723 return 0; |
1724 } | |
936 | 1725 if(!scan_table) |
1726 scan_table = s->inter_scantable.permutated; | |
0 | 1727 set_stat(ST_INTER_AC); |
542 | 1728 rl_vlc= rl->rl_vlc[s->qscale]; |
0 | 1729 } |
542 | 1730 { |
1731 OPEN_READER(re, &s->gb); | |
0 | 1732 for(;;) { |
542 | 1733 UPDATE_CACHE(re, &s->gb); |
1734 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
1735 if (level==0) { | |
1736 int cache; | |
1737 cache= GET_CACHE(re, &s->gb); | |
0 | 1738 /* escape */ |
542 | 1739 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) { |
1740 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) { | |
0 | 1741 /* third escape */ |
542 | 1742 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2); |
1743 UPDATE_CACHE(re, &s->gb); | |
499 | 1744 if(s->msmpeg4_version<=3){ |
542 | 1745 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
1746 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6); | |
1747 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8); | |
1748 SKIP_COUNTER(re, &s->gb, 1+6+8); | |
1749 }else{ | |
499 | 1750 int sign; |
542 | 1751 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1); |
499 | 1752 if(!s->esc3_level_length){ |
1753 int ll; | |
1754 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y); | |
1755 if(s->qscale<8){ | |
542 | 1756 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3); |
499 | 1757 if(ll==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1758 if(SHOW_UBITS(re, &s->gb, 1)) av_log(s->avctx, AV_LOG_ERROR, "cool a new vlc code ,contact the ffmpeg developers and upload the file\n"); |
542 | 1759 SKIP_BITS(re, &s->gb, 1); |
499 | 1760 ll=8; |
1761 } | |
1762 }else{ | |
1763 ll=2; | |
542 | 1764 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){ |
1765 ll++; | |
1766 SKIP_BITS(re, &s->gb, 1); | |
1767 } | |
578 | 1768 if(ll<8) SKIP_BITS(re, &s->gb, 1); |
499 | 1769 } |
1770 | |
1771 s->esc3_level_length= ll; | |
542 | 1772 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2); |
499 | 1773 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length); |
578 | 1774 UPDATE_CACHE(re, &s->gb); |
499 | 1775 } |
542 | 1776 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length); |
1777 SKIP_BITS(re, &s->gb, s->esc3_run_length); | |
1778 | |
1779 sign= SHOW_UBITS(re, &s->gb, 1); | |
1780 SKIP_BITS(re, &s->gb, 1); | |
1781 | |
1782 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length); | |
1783 SKIP_BITS(re, &s->gb, s->esc3_level_length); | |
499 | 1784 if(sign) level= -level; |
1785 } | |
1786 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y); | |
457 | 1787 #if 0 // waste of time / this will detect very few errors |
1788 { | |
1789 const int abs_level= ABS(level); | |
1790 const int run1= run - rl->max_run[last][abs_level] - run_diff; | |
1791 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ | |
1792 if(abs_level <= rl->max_level[last][run]){ | |
1793 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n"); | |
1794 return DECODING_AC_LOST; | |
1795 } | |
1796 if(abs_level <= rl->max_level[last][run]*2){ | |
1797 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n"); | |
1798 return DECODING_AC_LOST; | |
1799 } | |
499 | 1800 if(run1>=0 && abs_level <= rl->max_level[last][run1]){ |
457 | 1801 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n"); |
1802 return DECODING_AC_LOST; | |
1803 } | |
1804 } | |
1805 } | |
1806 #endif | |
246 | 1807 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ; |
1808 if (level>0) level= level * qmul + qadd; | |
457 | 1809 else level= level * qmul - qadd; |
1810 #if 0 // waste of time too :( | |
1811 if(level>2048 || level<-2048){ | |
1812 fprintf(stderr, "|level| overflow in 3. esc\n"); | |
1813 return DECODING_AC_LOST; | |
1814 } | |
1815 #endif | |
542 | 1816 i+= run + 1; |
1817 if(last) i+=192; | |
563 | 1818 #ifdef ERROR_DETAILS |
1819 if(run==66) | |
1820 fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level); | |
1821 else if((i>62 && i<192) || i>192+63) | |
1822 fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level); | |
1823 #endif | |
0 | 1824 } else { |
1825 /* second escape */ | |
542 | 1826 #if MIN_CACHE_BITS < 23 |
1827 LAST_SKIP_BITS(re, &s->gb, 2); | |
1828 UPDATE_CACHE(re, &s->gb); | |
1829 #else | |
1830 SKIP_BITS(re, &s->gb, 2); | |
1831 #endif | |
1832 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
1833 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing | |
1834 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1835 LAST_SKIP_BITS(re, &s->gb, 1); | |
563 | 1836 #ifdef ERROR_DETAILS |
1837 if(run==66) | |
1838 fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level); | |
1839 else if((i>62 && i<192) || i>192+63) | |
1840 fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level); | |
1841 #endif | |
0 | 1842 } |
1843 } else { | |
1844 /* first escape */ | |
542 | 1845 #if MIN_CACHE_BITS < 22 |
1846 LAST_SKIP_BITS(re, &s->gb, 1); | |
1847 UPDATE_CACHE(re, &s->gb); | |
1848 #else | |
1849 SKIP_BITS(re, &s->gb, 1); | |
1850 #endif | |
1851 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
1852 i+= run; | |
1853 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
1854 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1855 LAST_SKIP_BITS(re, &s->gb, 1); | |
563 | 1856 #ifdef ERROR_DETAILS |
1857 if(run==66) | |
1858 fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level); | |
1859 else if((i>62 && i<192) || i>192+63) | |
1860 fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level); | |
1861 #endif | |
0 | 1862 } |
1863 } else { | |
542 | 1864 i+= run; |
1865 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1866 LAST_SKIP_BITS(re, &s->gb, 1); | |
563 | 1867 #ifdef ERROR_DETAILS |
1868 if(run==66) | |
1869 fprintf(stderr, "illegal vlc code level=%d\n", level); | |
1870 else if((i>62 && i<192) || i>192+63) | |
1871 fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level); | |
1872 #endif | |
0 | 1873 } |
542 | 1874 if (i > 62){ |
1875 i-= 192; | |
1876 if(i&(~63)){ | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
983
diff
changeset
|
1877 const int left= s->gb.size_in_bits - get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1878 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1879 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y); |
563 | 1880 break; |
1881 }else{ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1882 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
563 | 1883 return -1; |
1884 } | |
542 | 1885 } |
1886 | |
1887 block[scan_table[i]] = level; | |
1888 break; | |
499 | 1889 } |
457 | 1890 |
542 | 1891 block[scan_table[i]] = level; |
0 | 1892 } |
542 | 1893 CLOSE_READER(re, &s->gb); |
1894 } | |
0 | 1895 not_coded: |
1896 if (s->mb_intra) { | |
1897 mpeg4_pred_ac(s, block, n, dc_pred_dir); | |
1898 if (s->ac_pred) { | |
542 | 1899 i = 63; /* XXX: not optimal */ |
0 | 1900 } |
1901 } | |
936 | 1902 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize |
542 | 1903 s->block_last_index[n] = i; |
499 | 1904 |
0 | 1905 return 0; |
1906 } | |
1907 | |
1908 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) | |
1909 { | |
1910 int level, pred; | |
1911 | |
457 | 1912 if(s->msmpeg4_version<=2){ |
307 | 1913 if (n < 4) { |
531 | 1914 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3); |
307 | 1915 } else { |
531 | 1916 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3); |
307 | 1917 } |
309 | 1918 if (level < 0) |
307 | 1919 return -1; |
1920 level-=256; | |
1921 }else{ //FIXME optimize use unified tables & index | |
1922 if (n < 4) { | |
2474 | 1923 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3); |
307 | 1924 } else { |
2474 | 1925 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3); |
307 | 1926 } |
457 | 1927 if (level < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1928 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); |
307 | 1929 return -1; |
457 | 1930 } |
307 | 1931 |
1932 if (level == DC_MAX) { | |
1933 level = get_bits(&s->gb, 8); | |
1934 if (get_bits1(&s->gb)) | |
1935 level = -level; | |
1936 } else if (level != 0) { | |
1937 if (get_bits1(&s->gb)) | |
1938 level = -level; | |
1939 } | |
0 | 1940 } |
1941 | |
457 | 1942 if(s->msmpeg4_version==1){ |
1064 | 1943 int32_t *dc_val; |
457 | 1944 pred = msmpeg4v1_pred_dc(s, n, &dc_val); |
1945 level += pred; | |
1946 | |
1947 /* update predictor */ | |
1948 *dc_val= level; | |
1949 }else{ | |
1064 | 1950 uint16_t *dc_val; |
501
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
1951 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); |
457 | 1952 level += pred; |
0 | 1953 |
457 | 1954 /* update predictor */ |
1955 if (n < 4) { | |
1956 *dc_val = level * s->y_dc_scale; | |
1957 } else { | |
1958 *dc_val = level * s->c_dc_scale; | |
1959 } | |
0 | 1960 } |
1961 | |
1962 return level; | |
1963 } | |
1964 | |
1965 static int msmpeg4_decode_motion(MpegEncContext * s, | |
1966 int *mx_ptr, int *my_ptr) | |
1967 { | |
1968 MVTable *mv; | |
1969 int code, mx, my; | |
1970 | |
1971 mv = &mv_tables[s->mv_table_index]; | |
1972 | |
531 | 1973 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2); |
499 | 1974 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1975 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y); |
0 | 1976 return -1; |
499 | 1977 } |
0 | 1978 if (code == mv->n) { |
499 | 1979 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y); |
0 | 1980 mx = get_bits(&s->gb, 6); |
1981 my = get_bits(&s->gb, 6); | |
1982 } else { | |
1983 mx = mv->table_mvx[code]; | |
1984 my = mv->table_mvy[code]; | |
1985 } | |
1986 | |
1987 mx += *mx_ptr - 32; | |
1988 my += *my_ptr - 32; | |
1989 /* WARNING : they do not do exactly modulo encoding */ | |
1990 if (mx <= -64) | |
1991 mx += 64; | |
1992 else if (mx >= 64) | |
1993 mx -= 64; | |
1994 | |
1995 if (my <= -64) | |
1996 my += 64; | |
1997 else if (my >= 64) | |
1998 my -= 64; | |
1999 *mx_ptr = mx; | |
2000 *my_ptr = my; | |
2001 return 0; | |
2002 } | |
936 | 2003 |
2004 /* cleanest way to support it | |
2005 * there is too much shared between versions so that we cant have 1 file per version & 1 common | |
2006 * as allmost everything would be in the common file | |
2007 */ | |
2008 #include "wmv2.c" |