Mercurial > libavcodec.hg
comparison h263.c @ 2003:16ac9630317d libavcodec
mpeg4 dc prediction simplification
dc cliping fix
author | michael |
---|---|
date | Wed, 05 May 2004 00:14:22 +0000 |
parents | 7bd3932bc918 |
children | ec6bfd8d92fc |
comparison
equal
deleted
inserted
replaced
2002:b737b5e96ee0 | 2003:16ac9630317d |
---|---|
74 #ifdef CONFIG_ENCODERS | 74 #ifdef CONFIG_ENCODERS |
75 static void mpeg4_encode_visual_object_header(MpegEncContext * s); | 75 static void mpeg4_encode_visual_object_header(MpegEncContext * s); |
76 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number); | 76 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number); |
77 #endif //CONFIG_ENCODERS | 77 #endif //CONFIG_ENCODERS |
78 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb); | 78 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb); |
79 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr); | 79 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding); |
80 | 80 |
81 #ifdef CONFIG_ENCODERS | 81 #ifdef CONFIG_ENCODERS |
82 static uint8_t uni_DCtab_lum_len[512]; | 82 static uint8_t uni_DCtab_lum_len[512]; |
83 static uint8_t uni_DCtab_chrom_len[512]; | 83 static uint8_t uni_DCtab_chrom_len[512]; |
84 static uint16_t uni_DCtab_lum_bits[512]; | 84 static uint16_t uni_DCtab_lum_bits[512]; |
1071 int zigzag_last_index[6]; | 1071 int zigzag_last_index[6]; |
1072 uint8_t *scan_table[6]; | 1072 uint8_t *scan_table[6]; |
1073 int i; | 1073 int i; |
1074 | 1074 |
1075 for(i=0; i<6; i++){ | 1075 for(i=0; i<6; i++){ |
1076 const int level= block[i][0]; | 1076 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1); |
1077 uint16_t *dc_ptr; | |
1078 | |
1079 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]); | |
1080 if (i < 4) { | |
1081 *dc_ptr = level * s->y_dc_scale; | |
1082 } else { | |
1083 *dc_ptr = level * s->c_dc_scale; | |
1084 } | |
1085 } | 1077 } |
1086 | 1078 |
1087 if(s->flags & CODEC_FLAG_AC_PRED){ | 1079 if(s->flags & CODEC_FLAG_AC_PRED){ |
1088 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); | 1080 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); |
1089 if(!s->ac_pred) | 1081 if(!s->ac_pred) |
2380 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ]; | 2372 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ]; |
2381 } | 2373 } |
2382 | 2374 |
2383 /** | 2375 /** |
2384 * predicts the dc. | 2376 * predicts the dc. |
2377 * encoding quantized level -> quantized diff | |
2378 * decoding quantized diff -> quantized level | |
2385 * @param n block index (0-3 are luma, 4-5 are chroma) | 2379 * @param n block index (0-3 are luma, 4-5 are chroma) |
2386 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here | |
2387 * @param dir_ptr pointer to an integer where the prediction direction will be stored | 2380 * @param dir_ptr pointer to an integer where the prediction direction will be stored |
2388 * @return the quantized predicted dc | |
2389 */ | 2381 */ |
2390 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr) | 2382 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding) |
2391 { | 2383 { |
2392 int a, b, c, wrap, pred, scale; | 2384 int a, b, c, wrap, pred, scale, ret; |
2393 uint16_t *dc_val; | 2385 uint16_t *dc_val; |
2394 | 2386 |
2395 /* find prediction */ | 2387 /* find prediction */ |
2396 if (n < 4) { | 2388 if (n < 4) { |
2397 scale = s->y_dc_scale; | 2389 scale = s->y_dc_scale; |
2429 *dir_ptr = 0; /* left */ | 2421 *dir_ptr = 0; /* left */ |
2430 } | 2422 } |
2431 /* we assume pred is positive */ | 2423 /* we assume pred is positive */ |
2432 pred = FASTDIV((pred + (scale >> 1)), scale); | 2424 pred = FASTDIV((pred + (scale >> 1)), scale); |
2433 | 2425 |
2434 /* prepare address for prediction update */ | 2426 if(encoding){ |
2435 *dc_val_ptr = &dc_val[0]; | 2427 ret = level - pred; |
2436 | 2428 }else{ |
2437 return pred; | 2429 level += pred; |
2430 ret= level; | |
2431 if(s->error_resilience>=3){ | |
2432 if(level<0){ | |
2433 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); | |
2434 return -1; | |
2435 } | |
2436 if(level*scale > 2048 + scale){ | |
2437 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); | |
2438 return -1; | |
2439 } | |
2440 } | |
2441 } | |
2442 level *=scale; | |
2443 if(level&(~2047)) level= level<0 ? 0 : 2047; | |
2444 dc_val[0]= level; | |
2445 | |
2446 return ret; | |
2438 } | 2447 } |
2439 | 2448 |
2440 /** | 2449 /** |
2441 * predicts the ac. | 2450 * predicts the ac. |
2442 * @param n block index (0-3 are luma, 4-5 are chroma) | 2451 * @param n block index (0-3 are luma, 4-5 are chroma) |
4535 * @param dir_ptr the prediction direction will be stored here | 4544 * @param dir_ptr the prediction direction will be stored here |
4536 * @return the quantized dc | 4545 * @return the quantized dc |
4537 */ | 4546 */ |
4538 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) | 4547 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
4539 { | 4548 { |
4540 int level, pred, code; | 4549 int level, code; |
4541 uint16_t *dc_val; | |
4542 | 4550 |
4543 if (n < 4) | 4551 if (n < 4) |
4544 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); | 4552 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
4545 else | 4553 else |
4546 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); | 4554 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
4571 return -1; | 4579 return -1; |
4572 } | 4580 } |
4573 } | 4581 } |
4574 } | 4582 } |
4575 } | 4583 } |
4576 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); | 4584 |
4577 level += pred; | 4585 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0); |
4578 if (level < 0){ | |
4579 if(s->error_resilience>=3){ | |
4580 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); | |
4581 return -1; | |
4582 } | |
4583 level = 0; | |
4584 } | |
4585 if (n < 4) { | |
4586 *dc_val = level * s->y_dc_scale; | |
4587 } else { | |
4588 *dc_val = level * s->c_dc_scale; | |
4589 } | |
4590 if(IS_3IV1) | |
4591 *dc_val = level * 8; | |
4592 | |
4593 if(s->error_resilience>=3){ | |
4594 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){ | |
4595 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); | |
4596 return -1; | |
4597 } | |
4598 } | |
4599 return level; | |
4600 } | 4586 } |
4601 | 4587 |
4602 /** | 4588 /** |
4603 * decodes a block. | 4589 * decodes a block. |
4604 * @return <0 if an error occured | 4590 * @return <0 if an error occured |
4840 CLOSE_READER(re, &s->gb); | 4826 CLOSE_READER(re, &s->gb); |
4841 } | 4827 } |
4842 not_coded: | 4828 not_coded: |
4843 if (intra) { | 4829 if (intra) { |
4844 if(s->qscale >= s->intra_dc_threshold){ | 4830 if(s->qscale >= s->intra_dc_threshold){ |
4845 uint16_t *dc_val; | 4831 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0); |
4846 block[0] += ff_mpeg4_pred_dc(s, n, &dc_val, &dc_pred_dir); | 4832 |
4847 if (n < 4) { | |
4848 *dc_val = block[0] * s->y_dc_scale; | |
4849 } else { | |
4850 *dc_val = block[0] * s->c_dc_scale; | |
4851 } | |
4852 | |
4853 if(i == -1) i=0; | 4833 if(i == -1) i=0; |
4854 } | 4834 } |
4855 | 4835 |
4856 mpeg4_pred_ac(s, block, n, dc_pred_dir); | 4836 mpeg4_pred_ac(s, block, n, dc_pred_dir); |
4857 if (s->ac_pred) { | 4837 if (s->ac_pred) { |