1 /*****************************************************************************
2 * block.c: MPEG2 video transrating module
3 *****************************************************************************
4 * Copyright (C) 2003-2004 VideoLAN (Centrale Réseaux) and its contributors
5 * Copyright (C) 2003 Antoine Missout
6 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
7 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
10 * Authors: Christophe Massiot <massiot@via.ecp.fr>
11 * Laurent Aimar <fenrir@via.ecp.fr>
13 * Michel Lespinasse <walken@zoy.org>
14 * Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
29 *****************************************************************************/
31 /*****************************************************************************
33 *****************************************************************************/
42 #include <vlc/input.h>
44 #include "transrate.h"
46 /****************************************************************************
47 * transrater, code from M2VRequantizer http://www.metakine.com/
48 ****************************************************************************/
50 /////---- begin ext mpeg code
55 static inline int saturate( int i_value )
59 if ( i_value < -2048 )
64 static int64_t get_score( const RunLevel *blk, RunLevel *new_blk, int i_qscale, int i_qscale_new )
69 while ( new_blk->level )
71 int new_level = new_blk->level;
72 int level = blk->level;
73 if ( i1 > 64 || i2 > 64 || !blk->run || !new_blk->run ) return score;
74 if ( i1 + blk->run == i2 + new_blk->run )
76 int64_t tmp = saturate(level * i_qscale)
77 - saturate(new_level * i_qscale_new);
86 int64_t tmp = saturate(level * i_qscale);
95 int level = blk->level;
96 int64_t tmp = saturate(level * i_qscale);
105 static void change_qscale( const RunLevel *blk, RunLevel *new_blk, int i_qscale, int i_qscale_new, int intra )
110 rounding = i_qscale_new / 3;
112 rounding = i_qscale_new / 6;
116 int level = blk->level > 0 ? blk->level : -blk->level;
117 int new_level = saturate(level * i_qscale) / i_qscale_new;
122 new_blk->run = i - li;
123 new_blk->level = blk->level > 0 ? new_level : -new_level;
132 static const uint8_t non_linear_mquant_table[32] =
134 0, 1, 2, 3, 4, 5, 6, 7,
135 8,10,12,14,16,18,20,22,
136 24,28,32,36,40,44,48,52,
137 56,64,72,80,88,96,104,112
139 static const uint8_t map_non_linear_mquant[113] =
141 0,1,2,3,4,5,6,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,
142 16,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,22,22,
143 22,22,23,23,23,23,24,24,24,24,24,24,24,25,25,25,25,25,25,25,26,26,
144 26,26,26,26,26,26,27,27,27,27,27,27,27,27,28,28,28,28,28,28,28,29,
145 29,29,29,29,29,29,29,29,29,30,30,30,30,30,30,30,31,31,31,31,31
148 int scale_quant( transrate_t *tr, double qrate )
150 int i_quant = (int)floor( tr->quantizer_scale * qrate + 0.5 );
152 if ( tr->q_scale_type )
158 i_quant = non_linear_mquant_table[map_non_linear_mquant[i_quant]];
166 i_quant = (i_quant / 2) * 2; // Must be *even*
172 int increment_quant( transrate_t *tr, int i_quant )
174 if ( tr->q_scale_type )
176 assert( i_quant >= 1 && i_quant <= 112 );
177 i_quant = map_non_linear_mquant[i_quant] + 1;
180 i_quant = non_linear_mquant_table[i_quant];
184 assert(!(i_quant & 1));
193 static int decrement_quant( transrate_t *tr, int i_quant )
195 if ( tr->q_scale_type )
197 assert( i_quant >= 1 && i_quant <= 112 );
198 i_quant = map_non_linear_mquant[i_quant] - 1;
201 i_quant = non_linear_mquant_table[i_quant];
205 assert(!(i_quant & 1));
213 static void quantize_block( transrate_t *tr, RunLevel *new_blk, int intra )
215 RunLevel old_blk[65];
216 RunLevel *blk = old_blk;
217 const uint8_t *old_matrix, *new_matrix;
220 memcpy( blk, new_blk, 65 * sizeof(RunLevel) );
223 old_matrix = tr->intra_quantizer_matrix;
224 new_matrix = mpeg4_default_intra_matrix;
228 old_matrix = tr->non_intra_quantizer_matrix;
229 new_matrix = mpeg4_default_non_intra_matrix;
234 int level = blk->level > 0 ? blk->level : -blk->level;
235 int new_level = (level * old_matrix[i] + new_matrix[i]/2)
241 new_blk->run = i - li;
242 new_blk->level = blk->level > 0 ? new_level : -new_level;
251 int transrate_mb( transrate_t *tr, RunLevel blk[6][65], RunLevel new_blk[6][65],
252 int i_cbp, int intra )
254 int i_qscale = tr->quantizer_scale;
255 int i_guessed_qscale = tr->new_quantizer_scale;
256 int64_t i_last_error = 0;
258 int i_last_qscale_same_error = 0;
265 for ( i = 0; i < 6; i++ )
267 if ( i_cbp & (1 << (5 - i)) )
269 RunLevel *cur_blk = blk[i];
271 while ( cur_blk->level )
279 /* See if we can change quantizer scale */
285 for ( i = 0; i < 6; i++ )
287 if ( i_cbp & (1 << (5 - i)) )
289 int64_t i_block_error;
290 change_qscale( blk[i], new_blk[i], i_qscale, i_guessed_qscale,
292 i_block_error = get_score( blk[i], new_blk[i],
293 i_qscale, i_guessed_qscale );
294 if ( i > 3 ) i_block_error *= 4;
295 if ( i_block_error > i_error )
296 i_error = i_block_error;
297 if ( new_blk[i]->level )
298 i_new_cbp |= (1 << (5 - i));
302 if ( i_error >= (int64_t)tr->i_minimum_error
303 && i_error <= (int64_t)tr->i_admissible_error )
307 if ( i_nb_coeffs <= 15 && i_error <= (int64_t)tr->i_admissible_error )
309 /* There is no interest in changing the qscale (takes up 5 bits
310 * we won't regain) */
316 if ( i_error > (int64_t)tr->i_admissible_error )
319 i_last_qscale = i_guessed_qscale;
320 i_guessed_qscale = decrement_quant( tr, i_guessed_qscale );
325 i_last_qscale = i_guessed_qscale;
326 i_guessed_qscale = increment_quant( tr, i_guessed_qscale );
327 i_last_error = i_error;
328 i_last_qscale_same_error = i_last_qscale;
330 if ( i_guessed_qscale == i_last_qscale )
333 else if ( i_direction < 0 )
335 if ( i_error > (int64_t)tr->i_admissible_error )
337 i_last_qscale = i_guessed_qscale;
338 i_guessed_qscale = decrement_quant( tr, i_guessed_qscale );
339 if ( i_guessed_qscale == i_last_qscale )
349 if ( i_error < (int64_t)tr->i_minimum_error )
351 i_last_qscale = i_guessed_qscale;
352 i_guessed_qscale = increment_quant( tr, i_guessed_qscale );
353 if ( i_error > i_last_error )
355 i_last_error = i_error;
356 i_last_qscale_same_error = i_last_qscale;
358 if ( i_guessed_qscale == i_last_qscale )
360 if ( i_last_error == i_error )
362 i_guessed_qscale = i_last_qscale_same_error;
363 if ( i_guessed_qscale == i_qscale )
365 memcpy( new_blk, blk, sizeof(RunLevel)*65*6 );
371 for ( i = 0; i < 6; i++ )
373 if ( i_cbp & (1 << (5 - i)) )
375 change_qscale( blk[i], new_blk[i],
376 i_qscale, i_guessed_qscale,
378 if ( new_blk[i]->level )
379 i_new_cbp |= (1 << (5 - i));
389 if ( i_error > (int64_t)tr->i_admissible_error
390 || i_last_error == i_error )
392 i_guessed_qscale = i_last_qscale_same_error;
393 if ( i_guessed_qscale == i_qscale )
395 memcpy( new_blk, blk, sizeof(RunLevel)*65*6 );
401 for ( i = 0; i < 6; i++ )
403 if ( i_cbp & (1 << (5 - i)) )
405 change_qscale( blk[i], new_blk[i],
406 i_qscale, i_guessed_qscale,
408 if ( new_blk[i]->level )
409 i_new_cbp |= (1 << (5 - i));
419 tr->new_quantizer_scale = i_guessed_qscale;
422 /* Now see if we can drop coeffs */
423 for ( i = 0; i < 6; i++ )
425 if ( i_new_cbp & (1 << (5 - i)) )
429 RunLevel *last_blk = new_blk[i];
432 while ( last_blk[1].level )
434 if ( last_blk == new_blk[i] )
436 old_level = last_blk->level;
438 i_error = get_score( blk[i], new_blk[i],
439 i_qscale, i_guessed_qscale );
440 if ( i_error > tr->i_admissible_error )
442 last_blk->level = old_level;
453 void get_intra_block_B14( transrate_t *tr, RunLevel *blk )
455 bs_transrate_t *bs = &tr->bs;
464 if (bs->i_bit_in_cache >= 0x28000000)
466 tab = DCT_B14AC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
469 if (i >= 64) break; /* end of block */
472 bs_flush( bs, tab->len );
474 val = (val ^ SBITS (bs->i_bit_in_cache, 1)) - SBITS (bs->i_bit_in_cache, 1);
476 blk->run = i - li - 1;
483 else if (bs->i_bit_in_cache >= 0x04000000)
485 tab = DCT_B14_8 + (UBITS (bs->i_bit_in_cache, 8) - 4);
488 if (i < 64) goto normal_code;
491 i += (UBITS (bs->i_bit_in_cache, 12) & 0x3F) - 64;
492 if (i >= 64) break; /* illegal, check needed to avoid buffer overflow */
495 val = SBITS (bs->i_bit_in_cache, 12);
497 blk->run = i - li - 1;
505 else if (bs->i_bit_in_cache >= 0x02000000)
507 tab = DCT_B14_10 + (UBITS (bs->i_bit_in_cache, 10) - 8);
509 if (i < 64 ) goto normal_code;
511 else if (bs->i_bit_in_cache >= 0x00800000)
513 tab = DCT_13 + (UBITS (bs->i_bit_in_cache, 13) - 16);
515 if (i < 64 ) goto normal_code;
517 else if (bs->i_bit_in_cache >= 0x00200000)
519 tab = DCT_15 + (UBITS (bs->i_bit_in_cache, 15) - 16);
521 if (i < 64 ) goto normal_code;
525 tab = DCT_16 + UBITS (bs->i_bit_in_cache, 16);
528 if (i < 64 ) goto normal_code;
530 fprintf(stderr, "Err in B14\n");
532 break; /* illegal, check needed to avoid buffer overflow */
534 bs_flush( bs, 2 ); /* dump end of block code */
537 if ( tr->mpeg4_matrix )
538 quantize_block( tr, blk, 1 );
541 void get_intra_block_B15( transrate_t *tr, RunLevel *blk )
543 bs_transrate_t *bs = &tr->bs;
552 if (bs->i_bit_in_cache >= 0x04000000)
554 tab = DCT_B15_8 + (UBITS (bs->i_bit_in_cache, 8) - 4);
560 bs_flush( bs, tab->len );
563 val = (val ^ SBITS (bs->i_bit_in_cache, 1)) - SBITS (bs->i_bit_in_cache, 1);
565 blk->run = i - li - 1;
574 i += (UBITS (bs->i_bit_in_cache, 12) & 0x3F) - 64;
576 if (i >= 64) break; /* illegal, check against buffer overflow */
579 val = SBITS (bs->i_bit_in_cache, 12);
581 blk->run = i - li - 1;
589 else if (bs->i_bit_in_cache >= 0x02000000)
591 tab = DCT_B15_10 + (UBITS (bs->i_bit_in_cache, 10) - 8);
593 if (i < 64) goto normal_code;
595 else if (bs->i_bit_in_cache >= 0x00800000)
597 tab = DCT_13 + (UBITS (bs->i_bit_in_cache, 13) - 16);
599 if (i < 64) goto normal_code;
601 else if (bs->i_bit_in_cache >= 0x00200000)
603 tab = DCT_15 + (UBITS (bs->i_bit_in_cache, 15) - 16);
605 if (i < 64) goto normal_code;
609 tab = DCT_16 + UBITS (bs->i_bit_in_cache, 16);
612 if (i < 64) goto normal_code;
614 fprintf(stderr, "Err in B15\n");
616 break; /* illegal, check needed to avoid buffer overflow */
618 bs_flush( bs, 4 ); /* dump end of block code */
621 if ( tr->mpeg4_matrix )
622 quantize_block( tr, blk, 1 );
626 int get_non_intra_block( transrate_t *tr, RunLevel *blk )
628 bs_transrate_t *bs = &tr->bs;
635 if (bs->i_bit_in_cache >= 0x28000000)
637 tab = DCT_B14DC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
644 if (bs->i_bit_in_cache >= 0x28000000)
646 tab = DCT_B14AC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
651 break; /* end of block */
655 bs_flush( bs, tab->len );
657 val = (val ^ SBITS (bs->i_bit_in_cache, 1)) - SBITS (bs->i_bit_in_cache, 1);
659 blk->run = i - li - 1;
663 //if ( ((val) && (tab->level < tst)) || ((!val) && (tab->level >= tst)) )
664 // LOGF("level: %i val: %i tst : %i q: %i nq : %i\n", tab->level, val, tst, q, nq);
671 if (bs->i_bit_in_cache >= 0x04000000)
673 tab = DCT_B14_8 + (UBITS (bs->i_bit_in_cache, 8) - 4);
676 if (i < 64) goto normal_code;
680 i += (UBITS (bs->i_bit_in_cache, 12) & 0x3F) - 64;
682 if (i >= 64) break; /* illegal, check needed to avoid buffer overflow */
685 val = SBITS (bs->i_bit_in_cache, 12);
687 blk->run = i - li - 1;
694 else if (bs->i_bit_in_cache >= 0x02000000)
696 tab = DCT_B14_10 + (UBITS (bs->i_bit_in_cache, 10) - 8);
698 if (i < 64) goto normal_code;
700 else if (bs->i_bit_in_cache >= 0x00800000)
702 tab = DCT_13 + (UBITS (bs->i_bit_in_cache, 13) - 16);
704 if (i < 64) goto normal_code;
706 else if (bs->i_bit_in_cache >= 0x00200000)
708 tab = DCT_15 + (UBITS (bs->i_bit_in_cache, 15) - 16);
710 if (i < 64) goto normal_code;
714 tab = DCT_16 + UBITS (bs->i_bit_in_cache, 16);
718 if (i < 64) goto normal_code;
720 fprintf(stderr, "Err in non-intra\n");
722 break; /* illegal, check needed to avoid buffer overflow */
724 bs_flush( bs, 2 ); /* dump end of block code */
727 if ( tr->mpeg4_matrix )
728 quantize_block( tr, blk, 0 );
733 static inline void putAC( bs_transrate_t *bs, int run, int signed_level, int vlcformat)
736 const VLCtable *ptab = NULL;
738 level = (signed_level<0) ? -signed_level : signed_level; /* abs(signed_level) */
740 assert(!(run<0 || run>63 || level==0 || level>2047));
744 if (run<2 && level<41)
746 if (vlcformat) ptab = &dct_code_tab1a[run][level-1];
747 else ptab = &dct_code_tab1[run][level-1];
750 else if (run<32 && level<6)
752 if (vlcformat) ptab = &dct_code_tab2a[run-2][level-1];
753 else ptab = &dct_code_tab2[run-2][level-1];
757 if (len) /* a VLC code exists */
759 bs_write( bs, ptab->code, len);
760 bs_write( bs, signed_level<0, 1); /* sign */
764 bs_write( bs, 1l, 6); /* Escape */
765 bs_write( bs, run, 6); /* 6 bit code for run */
766 bs_write( bs, ((unsigned int)signed_level) & 0xFFF, 12);
771 static inline void putACfirst( bs_transrate_t *bs, int run, int val)
773 if (run==0 && (val==1 || val==-1)) bs_write( bs, 2|(val<0), 2 );
774 else putAC( bs, run, val, 0);
777 void putnonintrablk( bs_transrate_t *bs, RunLevel *blk)
781 putACfirst( bs, blk->run, blk->level );
786 putAC( bs, blk->run, blk->level, 0 );
790 bs_write( bs, 2, 2 );
793 void putintrablk( bs_transrate_t *bs, RunLevel *blk, int vlcformat)
797 putAC( bs, blk->run, blk->level, vlcformat );
802 bs_write( bs, 6, 4 );
804 bs_write( bs, 2, 2 );