Mercurial > libavcodec.hg

comparison h263.c @ 265:4e9e728021d8 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes) some minor optimizations last non zero index cant be 64 bugfix
author michaelni
date Fri, 15 Mar 2002 04:10:53 +0000
parents 28c5c62b1c4c
children 252444e5259b
comparison
equal deleted inserted replaced
264:28c5c62b1c4c 265:4e9e728021d8
26 #include "mpeg4data.h" 26 #include "mpeg4data.h"
27 27
28 //rounded divison & shift 28 //rounded divison & shift
29 #define RDIV(a,b) ((a) > 0 ? ((a)+((b)>>1))/(b) : ((a)-((b)>>1))/(b)) 29 #define RDIV(a,b) ((a) > 0 ? ((a)+((b)>>1))/(b) : ((a)-((b)>>1))/(b))
30 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b)) 30 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
31 #define ABS(a) (((a)>=0)?(a):(-(a)))
31 32
32 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, 33 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
33 int n); 34 int n);
34 static void h263_encode_motion(MpegEncContext * s, int val); 35 static void h263_encode_motion(MpegEncContext * s, int val);
35 static void h263p_encode_umotion(MpegEncContext * s, int val); 36 static void h263p_encode_umotion(MpegEncContext * s, int val);
36 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, 37 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
37 int n); 38 int n, int dc, UINT8 *scan_table);
38 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); 39 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
39 static int h263p_decode_umotion(MpegEncContext * s, int pred); 40 static int h263p_decode_umotion(MpegEncContext * s, int pred);
40 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 41 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
41 int n, int coded); 42 int n, int coded);
42 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 43 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
43 int n, int coded); 44 int n, int coded);
45 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
46 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
47 int dir);
48
49 extern UINT32 inverse[256];
44 50
45 int h263_get_picture_format(int width, int height) 51 int h263_get_picture_format(int width, int height)
46 { 52 {
47 int format; 53 int format;
48 54
193 return pdif; 199 return pdif;
194 } 200 }
195 } 201 }
196 return 0; 202 return 0;
197 } 203 }
204
205 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
206 {
207 int score0=0, score1=0;
208 int i, n;
209
210 for(n=0; n<6; n++){
211 int x, y, wrap;
212 INT16 *ac_val, *ac_val1;
213
214 if (n < 4) {
215 x = 2 * s->mb_x + 1 + (n & 1);
216 y = 2 * s->mb_y + 1 + (n >> 1);
217 wrap = s->mb_width * 2 + 2;
218 ac_val = s->ac_val[0][0];
219 } else {
220 x = s->mb_x + 1;
221 y = s->mb_y + 1;
222 wrap = s->mb_width + 2;
223 ac_val = s->ac_val[n - 4 + 1][0];
224 }
225 ac_val += ((y) * wrap + (x)) * 16;
226 ac_val1= ac_val;
227 if(dir[n]){
228 ac_val-= wrap*16;
229 for(i=1; i<8; i++){
230 const int level= block[n][block_permute_op(i )];
231 score0+= ABS(level);
232 score1+= ABS(level - ac_val[i+8]);
233 ac_val1[i ]= block[n][block_permute_op(i<<3)];
234 ac_val1[i+8]= level;
235 }
236 }else{
237 ac_val-= 16;
238 for(i=1; i<8; i++){
239 const int level= block[n][block_permute_op(i<<3)];
240 score0+= ABS(level);
241 score1+= ABS(level - ac_val[i]);
242 ac_val1[i ]= level;
243 ac_val1[i+8]= block[n][block_permute_op(i )];
244 }
245 }
246 }
247
248 return score0 > score1 ? 1 : 0;
249 }
250
251 void mpeg4_encode_mb(MpegEncContext * s,
252 DCTELEM block[6][64],
253 int motion_x, int motion_y)
254 {
255 int cbpc, cbpy, i, cbp, pred_x, pred_y;
198 256
257 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
258 if (!s->mb_intra) {
259 /* compute cbp */
260 cbp = 0;
261 for (i = 0; i < 6; i++) {
262 if (s->block_last_index[i] >= 0)
263 cbp |= 1 << (5 - i);
264 }
265 if ((cbp | motion_x | motion_y) == 0) {
266 /* skip macroblock */
267 put_bits(&s->pb, 1, 1);
268 return;
269 }
270 put_bits(&s->pb, 1, 0); /* mb coded */
271 cbpc = cbp & 3;
272 put_bits(&s->pb,
273 inter_MCBPC_bits[cbpc],
274 inter_MCBPC_code[cbpc]);
275 cbpy = cbp >> 2;
276 cbpy ^= 0xf;
277 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
278
279 /* motion vectors: 16x16 mode only now */
280 h263_pred_motion(s, 0, &pred_x, &pred_y);
281
282 h263_encode_motion(s, motion_x - pred_x);
283 h263_encode_motion(s, motion_y - pred_y);
284
285 /* encode each block */
286 for (i = 0; i < 6; i++) {
287 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);
288 }
289 } else {
290 int dc_diff[6]; //dc values with the dc prediction subtracted
291 int dir[6]; //prediction direction
292 int zigzag_last_index[6];
293 UINT8 *scan_table[6];
294
295 for(i=0; i<6; i++){
296 const int level= block[i][0];
297 UINT16 *dc_ptr;
298
299 dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
300 if (i < 4) {
301 *dc_ptr = level * s->y_dc_scale;
302 } else {
303 *dc_ptr = level * s->c_dc_scale;
304 }
305 }
306
307 s->ac_pred= decide_ac_pred(s, block, dir);
308
309 if(s->ac_pred){
310 for(i=0; i<6; i++){
311 UINT8 *st;
312 int last_index;
313
314 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
315 if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
316 else st = ff_alternate_horizontal_scan; /* top */
317
318 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
319 if(block[i][st[last_index]]) break;
320 zigzag_last_index[i]= s->block_last_index[i];
321 s->block_last_index[i]= last_index;
322 scan_table[i]= st;
323 }
324 }else{
325 for(i=0; i<6; i++)
326 scan_table[i]= zigzag_direct;
327 }
328
329 /* compute cbp */
330 cbp = 0;
331 for (i = 0; i < 6; i++) {
332 if (s->block_last_index[i] >= 1)
333 cbp |= 1 << (5 - i);
334 }
335
336 cbpc = cbp & 3;
337 if (s->pict_type == I_TYPE) {
338 put_bits(&s->pb,
339 intra_MCBPC_bits[cbpc],
340 intra_MCBPC_code[cbpc]);
341 } else {
342 put_bits(&s->pb, 1, 0); /* mb coded */
343 put_bits(&s->pb,
344 inter_MCBPC_bits[cbpc + 4],
345 inter_MCBPC_code[cbpc + 4]);
346 }
347 put_bits(&s->pb, 1, s->ac_pred);
348 cbpy = cbp >> 2;
349 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
350
351 /* encode each block */
352 for (i = 0; i < 6; i++) {
353 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]);
354 }
355
356 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
357 if(s->ac_pred){
358 for(i=0; i<6; i++){
359 int j;
360 int x, y, wrap;
361 INT16 *ac_val;
362
363 if (i < 4) {
364 x = 2 * s->mb_x + 1 + (i & 1);
365 y = 2 * s->mb_y + 1 + (i >> 1);
366 wrap = s->mb_width * 2 + 2;
367 ac_val = s->ac_val[0][0];
368 } else {
369 x = s->mb_x + 1;
370 y = s->mb_y + 1;
371 wrap = s->mb_width + 2;
372 ac_val = s->ac_val[i - 4 + 1][0];
373 }
374 ac_val += ((y) * wrap + (x)) * 16;
375
376 if(dir[i]){
377 for(j=1; j<8; j++)
378 block[i][block_permute_op(j )]= ac_val[j+8];
379 }else{
380 for(j=1; j<8; j++)
381 block[i][block_permute_op(j<<3)]= ac_val[j ];
382 }
383 s->block_last_index[i]= zigzag_last_index[i];
384 }
385 }
386 }
387 }
388
199 void h263_encode_mb(MpegEncContext * s, 389 void h263_encode_mb(MpegEncContext * s,
200 DCTELEM block[6][64], 390 DCTELEM block[6][64],
201 int motion_x, int motion_y) 391 int motion_x, int motion_y)
202 { 392 {
203 int cbpc, cbpy, i, cbp, pred_x, pred_y; 393 int cbpc, cbpy, i, cbp, pred_x, pred_y;
266 } 456 }
267 457
268 /* encode each block */ 458 /* encode each block */
269 if (s->h263_pred) { 459 if (s->h263_pred) {
270 for (i = 0; i < 6; i++) { 460 for (i = 0; i < 6; i++) {
271 mpeg4_encode_block(s, block[i], i); 461 // mpeg4_encode_block(s, block[i], i);
272 } 462 }
273 } else { 463 } else {
274 for (i = 0; i < 6; i++) { 464 for (i = 0; i < 6; i++) {
275 h263_encode_block(s, block[i], i); 465 h263_encode_block(s, block[i], i);
276 } 466 }
277 } 467 }
278 } 468 }
279
280 469
281 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n) 470 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
282 { 471 {
283 int x, y, wrap, a, c, pred_dc, scale, i; 472 int x, y, wrap, a, c, pred_dc, scale, i;
284 INT16 *dc_val, *ac_val, *ac_val1; 473 INT16 *dc_val, *ac_val, *ac_val1;
664 // printf("****frame %d\n", picture_number); 853 // printf("****frame %d\n", picture_number);
665 } 854 }
666 855
667 void h263_dc_scale(MpegEncContext * s) 856 void h263_dc_scale(MpegEncContext * s)
668 { 857 {
858 #if 1
859 const static UINT8 y_tab[32]={
860 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
861 0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46
862 };
863 const static UINT8 c_tab[32]={
864 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
865 0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25
866 };
867 s->y_dc_scale = y_tab[s->qscale];
868 s->c_dc_scale = c_tab[s->qscale];
869 #else
669 int quant; 870 int quant;
670
671 quant = s->qscale; 871 quant = s->qscale;
672 /* luminance */ 872 /* luminance */
673 if (quant < 5) 873 if (quant < 5)
674 s->y_dc_scale = 8; 874 s->y_dc_scale = 8;
675 else if (quant > 4 && quant < 9) 875 else if (quant > 4 && quant < 9)
683 s->c_dc_scale = 8; 883 s->c_dc_scale = 8;
684 else if (quant > 4 && quant < 25) 884 else if (quant > 4 && quant < 25)
685 s->c_dc_scale = ((quant + 13) / 2); 885 s->c_dc_scale = ((quant + 13) / 2);
686 else 886 else
687 s->c_dc_scale = (quant - 6); 887 s->c_dc_scale = (quant - 6);
688 } 888 #endif
689 889 }
690 static int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr) 890
891 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
691 { 892 {
692 int a, b, c, xy, wrap, pred, scale; 893 int a, b, c, xy, wrap, pred, scale;
693 UINT16 *dc_val; 894 UINT16 *dc_val;
895 int dummy;
694 896
695 /* find prediction */ 897 /* find prediction */
696 if (n < 4) { 898 if (n < 4) {
697 wrap = s->mb_width * 2 + 2; 899 wrap = s->mb_width * 2 + 2;
698 xy = 2 * s->mb_y + 1 + ((n & 2) >> 1); 900 xy = 2 * s->mb_y + 1 + (n >> 1);
699 xy *= wrap; 901 xy *= wrap;
700 xy += 2 * s->mb_x + 1 + (n & 1); 902 xy += 2 * s->mb_x + 1 + (n & 1);
701 dc_val = s->dc_val[0]; 903 dc_val = s->dc_val[0];
702 scale = s->y_dc_scale; 904 scale = s->y_dc_scale;
703 } else { 905 } else {
722 } else { 924 } else {
723 pred = a; 925 pred = a;
724 *dir_ptr = 0; /* left */ 926 *dir_ptr = 0; /* left */
725 } 927 }
726 /* we assume pred is positive */ 928 /* we assume pred is positive */
929 #ifdef ARCH_X86
930 asm volatile (
931 "xorl %%edx, %%edx \n\t"
932 "mul %%ecx \n\t"
933 : "=d" (pred), "=a"(dummy)
934 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
935 );
936 #else
727 pred = (pred + (scale >> 1)) / scale; 937 pred = (pred + (scale >> 1)) / scale;
938 #endif
728 939
729 /* prepare address for prediction update */ 940 /* prepare address for prediction update */
730 *dc_val_ptr = &dc_val[xy]; 941 *dc_val_ptr = &dc_val[xy];
731 942
732 return pred; 943 return pred;
739 INT16 *ac_val, *ac_val1; 950 INT16 *ac_val, *ac_val1;
740 951
741 /* find prediction */ 952 /* find prediction */
742 if (n < 4) { 953 if (n < 4) {
743 x = 2 * s->mb_x + 1 + (n & 1); 954 x = 2 * s->mb_x + 1 + (n & 1);
744 y = 2 * s->mb_y + 1 + ((n & 2) >> 1); 955 y = 2 * s->mb_y + 1 + (n >> 1);
745 wrap = s->mb_width * 2 + 2; 956 wrap = s->mb_width * 2 + 2;
746 ac_val = s->ac_val[0][0]; 957 ac_val = s->ac_val[0][0];
747 } else { 958 } else {
748 x = s->mb_x + 1; 959 x = s->mb_x + 1;
749 y = s->mb_y + 1; 960 y = s->mb_y + 1;
773 /* top copy */ 984 /* top copy */
774 for(i=1;i<8;i++) 985 for(i=1;i<8;i++)
775 ac_val1[8 + i] = block[block_permute_op(i)]; 986 ac_val1[8 + i] = block[block_permute_op(i)];
776 } 987 }
777 988
778 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr) 989 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
779 { 990 int dir)
780 int size, v, pred; 991 {
781 UINT16 *dc_val; 992 int x, y, wrap, i;
782 993 INT16 *ac_val;
783 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); 994
995 /* find prediction */
784 if (n < 4) { 996 if (n < 4) {
785 *dc_val = level * s->y_dc_scale; 997 x = 2 * s->mb_x + 1 + (n & 1);
998 y = 2 * s->mb_y + 1 + (n >> 1);
999 wrap = s->mb_width * 2 + 2;
1000 ac_val = s->ac_val[0][0];
786 } else { 1001 } else {
787 *dc_val = level * s->c_dc_scale; 1002 x = s->mb_x + 1;
788 } 1003 y = s->mb_y + 1;
789 1004 wrap = s->mb_width + 2;
790 /* do the prediction */ 1005 ac_val = s->ac_val[n - 4 + 1][0];
791 level -= pred; 1006 }
1007 ac_val += ((y) * wrap + (x)) * 16;
1008
1009 if (dir == 0) {
1010 /* left prediction */
1011 ac_val -= 16;
1012 for(i=1;i<8;i++) {
1013 block[block_permute_op(i*8)] -= ac_val[i];
1014 }
1015 } else {
1016 /* top prediction */
1017 ac_val -= 16 * wrap;
1018 for(i=1;i<8;i++) {
1019 block[block_permute_op(i)] -= ac_val[i + 8];
1020 }
1021 }
1022 }
1023
1024
1025 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
1026 {
1027 int size, v;
792 /* find number of bits */ 1028 /* find number of bits */
793 size = 0; 1029 size = 0;
794 v = abs(level); 1030 v = abs(level);
795 while (v) { 1031 while (v) {
796 v >>= 1; 1032 v >>= 1;
813 if (size > 8) 1049 if (size > 8)
814 put_bits(&s->pb, 1, 1); 1050 put_bits(&s->pb, 1, 1);
815 } 1051 }
816 } 1052 }
817 1053
818 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) 1054 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
819 { 1055 {
820 int level, run, last, i, j, last_index, last_non_zero, sign, slevel; 1056 int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
821 int code, dc_pred_dir; 1057 int code;
822 const RLTable *rl; 1058 const RLTable *rl;
823 1059
824 if (s->mb_intra) { 1060 if (s->mb_intra) {
825 /* mpeg4 based DC predictor */ 1061 /* mpeg4 based DC predictor */
826 mpeg4_encode_dc(s, block[0], n, &dc_pred_dir); 1062 mpeg4_encode_dc(s, intra_dc, n);
827 i = 1; 1063 i = 1;
828 rl = &rl_intra; 1064 rl = &rl_intra;
829 } else { 1065 } else {
830 i = 0; 1066 i = 0;
831 rl = &rl_inter; 1067 rl = &rl_inter;
833 1069
834 /* AC coefs */ 1070 /* AC coefs */
835 last_index = s->block_last_index[n]; 1071 last_index = s->block_last_index[n];
836 last_non_zero = i - 1; 1072 last_non_zero = i - 1;
837 for (; i <= last_index; i++) { 1073 for (; i <= last_index; i++) {
838 j = zigzag_direct[i]; 1074 j = scan_table[i];
839 level = block[j]; 1075 level = block[j];
840 if (level) { 1076 if (level) {
841 run = i - last_non_zero - 1; 1077 run = i - last_non_zero - 1;
842 last = (i == last_index); 1078 last = (i == last_index);
843 sign = 0; 1079 sign = 0;
1447 i++; 1683 i++;
1448 } 1684 }
1449 not_coded: 1685 not_coded:
1450 if (s->mb_intra && s->h263_aic) { 1686 if (s->mb_intra && s->h263_aic) {
1451 h263_pred_acdc(s, block, n); 1687 h263_pred_acdc(s, block, n);
1452 i = 64; 1688 i = 63;
1453 } 1689 }
1454 s->block_last_index[n] = i; 1690 s->block_last_index[n] = i;
1455 return 0; 1691 return 0;
1456 } 1692 }
1457 1693
2096 s->time= (s->last_non_b_time[1]/s->time_increment_resolution + time_incr)*s->time_increment_resolution; 2332 s->time= (s->last_non_b_time[1]/s->time_increment_resolution + time_incr)*s->time_increment_resolution;
2097 s->time+= s->time_increment; 2333 s->time+= s->time_increment;
2098 } 2334 }
2099 2335
2100 if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){ 2336 if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
2101 int i;
2102 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n"); 2337 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
2103 for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){ 2338 for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
2104 if(get_bits1(&s->gb)) break; 2339 if(get_bits1(&s->gb)) break;
2105 } 2340 }
2106 printf("my guess is %d bits ;)\n",s->time_increment_bits); 2341 printf("my guess is %d bits ;)\n",s->time_increment_bits);