Mercurial > libavcodec.hg
comparison msmpeg4.c @ 499:8b7a54d58549 libavcodec
wmv1 support
dc scale optimisation
better ac table selection for msmpeg4
author | michaelni |
---|---|
date | Tue, 18 Jun 2002 00:49:00 +0000 |
parents | 97da217aed7f |
children | 2241bce35bb9 |
comparison
equal
deleted
inserted
replaced
498:0b4450c15067 | 499:8b7a54d58549 |
---|---|
30 * - (encoding) select best mv table (two choices) | 30 * - (encoding) select best mv table (two choices) |
31 * - (encoding) select best vlc/dc table | 31 * - (encoding) select best vlc/dc table |
32 */ | 32 */ |
33 //#define DEBUG | 33 //#define DEBUG |
34 | 34 |
35 /* motion vector table */ | |
36 typedef struct MVTable { | |
37 int n; | |
38 const UINT16 *table_mv_code; | |
39 const UINT8 *table_mv_bits; | |
40 const UINT8 *table_mvx; | |
41 const UINT8 *table_mvy; | |
42 UINT16 *table_mv_index; /* encoding: convert mv to index in table_mv */ | |
43 VLC vlc; /* decoding: vlc */ | |
44 } MVTable; | |
45 | |
46 static UINT32 v2_dc_lum_table[512][2]; | 35 static UINT32 v2_dc_lum_table[512][2]; |
47 static UINT32 v2_dc_chroma_table[512][2]; | 36 static UINT32 v2_dc_chroma_table[512][2]; |
48 | 37 |
49 static void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n); | 38 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n); |
50 static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | 39 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, |
51 int n, int coded); | 40 int n, int coded); |
52 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); | 41 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
53 static int msmpeg4_decode_motion(MpegEncContext * s, | 42 static int msmpeg4_decode_motion(MpegEncContext * s, |
54 int *mx_ptr, int *my_ptr); | 43 int *mx_ptr, int *my_ptr); |
55 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val); | 44 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val); |
56 static void init_h263_dc_for_msmpeg4(void); | 45 static void init_h263_dc_for_msmpeg4(void); |
60 | 49 |
61 #ifdef DEBUG | 50 #ifdef DEBUG |
62 int intra_count = 0; | 51 int intra_count = 0; |
63 int frame_count = 0; | 52 int frame_count = 0; |
64 #endif | 53 #endif |
65 /* XXX: move it to mpegvideo.h */ | |
66 | |
67 static int init_done = 0; | |
68 | 54 |
69 #include "msmpeg4data.h" | 55 #include "msmpeg4data.h" |
70 | 56 |
71 #ifdef STATS | 57 #ifdef STATS |
72 | 58 |
130 | 116 |
131 #define set_stat(var) | 117 #define set_stat(var) |
132 | 118 |
133 #endif | 119 #endif |
134 | 120 |
121 static void common_init(MpegEncContext * s) | |
122 { | |
123 static int inited=0; | |
124 | |
125 switch(s->msmpeg4_version){ | |
126 case 1: | |
127 case 2: | |
128 s->y_dc_scale_table= | |
129 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
130 break; | |
131 case 3: | |
132 if(s->workaround_bugs){ | |
133 s->y_dc_scale_table= old_ff_y_dc_scale_table; | |
134 s->c_dc_scale_table= old_ff_c_dc_scale_table; | |
135 } else{ | |
136 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; | |
137 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
138 } | |
139 break; | |
140 case 4: | |
141 s->y_dc_scale_table= wmv1_y_dc_scale_table; | |
142 s->c_dc_scale_table= wmv1_c_dc_scale_table; | |
143 break; | |
144 } | |
145 | |
146 if(s->msmpeg4_version==4){ | |
147 s->intra_scantable = wmv1_scantable[1]; | |
148 s->intra_h_scantable= wmv1_scantable[2]; | |
149 s->intra_v_scantable= wmv1_scantable[3]; | |
150 s->inter_scantable = wmv1_scantable[0]; | |
151 }else{ | |
152 s->intra_scantable = zigzag_direct; | |
153 s->intra_h_scantable= ff_alternate_horizontal_scan; | |
154 s->intra_v_scantable= ff_alternate_vertical_scan; | |
155 s->inter_scantable = zigzag_direct; | |
156 } | |
157 | |
158 if(!inited){ | |
159 int i; | |
160 inited=1; | |
161 | |
162 init_h263_dc_for_msmpeg4(); | |
163 | |
164 /* permute for IDCT */ | |
165 for(i=0; i<WMV1_SCANTABLE_COUNT; i++){ | |
166 int k; | |
167 for(k=0;k<64;k++) { | |
168 int j = wmv1_scantable[i][k]; | |
169 wmv1_scantable[i][k]= block_permute_op(j); | |
170 } | |
171 } | |
172 | |
173 } | |
174 } | |
175 | |
135 /* build the table which associate a (x,y) motion vector to a vlc */ | 176 /* build the table which associate a (x,y) motion vector to a vlc */ |
136 static void init_mv_table(MVTable *tab) | 177 static void init_mv_table(MVTable *tab) |
137 { | 178 { |
138 int i, x, y; | 179 int i, x, y; |
139 | 180 |
157 put_bits(pb, 1, 1); | 198 put_bits(pb, 1, 1); |
158 put_bits(pb, 1, (n >= 2)); | 199 put_bits(pb, 1, (n >= 2)); |
159 } | 200 } |
160 } | 201 } |
161 | 202 |
162 /* write MSMPEG4 compatible frame header */ | 203 void ff_msmpeg4_encode_init(MpegEncContext *s) |
163 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | 204 { |
164 { | 205 static int init_done=0; |
165 int i; | 206 int i; |
166 | 207 |
167 align_put_bits(&s->pb); | 208 common_init(s); |
168 | 209 if(s->msmpeg4_version>=4){ |
169 put_bits(&s->pb, 2, s->pict_type - 1); | 210 s->min_qcoeff= -255; |
170 | 211 s->max_qcoeff= 255; |
171 put_bits(&s->pb, 5, s->qscale); | |
172 | |
173 s->rl_table_index = 2; | |
174 if(s->msmpeg4_version<=2) | |
175 s->rl_chroma_table_index = 2; /* only for I frame */ | |
176 else | |
177 s->rl_chroma_table_index = 1; /* only for I frame */ | |
178 | |
179 s->dc_table_index = 1; | |
180 s->mv_table_index = 1; /* only if P frame */ | |
181 s->use_skip_mb_code = 1; /* only if P frame */ | |
182 | |
183 if (s->pict_type == I_TYPE) { | |
184 put_bits(&s->pb, 5, 0x17); /* indicate only one "slice" */ | |
185 | |
186 if(s->msmpeg4_version>2){ | |
187 code012(&s->pb, s->rl_chroma_table_index); | |
188 code012(&s->pb, s->rl_table_index); | |
189 | |
190 put_bits(&s->pb, 1, s->dc_table_index); | |
191 } | |
192 s->no_rounding = 1; | |
193 } else { | |
194 put_bits(&s->pb, 1, s->use_skip_mb_code); | |
195 | |
196 s->rl_chroma_table_index = s->rl_table_index; | |
197 if(s->msmpeg4_version>2){ | |
198 code012(&s->pb, s->rl_table_index); | |
199 | |
200 put_bits(&s->pb, 1, s->dc_table_index); | |
201 | |
202 put_bits(&s->pb, 1, s->mv_table_index); | |
203 } | |
204 | |
205 if(s->flipflop_rounding){ | |
206 s->no_rounding ^= 1; | |
207 }else{ | |
208 s->no_rounding = 0; | |
209 } | |
210 } | 212 } |
211 | 213 |
212 if (!init_done) { | 214 if (!init_done) { |
213 /* init various encoding tables */ | 215 /* init various encoding tables */ |
214 init_done = 1; | 216 init_done = 1; |
215 init_mv_table(&mv_tables[0]); | 217 init_mv_table(&mv_tables[0]); |
216 init_mv_table(&mv_tables[1]); | 218 init_mv_table(&mv_tables[1]); |
217 for(i=0;i<NB_RL_TABLES;i++) | 219 for(i=0;i<NB_RL_TABLES;i++) |
218 init_rl(&rl_table[i]); | 220 init_rl(&rl_table[i]); |
219 | 221 } |
220 init_h263_dc_for_msmpeg4(); | 222 } |
221 } | 223 |
224 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){ | |
225 int size=0; | |
226 int code; | |
227 int run_diff= intra ? 0 : 1; | |
228 | |
229 code = get_rl_index(rl, last, run, level); | |
230 size+= rl->table_vlc[code][1]; | |
231 if (code == rl->n) { | |
232 int level1, run1; | |
233 | |
234 level1 = level - rl->max_level[last][run]; | |
235 if (level1 < 1) | |
236 goto esc2; | |
237 code = get_rl_index(rl, last, run, level1); | |
238 if (code == rl->n) { | |
239 esc2: | |
240 size++; | |
241 if (level > MAX_LEVEL) | |
242 goto esc3; | |
243 run1 = run - rl->max_run[last][level] - run_diff; | |
244 if (run1 < 0) | |
245 goto esc3; | |
246 code = get_rl_index(rl, last, run1, level); | |
247 if (code == rl->n) { | |
248 esc3: | |
249 /* third escape */ | |
250 size+=1+1+6+8; | |
251 } else { | |
252 /* second escape */ | |
253 size+= 1+1+ rl->table_vlc[code][1]; | |
254 } | |
255 } else { | |
256 /* first escape */ | |
257 size+= 1+1+ rl->table_vlc[code][1]; | |
258 } | |
259 } else { | |
260 size++; | |
261 } | |
262 return size; | |
263 } | |
264 | |
265 static void find_best_tables(MpegEncContext * s) | |
266 { | |
267 int i; | |
268 int best =-1, best_size =9999999; | |
269 int chroma_best=-1, best_chroma_size=9999999; | |
270 int last_size=0; | |
271 | |
272 for(i=0; i<3; i++){ | |
273 int level; | |
274 int chroma_size=0; | |
275 int size=0; | |
276 | |
277 if(i>0){// ;) | |
278 size++; | |
279 chroma_size++; | |
280 } | |
281 for(level=0; level<=MAX_LEVEL; level++){ | |
282 int run; | |
283 for(run=0; run<=MAX_RUN; run++){ | |
284 int last; | |
285 for(last=0; last<2; last++){ | |
286 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last]; | |
287 int intra_luma_count = s->ac_stats[1][0][level][run][last]; | |
288 int intra_chroma_count= s->ac_stats[1][1][level][run][last]; | |
289 | |
290 if(s->pict_type==I_TYPE){ | |
291 size += intra_luma_count *get_size_of_code(s, &rl_table[ i], last, run, level,1); | |
292 chroma_size+= intra_chroma_count*get_size_of_code(s, &rl_table[3+i], last, run, level,1); | |
293 }else{ | |
294 size+= intra_luma_count *get_size_of_code(s, &rl_table[ i], last, run, level,1) | |
295 +intra_chroma_count*get_size_of_code(s, &rl_table[3+i], last, run, level,1) | |
296 +inter_count *get_size_of_code(s, &rl_table[3+i], last, run, level,0); | |
297 } | |
298 } | |
299 } | |
300 } | |
301 if(size<best_size){ | |
302 best_size= size; | |
303 best= i; | |
304 } | |
305 if(chroma_size<best_chroma_size){ | |
306 best_chroma_size= chroma_size; | |
307 chroma_best= i; | |
308 } | |
309 } | |
310 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n", | |
311 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size); | |
312 | |
313 if(s->pict_type==P_TYPE) chroma_best= best; | |
314 | |
315 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2); | |
316 | |
317 s->rl_table_index = best; | |
318 s->rl_chroma_table_index= chroma_best; | |
319 | |
320 if(s->pict_type != s->last_non_b_pict_type){ | |
321 s->rl_table_index= 2; | |
322 if(s->pict_type==I_TYPE) | |
323 s->rl_chroma_table_index= 1; | |
324 else | |
325 s->rl_chroma_table_index= 2; | |
326 } | |
327 | |
328 } | |
329 | |
330 /* write MSMPEG4 compatible frame header */ | |
331 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
332 { | |
333 find_best_tables(s); | |
334 | |
335 align_put_bits(&s->pb); | |
336 put_bits(&s->pb, 2, s->pict_type - 1); | |
337 | |
338 put_bits(&s->pb, 5, s->qscale); | |
339 if(s->msmpeg4_version<=2){ | |
340 s->rl_table_index = 2; | |
341 s->rl_chroma_table_index = 2; | |
342 } | |
343 | |
344 s->dc_table_index = 1; | |
345 s->mv_table_index = 1; /* only if P frame */ | |
346 s->use_skip_mb_code = 1; /* only if P frame */ | |
347 s->per_mb_rl_table = 0; | |
348 | |
349 if (s->pict_type == I_TYPE) { | |
350 s->no_rounding = 1; | |
351 put_bits(&s->pb, 5, 0x17); /* indicate only one "slice" */ | |
352 | |
353 if(s->msmpeg4_version==4){ | |
354 msmpeg4_encode_ext_header(s); | |
355 put_bits(&s->pb, 1, s->per_mb_rl_table); | |
356 } | |
357 | |
358 if(s->msmpeg4_version>2){ | |
359 if(!s->per_mb_rl_table){ | |
360 code012(&s->pb, s->rl_chroma_table_index); | |
361 code012(&s->pb, s->rl_table_index); | |
362 } | |
363 | |
364 put_bits(&s->pb, 1, s->dc_table_index); | |
365 } | |
366 } else { | |
367 put_bits(&s->pb, 1, s->use_skip_mb_code); | |
368 | |
369 if(s->msmpeg4_version==4) | |
370 put_bits(&s->pb, 1, s->per_mb_rl_table); | |
371 | |
372 if(s->msmpeg4_version>2){ | |
373 if(!s->per_mb_rl_table) | |
374 code012(&s->pb, s->rl_table_index); | |
375 | |
376 put_bits(&s->pb, 1, s->dc_table_index); | |
377 | |
378 put_bits(&s->pb, 1, s->mv_table_index); | |
379 } | |
380 | |
381 if(s->flipflop_rounding){ | |
382 s->no_rounding ^= 1; | |
383 }else{ | |
384 s->no_rounding = 0; | |
385 } | |
386 } | |
387 | |
388 s->esc3_level_length= 0; | |
389 s->esc3_run_length= 0; | |
222 | 390 |
223 #ifdef DEBUG | 391 #ifdef DEBUG |
224 intra_count = 0; | 392 intra_count = 0; |
225 printf("*****frame %d:\n", frame_count++); | 393 printf("*****frame %d:\n", frame_count++); |
226 #endif | 394 #endif |
425 s->y_dc_scale = s->qscale + 8; | 593 s->y_dc_scale = s->qscale + 8; |
426 s->c_dc_scale = (s->qscale + 13)>>1; | 594 s->c_dc_scale = (s->qscale + 13)>>1; |
427 } | 595 } |
428 } | 596 } |
429 | 597 |
430 static int msmpeg4v1_pred_dc(MpegEncContext * s, int n, | 598 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, |
431 INT32 **dc_val_ptr) | 599 INT32 **dc_val_ptr) |
432 { | 600 { |
433 int i; | 601 int i; |
434 | 602 |
435 if (n < 4) { | 603 if (n < 4) { |
436 i= 0; | 604 i= 0; |
441 *dc_val_ptr= &s->last_dc[i]; | 609 *dc_val_ptr= &s->last_dc[i]; |
442 return s->last_dc[i]; | 610 return s->last_dc[i]; |
443 } | 611 } |
444 | 612 |
445 /* dir = 0: left, dir = 1: top prediction */ | 613 /* dir = 0: left, dir = 1: top prediction */ |
446 static int msmpeg4_pred_dc(MpegEncContext * s, int n, | 614 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, |
447 INT16 **dc_val_ptr, int *dir_ptr) | 615 UINT16 **dc_val_ptr, int *dir_ptr) |
448 { | 616 { |
449 int a, b, c, wrap, pred, scale; | 617 int a, b, c, wrap, pred, scale; |
450 INT16 *dc_val; | 618 INT16 *dc_val; |
451 | 619 |
452 /* find prediction */ | 620 /* find prediction */ |
504 c = (c + (scale >> 1)) / scale; | 672 c = (c + (scale >> 1)) / scale; |
505 } | 673 } |
506 #endif | 674 #endif |
507 /* XXX: WARNING: they did not choose the same test as MPEG4. This | 675 /* XXX: WARNING: they did not choose the same test as MPEG4. This |
508 is very important ! */ | 676 is very important ! */ |
677 | |
509 if (abs(a - b) <= abs(b - c)) { | 678 if (abs(a - b) <= abs(b - c)) { |
510 pred = c; | 679 pred = c; |
511 *dir_ptr = 1; | 680 *dir_ptr = 1; |
512 } else { | 681 } else { |
513 pred = a; | 682 pred = a; |
531 pred = msmpeg4v1_pred_dc(s, n, &dc_val); | 700 pred = msmpeg4v1_pred_dc(s, n, &dc_val); |
532 | 701 |
533 /* update predictor */ | 702 /* update predictor */ |
534 *dc_val= level; | 703 *dc_val= level; |
535 }else{ | 704 }else{ |
536 INT16 *dc_val; | 705 UINT16 *dc_val; |
537 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); | 706 if(s->msmpeg4_version<=3) |
707 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); | |
708 else | |
709 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); | |
538 | 710 |
539 /* update predictor */ | 711 /* update predictor */ |
540 if (n < 4) { | 712 if (n < 4) { |
541 *dc_val = level * s->y_dc_scale; | 713 *dc_val = level * s->y_dc_scale; |
542 } else { | 714 } else { |
591 } | 763 } |
592 | 764 |
593 /* Encoding of a block. Very similar to MPEG4 except for a different | 765 /* Encoding of a block. Very similar to MPEG4 except for a different |
594 escape coding (same as H263) and more vlc tables. | 766 escape coding (same as H263) and more vlc tables. |
595 */ | 767 */ |
596 static void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) | 768 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
597 { | 769 { |
598 int level, run, last, i, j, last_index; | 770 int level, run, last, i, j, last_index; |
599 int last_non_zero, sign, slevel; | 771 int last_non_zero, sign, slevel; |
600 int code, run_diff, dc_pred_dir; | 772 int code, run_diff, dc_pred_dir; |
601 const RLTable *rl; | 773 const RLTable *rl; |
774 const UINT8 *scantable; | |
602 | 775 |
603 if (s->mb_intra) { | 776 if (s->mb_intra) { |
604 set_stat(ST_DC); | 777 set_stat(ST_DC); |
605 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir); | 778 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir); |
606 i = 1; | 779 i = 1; |
608 rl = &rl_table[s->rl_table_index]; | 781 rl = &rl_table[s->rl_table_index]; |
609 } else { | 782 } else { |
610 rl = &rl_table[3 + s->rl_chroma_table_index]; | 783 rl = &rl_table[3 + s->rl_chroma_table_index]; |
611 } | 784 } |
612 run_diff = 0; | 785 run_diff = 0; |
786 scantable= s->intra_scantable; | |
613 set_stat(ST_INTRA_AC); | 787 set_stat(ST_INTRA_AC); |
614 } else { | 788 } else { |
615 i = 0; | 789 i = 0; |
616 rl = &rl_table[3 + s->rl_table_index]; | 790 rl = &rl_table[3 + s->rl_table_index]; |
617 if(s->msmpeg4_version<=2) | 791 if(s->msmpeg4_version<=2) |
618 run_diff = 0; | 792 run_diff = 0; |
619 else | 793 else |
620 run_diff = 1; | 794 run_diff = 1; |
795 scantable= s->inter_scantable; | |
621 set_stat(ST_INTER_AC); | 796 set_stat(ST_INTER_AC); |
622 } | 797 } |
623 | 798 |
799 /* recalculate block_last_index for M$ wmv1 */ | |
800 if(scantable!=zigzag_direct && s->block_last_index[n]>0){ | |
801 for(last_index=63; last_index>=0; last_index--){ | |
802 if(block[scantable[last_index]]) break; | |
803 } | |
804 }else | |
805 last_index = s->block_last_index[n]; | |
624 /* AC coefs */ | 806 /* AC coefs */ |
625 last_index = s->block_last_index[n]; | |
626 last_non_zero = i - 1; | 807 last_non_zero = i - 1; |
627 for (; i <= last_index; i++) { | 808 for (; i <= last_index; i++) { |
628 j = zigzag_direct[i]; | 809 j = scantable[i]; |
629 level = block[j]; | 810 level = block[j]; |
630 if (level) { | 811 if (level) { |
631 run = i - last_non_zero - 1; | 812 run = i - last_non_zero - 1; |
632 last = (i == last_index); | 813 last = (i == last_index); |
633 sign = 0; | 814 sign = 0; |
634 slevel = level; | 815 slevel = level; |
635 if (level < 0) { | 816 if (level < 0) { |
636 sign = 1; | 817 sign = 1; |
637 level = -level; | 818 level = -level; |
638 } | 819 } |
820 if(level<=MAX_LEVEL && run<=MAX_RUN){ | |
821 s->ac_stats[s->mb_intra][n>3][level][run][last]++; | |
822 } | |
823 #if 0 | |
824 else | |
825 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like | |
826 #endif | |
639 code = get_rl_index(rl, last, run, level); | 827 code = get_rl_index(rl, last, run, level); |
640 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | 828 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
641 if (code == rl->n) { | 829 if (code == rl->n) { |
642 int level1, run1; | 830 int level1, run1; |
643 | 831 |
657 if (code == rl->n) { | 845 if (code == rl->n) { |
658 esc3: | 846 esc3: |
659 /* third escape */ | 847 /* third escape */ |
660 put_bits(&s->pb, 1, 0); | 848 put_bits(&s->pb, 1, 0); |
661 put_bits(&s->pb, 1, last); | 849 put_bits(&s->pb, 1, last); |
662 put_bits(&s->pb, 6, run); | 850 if(s->msmpeg4_version==4){ |
663 put_bits(&s->pb, 8, slevel & 0xff); | 851 if(s->esc3_level_length==0){ |
852 s->esc3_level_length=8; | |
853 s->esc3_run_length= 6; | |
854 if(s->qscale<8) | |
855 put_bits(&s->pb, 6, 3); | |
856 else | |
857 put_bits(&s->pb, 8, 3); | |
858 } | |
859 put_bits(&s->pb, s->esc3_run_length, run); | |
860 put_bits(&s->pb, 1, sign); | |
861 put_bits(&s->pb, s->esc3_level_length, level); | |
862 }else{ | |
863 put_bits(&s->pb, 6, run); | |
864 put_bits(&s->pb, 8, slevel & 0xff); | |
865 } | |
664 } else { | 866 } else { |
665 /* second escape */ | 867 /* second escape */ |
666 put_bits(&s->pb, 1, 1); | 868 put_bits(&s->pb, 1, 1); |
667 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | 869 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
668 put_bits(&s->pb, 1, sign); | 870 put_bits(&s->pb, 1, sign); |
698 static VLC v1_inter_cbpc_vlc; | 900 static VLC v1_inter_cbpc_vlc; |
699 | 901 |
700 /* this table is practically identical to the one from h263 except that its inverted */ | 902 /* this table is practically identical to the one from h263 except that its inverted */ |
701 static void init_h263_dc_for_msmpeg4(void) | 903 static void init_h263_dc_for_msmpeg4(void) |
702 { | 904 { |
703 static int inited=0; | |
704 | |
705 if(!inited){ | |
706 int level, uni_code, uni_len; | 905 int level, uni_code, uni_len; |
707 inited=1; | |
708 | 906 |
709 for(level=-256; level<256; level++){ | 907 for(level=-256; level<256; level++){ |
710 int size, v, l; | 908 int size, v, l; |
711 /* find number of bits */ | 909 /* find number of bits */ |
712 size = 0; | 910 size = 0; |
752 } | 950 } |
753 v2_dc_chroma_table[level+256][0]= uni_code; | 951 v2_dc_chroma_table[level+256][0]= uni_code; |
754 v2_dc_chroma_table[level+256][1]= uni_len; | 952 v2_dc_chroma_table[level+256][1]= uni_len; |
755 | 953 |
756 } | 954 } |
757 } | |
758 } | 955 } |
759 | 956 |
760 /* init all vlc decoding tables */ | 957 /* init all vlc decoding tables */ |
761 int msmpeg4_decode_init_vlc(MpegEncContext *s) | 958 int ff_msmpeg4_decode_init(MpegEncContext *s) |
762 { | 959 { |
763 static int done = 0; | 960 static int done = 0; |
764 int i; | 961 int i; |
765 MVTable *mv; | 962 MVTable *mv; |
766 | 963 |
964 common_init(s); | |
767 | 965 |
768 if (!done) { | 966 if (!done) { |
769 done = 1; | 967 done = 1; |
770 | 968 |
771 for(i=0;i<NB_RL_TABLES;i++) { | 969 for(i=0;i<NB_RL_TABLES;i++) { |
790 &table1_dc_lum[0][0], 8, 4); | 988 &table1_dc_lum[0][0], 8, 4); |
791 init_vlc(&dc_chroma_vlc[1], 9, 120, | 989 init_vlc(&dc_chroma_vlc[1], 9, 120, |
792 &table1_dc_chroma[0][1], 8, 4, | 990 &table1_dc_chroma[0][1], 8, 4, |
793 &table1_dc_chroma[0][0], 8, 4); | 991 &table1_dc_chroma[0][0], 8, 4); |
794 | 992 |
795 init_h263_dc_for_msmpeg4(); | |
796 init_vlc(&v2_dc_lum_vlc, 9, 512, | 993 init_vlc(&v2_dc_lum_vlc, 9, 512, |
797 &v2_dc_lum_table[0][1], 8, 4, | 994 &v2_dc_lum_table[0][1], 8, 4, |
798 &v2_dc_lum_table[0][0], 8, 4); | 995 &v2_dc_lum_table[0][0], 8, 4); |
799 init_vlc(&v2_dc_chroma_vlc, 9, 512, | 996 init_vlc(&v2_dc_chroma_vlc, 9, 512, |
800 &v2_dc_chroma_table[0][1], 8, 4, | 997 &v2_dc_chroma_table[0][1], 8, 4, |
840 return get_bits1(gb) + 1; | 1037 return get_bits1(gb) + 1; |
841 } | 1038 } |
842 | 1039 |
843 int msmpeg4_decode_picture_header(MpegEncContext * s) | 1040 int msmpeg4_decode_picture_header(MpegEncContext * s) |
844 { | 1041 { |
845 int code, code2; | 1042 int code; |
846 | 1043 |
847 #if 0 | 1044 #if 0 |
848 { | 1045 { |
849 int i; | 1046 int i; |
850 for(i=0; i<s->gb.size*8; i++) | 1047 for(i=0; i<s->gb.size*8; i++) |
905 s->rl_table_index = decode012(&s->gb); | 1102 s->rl_table_index = decode012(&s->gb); |
906 | 1103 |
907 s->dc_table_index = get_bits1(&s->gb); | 1104 s->dc_table_index = get_bits1(&s->gb); |
908 break; | 1105 break; |
909 case 4: | 1106 case 4: |
910 msmpeg4_decode_ext_header(s, 999 /* bufer size (useless here) */); | 1107 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8); |
911 printf("%X\n", show_bits(&s->gb, 24)); | 1108 |
912 code= get_bits(&s->gb, 2); | 1109 s->per_mb_rl_table= get_bits1(&s->gb); |
913 if(code==1){ | 1110 if(!s->per_mb_rl_table){ |
914 code2= get_bits(&s->gb, 3); | 1111 s->rl_chroma_table_index = decode012(&s->gb); |
915 if(code2==7) skip_bits(&s->gb, 1); | 1112 s->rl_table_index = decode012(&s->gb); |
916 } | 1113 } |
917 printf("%X\n", show_bits(&s->gb, 24)); | 1114 |
918 s->rl_chroma_table_index = 2; | 1115 s->dc_table_index = get_bits1(&s->gb); |
919 s->rl_table_index = 2; | |
920 | |
921 s->dc_table_index = 0; | |
922 break; | 1116 break; |
923 } | 1117 } |
924 s->no_rounding = 1; | 1118 s->no_rounding = 1; |
925 /* printf(" %d %d %d %d \n", | 1119 /* printf(" %d %d %d %d %d \n", |
926 s->qscale, | 1120 s->qscale, |
927 s->rl_chroma_table_index, | 1121 s->rl_chroma_table_index, |
928 s->rl_table_index, | 1122 s->rl_table_index, |
929 s->dc_table_index);*/ | 1123 s->dc_table_index, |
1124 s->per_mb_rl_table);*/ | |
930 } else { | 1125 } else { |
931 | 1126 |
932 switch(s->msmpeg4_version){ | 1127 switch(s->msmpeg4_version){ |
933 case 1: | 1128 case 1: |
934 case 2: | 1129 case 2: |
948 | 1143 |
949 s->dc_table_index = get_bits1(&s->gb); | 1144 s->dc_table_index = get_bits1(&s->gb); |
950 | 1145 |
951 s->mv_table_index = get_bits1(&s->gb); | 1146 s->mv_table_index = get_bits1(&s->gb); |
952 break; | 1147 break; |
953 } | 1148 case 4: |
954 /* printf(" %d %d %d %d %d \n", | 1149 s->use_skip_mb_code = get_bits1(&s->gb); |
1150 s->per_mb_rl_table= get_bits1(&s->gb); | |
1151 if(!s->per_mb_rl_table){ | |
1152 s->rl_table_index = decode012(&s->gb); | |
1153 s->rl_chroma_table_index = s->rl_table_index; | |
1154 } | |
1155 | |
1156 s->dc_table_index = get_bits1(&s->gb); | |
1157 | |
1158 s->mv_table_index = get_bits1(&s->gb); | |
1159 break; | |
1160 } | |
1161 /* printf(" %d %d %d %d %d %d \n", | |
955 s->use_skip_mb_code, | 1162 s->use_skip_mb_code, |
956 s->rl_table_index, | 1163 s->rl_table_index, |
957 s->rl_chroma_table_index, | 1164 s->rl_chroma_table_index, |
958 s->dc_table_index, | 1165 s->dc_table_index, |
959 s->mv_table_index);*/ | 1166 s->mv_table_index, |
1167 s->per_mb_rl_table);*/ | |
960 if(s->flipflop_rounding){ | 1168 if(s->flipflop_rounding){ |
961 s->no_rounding ^= 1; | 1169 s->no_rounding ^= 1; |
962 }else{ | 1170 }else{ |
963 s->no_rounding = 0; | 1171 s->no_rounding = 0; |
964 } | 1172 } |
965 // printf("%d", s->no_rounding); | 1173 } |
966 //return -1; | 1174 |
967 } | 1175 s->esc3_level_length= 0; |
968 | 1176 s->esc3_run_length= 0; |
969 #if 0 | |
970 if(s->msmpeg4_version==2) | |
971 { | |
972 int i; | |
973 for(i=0; i<s->gb.size*8; i++) | |
974 // printf("%d", get_bits1(&s->gb)); | |
975 get_bits1(&s->gb); | |
976 printf("END\n"); | |
977 return -1; | |
978 } | |
979 #endif | |
980 | 1177 |
981 #ifdef DEBUG | 1178 #ifdef DEBUG |
982 printf("*****frame %d:\n", frame_count++); | 1179 printf("*****frame %d:\n", frame_count++); |
983 #endif | 1180 #endif |
984 return 0; | 1181 return 0; |
1252 } | 1449 } |
1253 } | 1450 } |
1254 | 1451 |
1255 if (!s->mb_intra) { | 1452 if (!s->mb_intra) { |
1256 int mx, my; | 1453 int mx, my; |
1454 //printf("P at %d %d\n", s->mb_x, s->mb_y); | |
1455 if(s->per_mb_rl_table && cbp){ | |
1456 s->rl_table_index = decode012(&s->gb); | |
1457 s->rl_chroma_table_index = s->rl_table_index; | |
1458 } | |
1257 set_stat(ST_MV); | 1459 set_stat(ST_MV); |
1258 h263_pred_motion(s, 0, &mx, &my); | 1460 h263_pred_motion(s, 0, &mx, &my); |
1259 if (msmpeg4_decode_motion(s, &mx, &my) < 0) | 1461 if (msmpeg4_decode_motion(s, &mx, &my) < 0) |
1260 return -1; | 1462 return -1; |
1261 s->mv_dir = MV_DIR_FORWARD; | 1463 s->mv_dir = MV_DIR_FORWARD; |
1262 s->mv_type = MV_TYPE_16X16; | 1464 s->mv_type = MV_TYPE_16X16; |
1263 s->mv[0][0][0] = mx; | 1465 s->mv[0][0][0] = mx; |
1264 s->mv[0][0][1] = my; | 1466 s->mv[0][0][1] = my; |
1265 } else { | 1467 } else { |
1468 //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)); | |
1266 set_stat(ST_INTRA_MB); | 1469 set_stat(ST_INTRA_MB); |
1267 s->ac_pred = get_bits1(&s->gb); | 1470 s->ac_pred = get_bits1(&s->gb); |
1471 if(s->per_mb_rl_table && cbp){ | |
1472 s->rl_table_index = decode012(&s->gb); | |
1473 s->rl_chroma_table_index = s->rl_table_index; | |
1474 } | |
1268 } | 1475 } |
1269 | 1476 |
1270 for (i = 0; i < 6; i++) { | 1477 for (i = 0; i < 6; i++) { |
1271 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0) | 1478 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0) |
1272 { | 1479 { |
1276 } | 1483 } |
1277 | 1484 |
1278 return 0; | 1485 return 0; |
1279 } | 1486 } |
1280 | 1487 |
1281 static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | 1488 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, |
1282 int n, int coded) | 1489 int n, int coded) |
1283 { | 1490 { |
1284 int code, level, i, j, last, run, run_diff; | 1491 int code, level, i, j, last, run, run_diff; |
1285 int dc_pred_dir; | 1492 int dc_pred_dir; |
1286 RLTable *rl; | 1493 RLTable *rl; |
1318 if (!coded) { | 1525 if (!coded) { |
1319 goto not_coded; | 1526 goto not_coded; |
1320 } | 1527 } |
1321 if (s->ac_pred) { | 1528 if (s->ac_pred) { |
1322 if (dc_pred_dir == 0) | 1529 if (dc_pred_dir == 0) |
1323 scan_table = ff_alternate_vertical_scan; /* left */ | 1530 scan_table = s->intra_v_scantable; /* left */ |
1324 else | 1531 else |
1325 scan_table = ff_alternate_horizontal_scan; /* top */ | 1532 scan_table = s->intra_h_scantable; /* top */ |
1326 } else { | 1533 } else { |
1327 scan_table = zigzag_direct; | 1534 scan_table = s->intra_scantable; |
1328 } | 1535 } |
1329 set_stat(ST_INTRA_AC); | 1536 set_stat(ST_INTRA_AC); |
1330 } else { | 1537 } else { |
1331 qmul = s->qscale << 1; | 1538 qmul = s->qscale << 1; |
1332 qadd = (s->qscale - 1) | 1; | 1539 qadd = (s->qscale - 1) | 1; |
1340 | 1547 |
1341 if (!coded) { | 1548 if (!coded) { |
1342 s->block_last_index[n] = i - 1; | 1549 s->block_last_index[n] = i - 1; |
1343 return 0; | 1550 return 0; |
1344 } | 1551 } |
1345 scan_table = zigzag_direct; | 1552 scan_table = s->inter_scantable; |
1346 set_stat(ST_INTER_AC); | 1553 set_stat(ST_INTER_AC); |
1347 } | 1554 } |
1348 | 1555 |
1349 for(;;) { | 1556 for(;;) { |
1350 code = get_vlc(&s->gb, &rl->vlc); | 1557 code = get_vlc(&s->gb, &rl->vlc); |
1351 if (code < 0) | 1558 if (code < 0){ |
1559 fprintf(stderr, "illegal AC-VLC code at %d %d\n", s->mb_x, s->mb_y); | |
1352 return -1; | 1560 return -1; |
1561 } | |
1353 if (code == rl->n) { | 1562 if (code == rl->n) { |
1354 /* escape */ | 1563 /* escape */ |
1355 if (s->msmpeg4_version==1 || get_bits1(&s->gb) == 0) { | 1564 if (s->msmpeg4_version==1 || get_bits1(&s->gb) == 0) { |
1356 if (s->msmpeg4_version==1 || get_bits1(&s->gb) == 0) { | 1565 if (s->msmpeg4_version==1 || get_bits1(&s->gb) == 0) { |
1357 /* third escape */ | 1566 /* third escape */ |
1358 last = get_bits1(&s->gb); | 1567 if(s->msmpeg4_version<=3){ |
1359 run = get_bits(&s->gb, 6); | 1568 last= get_bits1(&s->gb); |
1360 level = get_bits(&s->gb, 8); | 1569 run= get_bits(&s->gb, 6); |
1361 level = (level << 24) >> 24; /* sign extend */ | 1570 level= get_bits(&s->gb, 8); |
1571 level= ((int8_t)level); | |
1572 }else{ | |
1573 int sign; | |
1574 last= get_bits1(&s->gb); | |
1575 if(!s->esc3_level_length){ | |
1576 int ll; | |
1577 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y); | |
1578 if(s->qscale<8){ | |
1579 ll= get_bits(&s->gb, 3); | |
1580 if(ll==0){ | |
1581 if(get_bits1(&s->gb)) printf("cool a new vlc code ,contact the ffmpeg developers and upload the file\n"); | |
1582 ll=8; | |
1583 } | |
1584 }else{ | |
1585 ll=2; | |
1586 while(ll<8 && get_bits1(&s->gb)==0) ll++; | |
1587 } | |
1588 | |
1589 s->esc3_level_length= ll; | |
1590 s->esc3_run_length= get_bits(&s->gb, 2) + 3; | |
1591 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length); | |
1592 } | |
1593 run= get_bits(&s->gb, s->esc3_run_length); | |
1594 sign= get_bits1(&s->gb); | |
1595 level= get_bits(&s->gb, s->esc3_level_length); | |
1596 if(sign) level= -level; | |
1597 } | |
1598 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y); | |
1362 #if 0 // waste of time / this will detect very few errors | 1599 #if 0 // waste of time / this will detect very few errors |
1363 { | 1600 { |
1364 const int abs_level= ABS(level); | 1601 const int abs_level= ABS(level); |
1365 const int run1= run - rl->max_run[last][abs_level] - run_diff; | 1602 const int run1= run - rl->max_run[last][abs_level] - run_diff; |
1366 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ | 1603 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ |
1370 } | 1607 } |
1371 if(abs_level <= rl->max_level[last][run]*2){ | 1608 if(abs_level <= rl->max_level[last][run]*2){ |
1372 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n"); | 1609 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n"); |
1373 return DECODING_AC_LOST; | 1610 return DECODING_AC_LOST; |
1374 } | 1611 } |
1375 if(abs_level <= rl->max_level[last][run1] && 0){ | 1612 if(run1>=0 && abs_level <= rl->max_level[last][run1]){ |
1376 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n"); | 1613 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n"); |
1377 return DECODING_AC_LOST; | 1614 return DECODING_AC_LOST; |
1378 } | 1615 } |
1379 } | 1616 } |
1380 } | 1617 } |
1389 } | 1626 } |
1390 #endif | 1627 #endif |
1391 } else { | 1628 } else { |
1392 /* second escape */ | 1629 /* second escape */ |
1393 code = get_vlc(&s->gb, &rl->vlc); | 1630 code = get_vlc(&s->gb, &rl->vlc); |
1394 if (code < 0 || code >= rl->n) | 1631 if (code < 0 || code >= rl->n){ |
1632 fprintf(stderr, "illegal ESC2-VLC code %d at %d %d\n", code, s->mb_x, s->mb_y); | |
1395 return -1; | 1633 return -1; |
1634 } | |
1396 run = rl->table_run[code]; | 1635 run = rl->table_run[code]; |
1397 level = rl->table_level[code]; | 1636 level = rl->table_level[code]; |
1398 last = code >= rl->last; | 1637 last = code >= rl->last; |
1399 run += rl->max_run[last][level] + run_diff; | 1638 run += rl->max_run[last][level] + run_diff; |
1400 level= level * qmul + qadd; | 1639 level= level * qmul + qadd; |
1402 level = -level; | 1641 level = -level; |
1403 } | 1642 } |
1404 } else { | 1643 } else { |
1405 /* first escape */ | 1644 /* first escape */ |
1406 code = get_vlc(&s->gb, &rl->vlc); | 1645 code = get_vlc(&s->gb, &rl->vlc); |
1407 if (code < 0 || code >= rl->n) | 1646 if (code < 0 || code >= rl->n){ |
1647 fprintf(stderr, "illegal ESC2-VLC code %d at %d %d\n", code, s->mb_x, s->mb_y); | |
1408 return -1; | 1648 return -1; |
1649 } | |
1409 run = rl->table_run[code]; | 1650 run = rl->table_run[code]; |
1410 level = rl->table_level[code]; | 1651 level = rl->table_level[code]; |
1411 last = code >= rl->last; | 1652 last = code >= rl->last; |
1412 level += rl->max_level[last][run]; | 1653 level += rl->max_level[last][run]; |
1413 level= level * qmul + qadd; | 1654 level= level * qmul + qadd; |
1420 last = code >= rl->last; | 1661 last = code >= rl->last; |
1421 if (get_bits1(&s->gb)) | 1662 if (get_bits1(&s->gb)) |
1422 level = -level; | 1663 level = -level; |
1423 } | 1664 } |
1424 i += run; | 1665 i += run; |
1425 if (i >= 64) | 1666 if (i >= 64){ |
1667 fprintf(stderr, "run too long at %d %d\n", s->mb_x, s->mb_y); | |
1426 return -1; | 1668 return -1; |
1669 } | |
1427 | 1670 |
1428 j = scan_table[i]; | 1671 j = scan_table[i]; |
1429 block[j] = level; | 1672 block[j] = level; |
1430 i++; | 1673 i++; |
1431 if (last) | 1674 if (last) |
1436 mpeg4_pred_ac(s, block, n, dc_pred_dir); | 1679 mpeg4_pred_ac(s, block, n, dc_pred_dir); |
1437 if (s->ac_pred) { | 1680 if (s->ac_pred) { |
1438 i = 64; /* XXX: not optimal */ | 1681 i = 64; /* XXX: not optimal */ |
1439 } | 1682 } |
1440 } | 1683 } |
1684 if(s->msmpeg4_version==4 && i>1) i=64; //FIXME/XXX optimize | |
1441 s->block_last_index[n] = i - 1; | 1685 s->block_last_index[n] = i - 1; |
1442 | 1686 |
1443 return 0; | 1687 return 0; |
1444 } | 1688 } |
1445 | 1689 |
1446 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) | 1690 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
1447 { | 1691 { |
1483 level += pred; | 1727 level += pred; |
1484 | 1728 |
1485 /* update predictor */ | 1729 /* update predictor */ |
1486 *dc_val= level; | 1730 *dc_val= level; |
1487 }else{ | 1731 }else{ |
1488 INT16 *dc_val; | 1732 UINT16 *dc_val; |
1489 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); | 1733 if(s->msmpeg4_version<=3) |
1734 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); | |
1735 else | |
1736 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); | |
1490 level += pred; | 1737 level += pred; |
1491 | 1738 |
1492 /* update predictor */ | 1739 /* update predictor */ |
1493 if (n < 4) { | 1740 if (n < 4) { |
1494 *dc_val = level * s->y_dc_scale; | 1741 *dc_val = level * s->y_dc_scale; |
1507 int code, mx, my; | 1754 int code, mx, my; |
1508 | 1755 |
1509 mv = &mv_tables[s->mv_table_index]; | 1756 mv = &mv_tables[s->mv_table_index]; |
1510 | 1757 |
1511 code = get_vlc(&s->gb, &mv->vlc); | 1758 code = get_vlc(&s->gb, &mv->vlc); |
1512 if (code < 0) | 1759 if (code < 0){ |
1760 fprintf(stderr, "illegal MV code at %d %d\n", s->mb_x, s->mb_y); | |
1513 return -1; | 1761 return -1; |
1762 } | |
1514 if (code == mv->n) { | 1763 if (code == mv->n) { |
1764 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y); | |
1515 mx = get_bits(&s->gb, 6); | 1765 mx = get_bits(&s->gb, 6); |
1516 my = get_bits(&s->gb, 6); | 1766 my = get_bits(&s->gb, 6); |
1517 } else { | 1767 } else { |
1518 mx = mv->table_mvx[code]; | 1768 mx = mv->table_mvx[code]; |
1519 my = mv->table_mvy[code]; | 1769 my = mv->table_mvy[code]; |