* modules/stream_out/transrate: Rewrote the transrater to use a SAD error
[vlc.git] / modules / stream_out / transrate / block.c
1 /*****************************************************************************
2  * block.c: MPEG2 video transrating module
3  *****************************************************************************
4  * Copyright (C) 2003-2004 VideoLAN
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>
8  * $Id: frame.c,v 1.2 2004/03/03 11:39:06 massiot Exp $
9  *
10  * Authors: Christophe Massiot <massiot@via.ecp.fr>
11  *          Laurent Aimar <fenrir@via.ecp.fr>
12  *          Antoine Missout
13  *          Michel Lespinasse <walken@zoy.org>
14  *          Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
15  *
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.
20  *
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.
25  *
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  *****************************************************************************/
30
31 /*****************************************************************************
32  * Preamble
33  *****************************************************************************/
34 #include <stdio.h>
35 #include <stdlib.h>
36 #define NDEBUG 1
37 #include <assert.h>
38 #include <math.h>
39
40 #include <vlc/vlc.h>
41 #include <vlc/sout.h>
42 #include <vlc/input.h>
43
44 #include "transrate.h"
45
46 /****************************************************************************
47  * transrater, code from M2VRequantizer http://www.metakine.com/
48  ****************************************************************************/
49
50 /////---- begin ext mpeg code
51
52 #include "getvlc.h"
53 #include "putvlc.h"
54
55 static inline int saturate( int i_value )
56 {
57     if ( i_value > 2047 )
58         return 2047;
59     if ( i_value < -2048 )
60         return -2048;
61     return i_value;
62 }
63
64 static int64_t get_score( const RunLevel *blk, RunLevel *new_blk, int i_qscale, int i_qscale_new )
65 {
66     int64_t score = 0;
67     int i1 = -1, i2 = -1;
68
69     while ( new_blk->level )
70     {
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 )
75         {
76             int64_t tmp = saturate(level * i_qscale) 
77                             - saturate(new_level * i_qscale_new);
78             i1 += blk->run;
79             i2 += new_blk->run;
80             score += tmp * tmp;
81             blk++;
82             new_blk++;
83         }
84         else
85         {
86             int64_t tmp = saturate(level * i_qscale);
87             i1 += blk->run;
88             score += tmp * tmp;
89             blk++;
90         }
91     }
92
93     while ( blk->level )
94     {
95         int level = blk->level;
96         int64_t tmp = saturate(level * i_qscale);
97         i1 += blk->run;
98         score += tmp * tmp;
99         blk++;
100     }
101
102     return score;
103 }
104
105 static void change_qscale( const RunLevel *blk, RunLevel *new_blk, int i_qscale, int i_qscale_new, int intra )
106 {
107     int i = 0, li = 0;
108     int rounding;
109     if ( intra )
110         rounding = i_qscale_new / 3;
111     else
112         rounding = i_qscale_new / 6;
113
114     while ( blk->level )
115     {
116         int level = blk->level > 0 ? blk->level : -blk->level;
117         int new_level = saturate(level * i_qscale) / i_qscale_new;
118         i += blk->run;
119
120         if ( new_level )
121         {
122             new_blk->run = i - li;
123             new_blk->level = blk->level > 0 ? new_level : -new_level;
124             new_blk++;
125             li = i;
126         }
127         blk++;
128     }
129     new_blk->level = 0;
130 }
131
132 static const uint8_t non_linear_mquant_table[32] =
133 {
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
138 };
139 static const uint8_t map_non_linear_mquant[113] =
140 {
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
146 };
147
148 int scale_quant( transrate_t *tr, double qrate )
149 {
150     int i_quant = (int)floor( tr->quantizer_scale * qrate + 0.5 );
151
152     if ( tr->q_scale_type )
153     {
154         if ( i_quant < 1 )
155             i_quant = 1;
156         if ( i_quant > 112 )
157             i_quant = 112;
158         i_quant = non_linear_mquant_table[map_non_linear_mquant[i_quant]];
159     }
160     else
161     {
162         if ( i_quant < 2 )
163             i_quant = 2;
164         if ( i_quant > 62 )
165             i_quant = 62;
166         i_quant = (i_quant / 2) * 2; // Must be *even*
167     }
168
169     return i_quant;
170 }
171
172 int increment_quant( transrate_t *tr, int i_quant )
173 {
174     if ( tr->q_scale_type )
175     {
176         assert( i_quant >= 1 && i_quant <= 112 );
177         i_quant = map_non_linear_mquant[i_quant] + 1;
178         if ( i_quant > 31 )
179             i_quant = 31;
180         i_quant = non_linear_mquant_table[i_quant];
181     }
182     else
183     {
184         assert(!(i_quant & 1));
185         i_quant += 2;
186         if ( i_quant > 62 )
187             i_quant = 62;
188     }
189     return i_quant;
190 }
191
192
193 static int decrement_quant( transrate_t *tr, int i_quant )
194 {
195     if ( tr->q_scale_type )
196     {
197         assert( i_quant >= 1 && i_quant <= 112 );
198         i_quant = map_non_linear_mquant[i_quant] - 1;
199         if ( i_quant < 1 )
200             i_quant = 1;
201         i_quant = non_linear_mquant_table[i_quant];
202     }
203     else
204     {
205         assert(!(i_quant & 1));
206         i_quant -= 2;
207         if ( i_quant < 2 )
208             i_quant = 2;
209     }
210     return i_quant;
211 }
212
213 static void quantize_block( transrate_t *tr, RunLevel *new_blk, int intra )
214 {
215     RunLevel old_blk[65];
216     RunLevel *blk = old_blk;
217     const uint8_t *old_matrix, *new_matrix;
218     int i = 0, li = 0;
219
220     memcpy( blk, new_blk, 65 * sizeof(RunLevel) );
221     if ( intra )
222     {
223         old_matrix = tr->intra_quantizer_matrix;
224         new_matrix = mpeg4_default_intra_matrix;
225     }
226     else
227     {
228         old_matrix = tr->non_intra_quantizer_matrix;
229         new_matrix = mpeg4_default_non_intra_matrix;
230     }
231
232     while ( blk->level )
233     {
234         int level = blk->level > 0 ? blk->level : -blk->level;
235         int new_level = (level * old_matrix[i] + new_matrix[i]/2)
236                             / new_matrix[i];
237         i += blk->run;
238
239         if (new_level)
240         {
241             new_blk->run = i - li;
242             new_blk->level = blk->level > 0 ? new_level : -new_level;
243             new_blk++;
244             li = i;
245         }
246         blk++;
247     }
248     new_blk->level = 0;
249 }
250
251 int transrate_mb( transrate_t *tr, RunLevel blk[6][65], RunLevel new_blk[6][65],
252                   int i_cbp, int intra )
253 {
254     int i_qscale = tr->quantizer_scale;
255     int i_guessed_qscale = tr->new_quantizer_scale;
256     int64_t i_last_error = 0;
257     int i_last_qscale;
258     int i_last_qscale_same_error = 0;
259     int i_direction = 0;
260     int i_new_cbp;
261     int i_nb_blocks = 0;
262     int i_nb_coeffs = 0;
263     int i;
264
265     for ( i = 0; i < 6; i++ )
266     {
267         if ( i_cbp & (1 << (5 - i)) )
268         {
269             RunLevel *cur_blk = blk[i];
270             i_nb_blocks++;
271             while ( cur_blk->level )
272             {
273                 cur_blk++;
274                 i_nb_coeffs++;
275             }
276         }
277     }
278
279     /* See if we can change quantizer scale */
280     for ( ; ; )
281     {
282         int64_t i_error = 0;
283         i_new_cbp = 0;
284
285         for ( i = 0; i < 6; i++ )
286         {
287             if ( i_cbp & (1 << (5 - i)) )
288             {
289                 int64_t i_block_error;
290                 change_qscale( blk[i], new_blk[i], i_qscale, i_guessed_qscale,
291                                intra );
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));
299             }
300         }
301
302         if ( i_error >= (int64_t)tr->i_minimum_error
303                 && i_error <= (int64_t)tr->i_admissible_error )
304         {
305             break;
306         }
307         if ( i_nb_coeffs <= 15 && i_error <= (int64_t)tr->i_admissible_error )
308         {
309             /* There is no interest in changing the qscale (takes up 5 bits
310              * we won't regain) */
311             break;
312         }
313
314         if ( !i_direction )
315         {
316             if ( i_error > (int64_t)tr->i_admissible_error )
317             {
318                 i_direction = -1;
319                 i_last_qscale = i_guessed_qscale;
320                 i_guessed_qscale = decrement_quant( tr, i_guessed_qscale );
321             }
322             else
323             {
324                 i_direction = +1;
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;
329             }
330             if ( i_guessed_qscale == i_last_qscale )
331                 break;
332         }
333         else if ( i_direction < 0 )
334         {
335             if ( i_error > (int64_t)tr->i_admissible_error )
336             {
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 )
340                     break;
341             }
342             else
343             {
344                 break;
345             }
346         }
347         else
348         {
349             if ( i_error < (int64_t)tr->i_minimum_error )
350             {
351                 i_last_qscale = i_guessed_qscale;
352                 i_guessed_qscale = increment_quant( tr, i_guessed_qscale );
353                 if ( i_error > i_last_error )
354                 {
355                     i_last_error = i_error;
356                     i_last_qscale_same_error = i_last_qscale;
357                 }
358                 if ( i_guessed_qscale == i_last_qscale )
359                 {
360                     if ( i_last_error == i_error )
361                     {
362                         i_guessed_qscale = i_last_qscale_same_error;
363                         if ( i_guessed_qscale == i_qscale )
364                         {
365                             memcpy( new_blk, blk, sizeof(RunLevel)*65*6 );
366                             i_new_cbp = i_cbp;
367                         }
368                         else
369                         {
370                             i_new_cbp = 0;
371                             for ( i = 0; i < 6; i++ )
372                             {
373                                 if ( i_cbp & (1 << (5 - i)) )
374                                 {
375                                     change_qscale( blk[i], new_blk[i],
376                                                    i_qscale, i_guessed_qscale,
377                                                    intra );
378                                     if ( new_blk[i]->level )
379                                         i_new_cbp |= (1 << (5 - i));
380                                 }
381                             }
382                         }
383                     }
384                     break;
385                 }
386             }
387             else
388             {
389                 if ( i_error > (int64_t)tr->i_admissible_error
390                         || i_last_error == i_error )
391                 {
392                     i_guessed_qscale = i_last_qscale_same_error;
393                     if ( i_guessed_qscale == i_qscale )
394                     {
395                         memcpy( new_blk, blk, sizeof(RunLevel)*65*6 );
396                         i_new_cbp = i_cbp;
397                     }
398                     else
399                     {
400                         i_new_cbp = 0;
401                         for ( i = 0; i < 6; i++ )
402                         {
403                             if ( i_cbp & (1 << (5 - i)) )
404                             {
405                                 change_qscale( blk[i], new_blk[i],
406                                                i_qscale, i_guessed_qscale,
407                                                intra );
408                                 if ( new_blk[i]->level )
409                                     i_new_cbp |= (1 << (5 - i));
410                             }
411                         }
412                     }
413                 }
414                 break;
415             }
416         }
417     }
418
419     tr->new_quantizer_scale = i_guessed_qscale;
420
421 #if 0
422     /* Now see if we can drop coeffs */
423     for ( i = 0; i < 6; i++ )
424     {
425         if ( i_new_cbp & (1 << (5 - i)) )
426         {
427             for ( ; ; )
428             {
429                 RunLevel *last_blk = new_blk[i];
430                 uint8_t old_level;
431
432                 while ( last_blk[1].level )
433                     last_blk++;
434                 if ( last_blk == new_blk[i] )
435                     break;
436                 old_level = last_blk->level;
437                 last_blk->level = 0;
438                 i_error = get_score( blk[i], new_blk[i],
439                                      i_qscale, i_guessed_qscale );
440                 if ( i_error > tr->i_admissible_error )
441                 {
442                     last_blk->level = old_level;
443                     break;
444                 }
445             }
446         }
447     }
448 #endif
449
450     return i_new_cbp;
451 }
452
453 void get_intra_block_B14( transrate_t *tr, RunLevel *blk )
454 {
455     bs_transrate_t *bs = &tr->bs;
456     int i, li;
457     int val;
458     const DCTtab * tab;
459
460     li = i = 0;
461
462     for( ;; )
463     {
464         if (bs->i_bit_in_cache >= 0x28000000)
465         {
466             tab = DCT_B14AC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
467
468             i += tab->run;
469             if (i >= 64) break; /* end of block */
470
471     normal_code:
472             bs_flush( bs, tab->len );
473             val = tab->level;
474             val = (val ^ SBITS (bs->i_bit_in_cache, 1)) - SBITS (bs->i_bit_in_cache, 1);
475             blk->level = val;
476             blk->run = i - li - 1;
477             li = i;
478             blk++;
479
480             bs_flush( bs, 1 );
481             continue;
482         }
483         else if (bs->i_bit_in_cache >= 0x04000000)
484         {
485             tab = DCT_B14_8 + (UBITS (bs->i_bit_in_cache, 8) - 4);
486
487             i += tab->run;
488             if (i < 64) goto normal_code;
489
490             /* escape code */
491             i += (UBITS (bs->i_bit_in_cache, 12) & 0x3F) - 64;
492             if (i >= 64) break; /* illegal, check needed to avoid buffer overflow */
493
494             bs_flush( bs, 12 );
495             val = SBITS (bs->i_bit_in_cache, 12);
496             blk->level = val;
497             blk->run = i - li - 1;
498             li = i;
499             blk++;
500
501             bs_flush( bs, 12 );
502
503             continue;
504         }
505         else if (bs->i_bit_in_cache >= 0x02000000)
506         {
507             tab = DCT_B14_10 + (UBITS (bs->i_bit_in_cache, 10) - 8);
508             i += tab->run;
509             if (i < 64 ) goto normal_code;
510         }
511         else if (bs->i_bit_in_cache >= 0x00800000)
512         {
513             tab = DCT_13 + (UBITS (bs->i_bit_in_cache, 13) - 16);
514             i += tab->run;
515             if (i < 64 ) goto normal_code;
516         }
517         else if (bs->i_bit_in_cache >= 0x00200000)
518         {
519             tab = DCT_15 + (UBITS (bs->i_bit_in_cache, 15) - 16);
520             i += tab->run;
521             if (i < 64 ) goto normal_code;
522         }
523         else
524         {
525             tab = DCT_16 + UBITS (bs->i_bit_in_cache, 16);
526             bs_flush( bs, 16 );
527             i += tab->run;
528             if (i < 64 ) goto normal_code;
529         }
530         fprintf(stderr, "Err in B14\n");
531         tr->b_error = 1;
532         break;  /* illegal, check needed to avoid buffer overflow */
533     }
534     bs_flush( bs, 2 );    /* dump end of block code */
535     blk->level = 0;
536
537     if ( tr->mpeg4_matrix )
538         quantize_block( tr, blk, 1 );
539 }
540
541 void get_intra_block_B15( transrate_t *tr, RunLevel *blk )
542 {
543     bs_transrate_t *bs = &tr->bs;
544     int i, li;
545     int val;
546     const DCTtab * tab;
547
548     li = i = 0;
549
550     for( ;; )
551     {
552         if (bs->i_bit_in_cache >= 0x04000000)
553         {
554             tab = DCT_B15_8 + (UBITS (bs->i_bit_in_cache, 8) - 4);
555
556             i += tab->run;
557             if (i < 64)
558             {
559     normal_code:
560                 bs_flush( bs, tab->len );
561
562                 val = tab->level;
563                 val = (val ^ SBITS (bs->i_bit_in_cache, 1)) - SBITS (bs->i_bit_in_cache, 1);
564                 blk->level = val;
565                 blk->run = i - li - 1;
566                 li = i;
567                 blk++;
568
569                 bs_flush( bs, 1 );
570                 continue;
571             }
572             else
573             {
574                 i += (UBITS (bs->i_bit_in_cache, 12) & 0x3F) - 64;
575
576                 if (i >= 64) break; /* illegal, check against buffer overflow */
577
578                 bs_flush( bs, 12 );
579                 val = SBITS (bs->i_bit_in_cache, 12);
580                 blk->level = val;
581                 blk->run = i - li - 1;
582                 li = i;
583                 blk++;
584
585                 bs_flush( bs, 12 );
586                 continue;
587             }
588         }
589         else if (bs->i_bit_in_cache >= 0x02000000)
590         {
591             tab = DCT_B15_10 + (UBITS (bs->i_bit_in_cache, 10) - 8);
592             i += tab->run;
593             if (i < 64) goto normal_code;
594         }
595         else if (bs->i_bit_in_cache >= 0x00800000)
596         {
597             tab = DCT_13 + (UBITS (bs->i_bit_in_cache, 13) - 16);
598             i += tab->run;
599             if (i < 64) goto normal_code;
600         }
601         else if (bs->i_bit_in_cache >= 0x00200000)
602         {
603             tab = DCT_15 + (UBITS (bs->i_bit_in_cache, 15) - 16);
604             i += tab->run;
605             if (i < 64) goto normal_code;
606         }
607         else
608         {
609             tab = DCT_16 + UBITS (bs->i_bit_in_cache, 16);
610             bs_flush( bs, 16 );
611             i += tab->run;
612             if (i < 64) goto normal_code;
613         }
614         fprintf(stderr, "Err in B15\n");
615         tr->b_error = 1;
616         break;  /* illegal, check needed to avoid buffer overflow */
617     }
618     bs_flush( bs, 4 );    /* dump end of block code */
619     blk->level = 0;
620
621     if ( tr->mpeg4_matrix )
622         quantize_block( tr, blk, 1 );
623 }
624
625
626 int get_non_intra_block( transrate_t *tr, RunLevel *blk )
627 {
628     bs_transrate_t *bs = &tr->bs;
629     int i, li;
630     int val;
631     const DCTtab * tab;
632
633     li = i = -1;
634
635     if (bs->i_bit_in_cache >= 0x28000000)
636     {
637         tab = DCT_B14DC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
638         goto entry_1;
639     }
640     else goto entry_2;
641
642     for( ;; )
643     {
644         if (bs->i_bit_in_cache >= 0x28000000)
645         {
646             tab = DCT_B14AC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
647
648     entry_1:
649             i += tab->run;
650             if (i >= 64)
651             break;  /* end of block */
652
653     normal_code:
654
655             bs_flush( bs, tab->len );
656             val = tab->level;
657             val = (val ^ SBITS (bs->i_bit_in_cache, 1)) - SBITS (bs->i_bit_in_cache, 1);
658             blk->level = val;
659             blk->run = i - li - 1;
660             li = i;
661             blk++;
662
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);
665
666             bs_flush( bs, 1 );
667             continue;
668         }
669
670     entry_2:
671         if (bs->i_bit_in_cache >= 0x04000000)
672         {
673             tab = DCT_B14_8 + (UBITS (bs->i_bit_in_cache, 8) - 4);
674
675             i += tab->run;
676             if (i < 64) goto normal_code;
677
678             /* escape code */
679
680             i += (UBITS (bs->i_bit_in_cache, 12) & 0x3F) - 64;
681
682             if (i >= 64) break; /* illegal, check needed to avoid buffer overflow */
683
684             bs_flush( bs, 12 );
685             val = SBITS (bs->i_bit_in_cache, 12);
686             blk->level = val;
687             blk->run = i - li - 1;
688             li = i;
689             blk++;
690
691             bs_flush( bs, 12 );
692             continue;
693         }
694         else if (bs->i_bit_in_cache >= 0x02000000)
695         {
696             tab = DCT_B14_10 + (UBITS (bs->i_bit_in_cache, 10) - 8);
697             i += tab->run;
698             if (i < 64) goto normal_code;
699         }
700         else if (bs->i_bit_in_cache >= 0x00800000)
701         {
702             tab = DCT_13 + (UBITS (bs->i_bit_in_cache, 13) - 16);
703             i += tab->run;
704             if (i < 64) goto normal_code;
705         }
706         else if (bs->i_bit_in_cache >= 0x00200000)
707         {
708             tab = DCT_15 + (UBITS (bs->i_bit_in_cache, 15) - 16);
709             i += tab->run;
710             if (i < 64) goto normal_code;
711         }
712         else
713         {
714             tab = DCT_16 + UBITS (bs->i_bit_in_cache, 16);
715             bs_flush( bs, 16 );
716
717             i += tab->run;
718             if (i < 64) goto normal_code;
719         }
720         fprintf(stderr, "Err in non-intra\n");
721         tr->b_error = 1;
722         break;  /* illegal, check needed to avoid buffer overflow */
723     }
724     bs_flush( bs, 2 );    /* dump end of block code */
725     blk->level = 0;
726
727     if ( tr->mpeg4_matrix )
728         quantize_block( tr, blk, 0 );
729
730     return i;
731 }
732
733 static inline void putAC( bs_transrate_t *bs, int run, int signed_level, int vlcformat)
734 {
735     int level, len;
736     const VLCtable *ptab = NULL;
737
738     level = (signed_level<0) ? -signed_level : signed_level; /* abs(signed_level) */
739
740     assert(!(run<0 || run>63 || level==0 || level>2047));
741
742     len = 0;
743
744     if (run<2 && level<41)
745     {
746         if (vlcformat)  ptab = &dct_code_tab1a[run][level-1];
747         else ptab = &dct_code_tab1[run][level-1];
748         len = ptab->len;
749     }
750     else if (run<32 && level<6)
751     {
752         if (vlcformat) ptab = &dct_code_tab2a[run-2][level-1];
753         else ptab = &dct_code_tab2[run-2][level-1];
754         len = ptab->len;
755     }
756
757     if (len) /* a VLC code exists */
758     {
759         bs_write( bs, ptab->code, len);
760         bs_write( bs, signed_level<0, 1); /* sign */
761     }
762     else
763     {
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);
767     }
768 }
769
770
771 static inline void putACfirst( bs_transrate_t *bs, int run, int val)
772 {
773     if (run==0 && (val==1 || val==-1)) bs_write( bs, 2|(val<0), 2 );
774     else putAC( bs, run, val, 0);
775 }
776
777 void putnonintrablk( bs_transrate_t *bs, RunLevel *blk)
778 {
779     assert(blk->level);
780
781     putACfirst( bs, blk->run, blk->level );
782     blk++;
783
784     while (blk->level)
785     {
786         putAC( bs, blk->run, blk->level, 0 );
787         blk++;
788     }
789
790     bs_write( bs, 2, 2 );
791 }
792
793 void putintrablk( bs_transrate_t *bs, RunLevel *blk, int vlcformat)
794 {
795     while (blk->level)
796     {
797         putAC( bs, blk->run, blk->level, vlcformat );
798         blk++;
799     }
800
801     if (vlcformat)
802         bs_write( bs, 6, 4 );
803     else
804         bs_write( bs, 2, 2 );
805 }
806