Renamed playlist "playlist-current" to "item-current".
[vlc.git] / modules / stream_out / transrate / frame.c
1 /*****************************************************************************
2  * frame.c: MPEG2 video transrating module
3  *****************************************************************************
4  * Copyright (C) 2003-2004 the VideoLAN team
5  * Copyright (C) 2003 Antoine Missout <antoine.missout@metakine.com>
6  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
7  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
8  * $Id$
9  *
10  * Authors: Christophe Massiot <massiot@via.ecp.fr>
11  *          Laurent Aimar <fenrir@via.ecp.fr>
12  *          Antoine Missout <antoine.missout@metakine.com>
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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
29  *****************************************************************************/
30
31 /*****************************************************************************
32  * Preamble
33  *****************************************************************************/
34 #define NDEBUG 1
35 #ifdef HAVE_CONFIG_H
36 # include "config.h"
37 #endif
38
39 #include <assert.h>
40 #include <math.h>
41
42 #include <vlc_common.h>
43 #include <vlc_sout.h>
44 #include <vlc_codec.h>
45
46 #include "transrate.h"
47
48 /****************************************************************************
49  * transrater, code from M2VRequantizer http://www.metakine.com/
50  ****************************************************************************/
51
52 // useful constants
53 enum
54 {
55     I_TYPE = 1,
56     P_TYPE = 2,
57     B_TYPE = 3
58 };
59
60
61 /////---- begin ext mpeg code
62
63 #include "putvlc.h"
64
65 #include "getvlc.h"
66
67 static const int non_linear_quantizer_scale [] =
68 {
69      0,  1,  2,  3,  4,  5,   6,   7,
70      8, 10, 12, 14, 16, 18,  20,  22,
71     24, 28, 32, 36, 40, 44,  48,  52,
72     56, 64, 72, 80, 88, 96, 104, 112
73 };
74
75 static inline int get_macroblock_modes( transrate_t *tr )
76 {
77     bs_transrate_t *bs = &tr->bs;
78
79     int macroblock_modes;
80     const MBtab * tab;
81
82     switch( tr->picture_coding_type )
83     {
84         case I_TYPE:
85
86             tab = MB_I + UBITS (bs->i_bit_in_cache, 1);
87             bs_flush( bs, tab->len );
88             macroblock_modes = tab->modes;
89
90             if ((!(tr->frame_pred_frame_dct)) && (tr->picture_structure == FRAME_PICTURE))
91             {
92                 macroblock_modes |= UBITS (bs->i_bit_in_cache, 1) * DCT_TYPE_INTERLACED;
93                 bs_flush( bs, 1 );
94             }
95
96             return macroblock_modes;
97
98         case P_TYPE:
99
100             tab = MB_P + UBITS (bs->i_bit_in_cache, 5);
101             bs_flush( bs, tab->len );
102             macroblock_modes = tab->modes;
103
104             if (tr->picture_structure != FRAME_PICTURE)
105             {
106                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
107                 {
108                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
109                     bs_flush( bs, 2 );
110                 }
111                 return macroblock_modes;
112             }
113             else if (tr->frame_pred_frame_dct)
114             {
115                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
116                     macroblock_modes |= MC_FRAME;
117                 return macroblock_modes;
118             }
119             else
120             {
121                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
122                 {
123                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
124                     bs_flush( bs, 2 );
125                 }
126                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
127                 {
128                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 1) * DCT_TYPE_INTERLACED;
129                     bs_flush( bs, 1 );
130                 }
131                 return macroblock_modes;
132             }
133
134         case B_TYPE:
135
136             tab = MB_B + UBITS (bs->i_bit_in_cache, 6);
137             bs_flush( bs, tab->len );
138             macroblock_modes = tab->modes;
139
140             if( tr->picture_structure != FRAME_PICTURE)
141             {
142                 if (! (macroblock_modes & MACROBLOCK_INTRA))
143                 {
144                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
145                     bs_flush( bs, 2 );
146                 }
147                 return macroblock_modes;
148             }
149             else if (tr->frame_pred_frame_dct)
150             {
151                 /* if (! (macroblock_modes & MACROBLOCK_INTRA)) */
152                 macroblock_modes |= MC_FRAME;
153                 return macroblock_modes;
154             }
155             else
156             {
157                 if (macroblock_modes & MACROBLOCK_INTRA) goto intra;
158                 macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
159                 bs_flush( bs, 2 );
160                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
161                 {
162                     intra:
163                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 1) * DCT_TYPE_INTERLACED;
164                     bs_flush( bs, 1 );
165                 }
166                 return macroblock_modes;
167             }
168
169         default:
170             return 0;
171     }
172
173 }
174
175 static inline int get_quantizer_scale( transrate_t *tr )
176 {
177     bs_transrate_t *bs = &tr->bs;
178
179     int quantizer_scale_code;
180
181     quantizer_scale_code = UBITS (bs->i_bit_in_cache, 5);
182     bs_flush( bs, 5 );
183
184     if( tr->q_scale_type )
185         return non_linear_quantizer_scale[quantizer_scale_code];
186     else
187         return quantizer_scale_code << 1;
188 }
189
190 static inline int get_motion_delta( bs_transrate_t *bs, const int f_code )
191 {
192     int delta;
193     int sign;
194     const MVtab * tab;
195
196     if (bs->i_bit_in_cache & 0x80000000)
197     {
198         bs_copy( bs, 1 );
199         return 0;
200     }
201     else if (bs->i_bit_in_cache >= 0x0c000000)
202     {
203
204         tab = MV_4 + UBITS (bs->i_bit_in_cache, 4);
205         delta = (tab->delta << f_code) + 1;
206         bs_copy( bs, tab->len);
207
208         sign = SBITS (bs->i_bit_in_cache, 1);
209         bs_copy( bs, 1 );
210
211         if (f_code)
212         {
213             delta += UBITS (bs->i_bit_in_cache, f_code);
214             bs_copy( bs, f_code);
215         }
216
217         return (delta ^ sign) - sign;
218     }
219     else
220     {
221
222         tab = MV_10 + UBITS (bs->i_bit_in_cache, 10);
223         delta = (tab->delta << f_code) + 1;
224         bs_copy( bs, tab->len);
225
226         sign = SBITS (bs->i_bit_in_cache, 1);
227         bs_copy( bs, 1);
228
229         if (f_code)
230         {
231             delta += UBITS (bs->i_bit_in_cache, f_code);
232             bs_copy( bs, f_code);
233         }
234
235         return (delta ^ sign) - sign;
236     }
237 }
238
239
240 static inline int get_dmv( bs_transrate_t *bs )
241 {
242     const DMVtab * tab;
243
244     tab = DMV_2 + UBITS (bs->i_bit_in_cache, 2);
245     bs_copy( bs, tab->len);
246     return tab->dmv;
247 }
248
249 static inline int get_coded_block_pattern( bs_transrate_t *bs )
250 {
251     const CBPtab * tab;
252
253     if (bs->i_bit_in_cache >= 0x20000000)
254     {
255         tab = CBP_7 + (UBITS (bs->i_bit_in_cache, 7) - 16);
256         bs_flush( bs, tab->len );
257         return tab->cbp;
258     }
259     else
260     {
261         tab = CBP_9 + UBITS (bs->i_bit_in_cache, 9);
262         bs_flush( bs, tab->len );
263         return tab->cbp;
264     }
265 }
266
267 static inline int get_luma_dc_dct_diff( bs_transrate_t *bs, uint32_t *bits, uint8_t *len )
268 {
269     const DCtab * tab;
270     int size;
271     int dc_diff;
272
273     if (bs->i_bit_in_cache < 0xf8000000)
274     {
275         tab = DC_lum_5 + UBITS (bs->i_bit_in_cache, 5);
276         size = tab->size;
277         if (size)
278         {
279             *bits = bs_read( bs, tab->len );
280             *len = tab->len;
281             //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
282             dc_diff = UBITS (bs->i_bit_in_cache, size);
283             if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
284             *bits <<= size;
285             *bits |= bs_read( bs, size );
286             *len += size;
287             return dc_diff;
288         }
289         else
290         {
291             *bits = bs_read( bs, 3 );
292             *len = 3;
293             return 0;
294         }
295     }
296     else
297     {
298         tab = DC_long + (UBITS (bs->i_bit_in_cache, 9) - 0x1e0);
299         size = tab->size;
300         *bits = bs_read( bs, tab->len );
301         *len = tab->len;
302         //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
303         dc_diff = UBITS (bs->i_bit_in_cache, size);
304         if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
305         *bits <<= size;
306         *bits |= bs_read( bs, size );
307         *len += size;
308         return dc_diff;
309     }
310 }
311
312 static inline int get_chroma_dc_dct_diff( bs_transrate_t *bs, uint32_t *bits, uint8_t *len )
313 {
314     const DCtab * tab;
315     int size;
316     int dc_diff;
317
318     if (bs->i_bit_in_cache < 0xf8000000)
319     {
320         tab = DC_chrom_5 + UBITS (bs->i_bit_in_cache, 5);
321         size = tab->size;
322         if (size)
323         {
324             *bits = bs_read( bs, tab->len );
325             *len = tab->len;
326             //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
327             dc_diff = UBITS (bs->i_bit_in_cache, size);
328             if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
329             *bits <<= size;
330             *bits |= bs_read( bs, size );
331             *len += size;
332             return dc_diff;
333         }
334         else
335         {
336             *bits = bs_read( bs, 2 );
337             *len = 2;
338             return 0;
339         }
340     }
341     else
342     {
343         tab = DC_long + (UBITS (bs->i_bit_in_cache, 10) - 0x3e0);
344         size = tab->size;
345         *bits = bs_read( bs, tab->len + 1 );
346         *len = tab->len + 1;
347         //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
348         dc_diff = UBITS (bs->i_bit_in_cache, size);
349         if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
350         *bits <<= size;
351         *bits |= bs_read( bs, size );
352         *len += size;
353         return dc_diff;
354     }
355 }
356
357 static void motion_fr_frame( bs_transrate_t *bs, unsigned int f_code[2] )
358 {
359     get_motion_delta( bs, f_code[0] );
360     get_motion_delta( bs, f_code[1] );
361 }
362
363 static void motion_fr_field( bs_transrate_t *bs, unsigned int f_code[2] )
364 {
365     bs_copy( bs, 1);
366
367     get_motion_delta( bs, f_code[0]);
368     get_motion_delta( bs, f_code[1]);
369
370     bs_copy( bs, 1);
371
372     get_motion_delta( bs, f_code[0]);
373     get_motion_delta( bs, f_code[1]);
374 }
375
376 static void motion_fr_dmv( bs_transrate_t *bs, unsigned int f_code[2] )
377 {
378     get_motion_delta( bs, f_code[0]);
379     get_dmv( bs );
380
381     get_motion_delta( bs, f_code[1]);
382     get_dmv( bs );
383 }
384
385 static void motion_fi_field( bs_transrate_t *bs, unsigned int f_code[2] )
386 {
387     bs_copy( bs, 1);
388
389     get_motion_delta( bs, f_code[0]);
390     get_motion_delta( bs, f_code[1]);
391 }
392
393 static void motion_fi_16x8( bs_transrate_t *bs, unsigned int f_code[2] )
394 {
395     bs_copy( bs, 1);
396
397     get_motion_delta( bs, f_code[0]);
398     get_motion_delta( bs, f_code[1]);
399
400     bs_copy( bs, 1);
401
402     get_motion_delta( bs, f_code[0]);
403     get_motion_delta( bs, f_code[1]);
404 }
405
406 static void motion_fi_dmv( bs_transrate_t *bs, unsigned int f_code[2] )
407 {
408     get_motion_delta( bs, f_code[0]);
409     get_dmv( bs );
410
411     get_motion_delta( bs, f_code[1]);
412     get_dmv( bs );
413 }
414
415
416 #define MOTION_CALL(routine,direction)                      \
417 do {                                                        \
418     if ((direction) & MACROBLOCK_MOTION_FORWARD)            \
419         routine( bs, tr->f_code[0]);                        \
420     if ((direction) & MACROBLOCK_MOTION_BACKWARD)           \
421         routine( bs, tr->f_code[1]);                        \
422 } while (0)
423
424 #define NEXT_MACROBLOCK                                         \
425 do {                                                            \
426     tr->h_offset += 16;                                         \
427     if( tr->h_offset == tr->horizontal_size_value)              \
428     {                                                           \
429         tr->v_offset += 16;                                         \
430         if (tr->v_offset > (tr->vertical_size_value - 16)) return;      \
431         tr->h_offset = 0;                                       \
432     }                                                           \
433 } while (0)
434
435 static void putmbdata( transrate_t *tr, int macroblock_modes )
436 {
437     bs_transrate_t *bs = &tr->bs;
438
439     bs_write( bs,
440               mbtypetab[tr->picture_coding_type-1][macroblock_modes&0x1F].code,
441               mbtypetab[tr->picture_coding_type-1][macroblock_modes&0x1F].len);
442
443     switch ( tr->picture_coding_type )
444     {
445         case I_TYPE:
446             if ((! (tr->frame_pred_frame_dct)) && (tr->picture_structure == FRAME_PICTURE))
447                 bs_write( bs, macroblock_modes & DCT_TYPE_INTERLACED ? 1 : 0, 1);
448             break;
449
450         case P_TYPE:
451             if (tr->picture_structure != FRAME_PICTURE)
452             {
453                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
454                     bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
455                 break;
456             }
457             else if (tr->frame_pred_frame_dct) break;
458             else
459             {
460                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
461                     bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
462                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
463                     bs_write( bs, macroblock_modes & DCT_TYPE_INTERLACED ? 1 : 0, 1);
464                 break;
465             }
466
467         case B_TYPE:
468             if (tr->picture_structure != FRAME_PICTURE)
469             {
470                 if (! (macroblock_modes & MACROBLOCK_INTRA))
471                     bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
472                 break;
473             }
474             else if (tr->frame_pred_frame_dct) break;
475             else
476             {
477                 if (macroblock_modes & MACROBLOCK_INTRA) goto intra;
478                 bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
479                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
480                 {
481                     intra:
482                     bs_write( bs, macroblock_modes & DCT_TYPE_INTERLACED ? 1 : 0, 1);
483                 }
484                 break;
485             }
486     }
487 }
488
489 static const uint8_t map_non_linear_mquant[113] =
490 {
491     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,
492     16,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,22,22,
493     22,22,23,23,23,23,24,24,24,24,24,24,24,25,25,25,25,25,25,25,26,26,
494     26,26,26,26,26,26,27,27,27,27,27,27,27,27,28,28,28,28,28,28,28,29,
495     29,29,29,29,29,29,29,29,29,30,30,30,30,30,30,30,31,31,31,31,31
496 };
497 static inline void put_quantiser( transrate_t *tr )
498 {
499     bs_transrate_t *bs = &tr->bs;
500
501     bs_write( bs, tr->q_scale_type ? map_non_linear_mquant[tr->new_quantizer_scale] : tr->new_quantizer_scale >> 1, 5 );
502     tr->last_coded_scale = tr->new_quantizer_scale;
503 }
504
505 /* generate variable length code for macroblock_address_increment (6.3.16) */
506 static inline void putaddrinc( transrate_t *tr, int addrinc )
507 {
508     bs_transrate_t *bs = &tr->bs;
509
510     while ( addrinc >= 33 )
511     {
512         bs_write( bs, 0x08, 11 ); /* macroblock_escape */
513         addrinc -= 33;
514     }
515
516     bs_write( bs, addrinctab[addrinc].code, addrinctab[addrinc].len );
517 }
518
519 static int slice_init( transrate_t *tr,  int code )
520 {
521     bs_transrate_t *bs = &tr->bs;
522     int offset;
523     const MBAtab * mba;
524
525     tr->v_offset = (code - 1) * 16;
526
527     tr->quantizer_scale = get_quantizer_scale( tr );
528     if ( tr->new_quantizer_scale < tr->quantizer_scale )
529         tr->new_quantizer_scale = scale_quant( tr, tr->qrate );
530
531     /*LOGF("************************\nstart of slice %i in %s picture. ori quant: %i new quant: %i\n", code,
532         (picture_coding_type == I_TYPE ? "I_TYPE" : (picture_coding_type == P_TYPE ? "P_TYPE" : "B_TYPE")),
533         quantizer_scale, new_quantizer_scale);*/
534
535     /* ignore intra_slice and all the extra data */
536     while (bs->i_bit_in_cache & 0x80000000)
537     {
538         bs_flush( bs, 9 );
539     }
540
541     /* decode initial macroblock address increment */
542     offset = 0;
543     for( ;; )
544     {
545         if (bs->i_bit_in_cache >= 0x08000000)
546         {
547             mba = MBA_5 + (UBITS (bs->i_bit_in_cache, 6) - 2);
548             break;
549         }
550         else if (bs->i_bit_in_cache >= 0x01800000)
551         {
552             mba = MBA_11 + (UBITS (bs->i_bit_in_cache, 12) - 24);
553             break;
554         }
555         else if( UBITS (bs->i_bit_in_cache, 12 ) == 8 )
556         {
557             /* macroblock_escape */
558             offset += 33;
559             bs_flush(bs, 11);
560         }
561         else
562         {
563             return -1;
564         }
565     }
566
567     bs_flush(bs, mba->len + 1);
568     tr->h_offset = (offset + mba->mba) << 4;
569
570     while( tr->h_offset - (int)tr->horizontal_size_value >= 0)
571     {
572         tr->h_offset -= tr->horizontal_size_value;
573         tr->v_offset += 16;
574     }
575
576     if( tr->v_offset > tr->vertical_size_value - 16 )
577     {
578         return -1;
579     }
580     return (offset + mba->mba);
581 }
582
583 static void mpeg2_slice( transrate_t *tr, const int code )
584 {
585     bs_transrate_t *bs = &tr->bs;
586     int mba_inc;
587     int first_in_slice = 1;
588
589     if( (mba_inc = slice_init( tr, code )) < 0 )
590     {
591         return;
592     }
593
594     for( ;; )
595     {
596         const MBAtab * mba;
597         int macroblock_modes;
598         int mba_local;
599         int i;
600
601         while (unlikely(bs->i_bit_in < 24)) bs_refill( bs );
602
603         macroblock_modes = get_macroblock_modes( tr );
604         if (macroblock_modes & MACROBLOCK_QUANT)
605             tr->quantizer_scale = get_quantizer_scale( tr );
606         if (tr->new_quantizer_scale < tr->quantizer_scale)
607             tr->new_quantizer_scale = scale_quant( tr, tr->qrate );
608
609         //LOGF("blk %i : ", h_offset >> 4);
610
611         if (macroblock_modes & MACROBLOCK_INTRA)
612         {
613             RunLevel block[6][65]; // terminated by level = 0, so we need 64+1
614             RunLevel new_block[6][65]; // terminated by level = 0, so we need 64+1
615             uint32_t dc[6];
616             uint8_t  dc_len[6];
617
618             // begin saving data
619             int batb;
620             uint8_t   p_n_ow[32], *p_n_w,
621                     *p_o_ow = bs->p_ow, *p_o_w = bs->p_w;
622             uint32_t  i_n_bit_out, i_n_bit_out_cache,
623                     i_o_bit_out  = bs->i_bit_out, i_o_bit_out_cache = bs->i_bit_out_cache;
624
625             bs->i_bit_out_cache = 0; bs->i_bit_out = BITS_IN_BUF;
626             bs->p_ow = bs->p_w = p_n_ow;
627
628             //LOG("intra "); if (macroblock_modes & MACROBLOCK_QUANT) LOGF("got new quant: %i ", quantizer_scale);
629
630             if (tr->concealment_motion_vectors)
631             {
632                 if (tr->picture_structure != FRAME_PICTURE)
633                 {
634                     bs_copy(bs, 1); /* remove field_select */
635                 }
636                 /* like motion_frame, but parsing without actual motion compensation */
637                 get_motion_delta(bs, tr->f_code[0][0]);
638                 get_motion_delta(bs, tr->f_code[0][1]);
639
640                 bs_copy(bs, 1); /* remove marker_bit */
641             }
642
643             assert(bs->p_w - bs->p_ow < 32);
644
645             p_n_w = bs->p_w;
646             i_n_bit_out = bs->i_bit_out;
647             i_n_bit_out_cache = bs->i_bit_out_cache;
648             assert(bs->p_ow == p_n_ow);
649
650             bs->i_bit_out = i_o_bit_out ;
651             bs->i_bit_out_cache = i_o_bit_out_cache;
652             bs->p_ow = p_o_ow;
653             bs->p_w = p_o_w;
654             // end saving data
655
656             if( tr->intra_vlc_format )
657             {
658                 /* Luma */
659                 for ( i = 0; i < 4; i++ )
660                 {
661                     get_luma_dc_dct_diff( bs, dc + i, dc_len + i );
662                     get_intra_block_B15( tr, block[i] );
663                     if (tr->b_error) return;
664                 }
665                 /* Chroma */
666                 for ( ; i < 6; i++ )
667                 {
668                     get_chroma_dc_dct_diff( bs, dc + i, dc_len + i );
669                     get_intra_block_B15( tr, block[i] );
670                     if (tr->b_error) return;
671                 }
672             }
673             else
674             {
675                 /* Luma */
676                 for ( i = 0; i < 4; i++ )
677                 {
678                     get_luma_dc_dct_diff( bs, dc + i, dc_len + i );
679                     get_intra_block_B14( tr, block[i] );
680                     if (tr->b_error) return;
681                 }
682                 /* Chroma */
683                 for ( ; i < 6; i++ )
684                 {
685                     get_chroma_dc_dct_diff( bs, dc + i, dc_len + i );
686                     get_intra_block_B14( tr, block[i] );
687                     if (tr->b_error) return;
688                 }
689             }
690
691             transrate_mb( tr, block, new_block, 0x3f, 1 );
692
693             if (tr->last_coded_scale == tr->new_quantizer_scale)
694                 macroblock_modes &= ~MACROBLOCK_QUANT;
695
696             if ( first_in_slice )
697             {
698                 put_quantiser( tr );
699                 bs_write( bs, 0, 1 );
700                 macroblock_modes &= ~MACROBLOCK_QUANT;
701             }
702             putaddrinc( tr, mba_inc );
703             mba_inc = 0;
704             putmbdata( tr, macroblock_modes );
705             if( macroblock_modes & MACROBLOCK_QUANT )
706             {
707                 put_quantiser( tr );
708             }
709
710             // put saved motion data...
711             for (batb = 0; batb < (p_n_w - p_n_ow); batb++)
712             {
713                 bs_write( bs, p_n_ow[batb], 8 );
714             }
715             bs_write( bs, i_n_bit_out_cache, BITS_IN_BUF - i_n_bit_out );
716             // end saved motion data...
717
718             for ( i = 0; i < 6; i++ )
719             {
720                 bs_write( bs, *(dc + i), *(dc_len + i) );
721                 putintrablk( bs, new_block[i], tr->intra_vlc_format );
722             }
723  
724         }
725         else
726         {
727             RunLevel block[6][65]; // terminated by level = 0, so we need 64+1
728             RunLevel new_block[6][65]; // terminated by level = 0, so we need 64+1
729             int new_coded_block_pattern = 0;
730             int cbp = 0;
731
732             // begin saving data
733             int batb;
734             uint8_t   p_n_ow[32], *p_n_w,
735                     *p_o_ow = bs->p_ow, *p_o_w = bs->p_w;
736             uint32_t  i_n_bit_out, i_n_bit_out_cache,
737                     i_o_bit_out  = bs->i_bit_out, i_o_bit_out_cache = bs->i_bit_out_cache;
738
739             bs->i_bit_out_cache = 0; bs->i_bit_out = BITS_IN_BUF;
740             bs->p_ow = bs->p_w = p_n_ow;
741
742             if (tr->picture_structure == FRAME_PICTURE)
743                 switch (macroblock_modes & MOTION_TYPE_MASK)
744                 {
745                     case MC_FRAME: MOTION_CALL (motion_fr_frame, macroblock_modes); break;
746                     case MC_FIELD: MOTION_CALL (motion_fr_field, macroblock_modes); break;
747                     case MC_DMV: MOTION_CALL (motion_fr_dmv, MACROBLOCK_MOTION_FORWARD); break;
748                 }
749             else
750                 switch (macroblock_modes & MOTION_TYPE_MASK)
751                 {
752                     case MC_FIELD: MOTION_CALL (motion_fi_field, macroblock_modes); break;
753                     case MC_16X8: MOTION_CALL (motion_fi_16x8, macroblock_modes); break;
754                     case MC_DMV: MOTION_CALL (motion_fi_dmv, MACROBLOCK_MOTION_FORWARD); break;
755                 }
756
757             //LOG("non intra "); if (macroblock_modes & MACROBLOCK_QUANT) LOGF("got new quant: %i ", quantizer_scale);
758
759             if (macroblock_modes & MACROBLOCK_PATTERN)
760             {
761                 int last_in_slice;
762
763                 cbp = get_coded_block_pattern( bs );
764
765                 for ( i = 0; i < 6; i++ )
766                 {
767                     if ( cbp & (1 << (5 - i)) )
768                     {
769                         get_non_intra_block( tr, block[i] );
770                         if (tr->b_error) return;
771                     }
772                 }
773                 last_in_slice = !UBITS( bs->i_bit_in_cache, 11 );
774
775                 new_coded_block_pattern = transrate_mb( tr, block, new_block,
776                                                         cbp, 0 );
777
778                 if ( !new_coded_block_pattern &&
779                         !(macroblock_modes
780                             & (MACROBLOCK_MOTION_FORWARD
781                                 | MACROBLOCK_MOTION_BACKWARD))
782                         && (first_in_slice || last_in_slice) )
783                 {
784                     /* First mb in slice, just code a 0-mv mb.
785                      * This is wrong for last in slice, but it only shows
786                      * a few artefacts. */
787                     macroblock_modes |= MACROBLOCK_MOTION_FORWARD;
788                     if (tr->picture_structure == FRAME_PICTURE)
789                     {
790                         macroblock_modes |= MC_FRAME;
791                         bs_write( bs, 0x3, 2 ); /* motion vectors */
792                     }
793                     else
794                     {
795                         macroblock_modes |= MC_FIELD;
796                         bs_write( bs,
797                              (tr->picture_structure == BOTTOM_FIELD ? 1 : 0),
798                              1); /* motion field select */
799                         bs_write( bs, 0x3, 2 ); /* motion vectors */
800                     }
801                 }
802
803                 if ( !new_coded_block_pattern )
804                 {
805                     macroblock_modes &= ~MACROBLOCK_PATTERN;
806                     macroblock_modes &= ~MACROBLOCK_QUANT;
807                 }
808                 else
809                 {
810                     if ( tr->last_coded_scale == tr->new_quantizer_scale )
811                     {
812                         macroblock_modes &= ~MACROBLOCK_QUANT;
813                     }
814                     else
815                     {
816                         macroblock_modes |= MACROBLOCK_QUANT;
817                     }
818                 }
819             }
820
821             assert(bs->p_w - bs->p_ow < 32);
822
823             p_n_w = bs->p_w;
824             i_n_bit_out = bs->i_bit_out;
825             i_n_bit_out_cache = bs->i_bit_out_cache;
826             assert(bs->p_ow == p_n_ow);
827
828             bs->i_bit_out = i_o_bit_out ;
829             bs->i_bit_out_cache = i_o_bit_out_cache;
830             bs->p_ow = p_o_ow;
831             bs->p_w = p_o_w;
832             // end saving data
833
834             if ( macroblock_modes &
835                     (MACROBLOCK_MOTION_FORWARD | MACROBLOCK_MOTION_BACKWARD
836                       | MACROBLOCK_PATTERN) )
837             {
838                 if ( first_in_slice )
839                 {
840                     put_quantiser( tr );
841                     bs_write( bs, 0, 1 );
842                     macroblock_modes &= ~MACROBLOCK_QUANT;
843                 }
844                 putaddrinc( tr, mba_inc );
845                 mba_inc = 0;
846                 putmbdata( tr, macroblock_modes );
847                 if ( macroblock_modes & MACROBLOCK_QUANT )
848                 {
849                     put_quantiser( tr );
850                 }
851
852                 // put saved motion data...
853                 for (batb = 0; batb < (p_n_w - p_n_ow); batb++)
854                 {
855                     bs_write( bs, p_n_ow[batb], 8 );
856                 }
857                 bs_write( bs, i_n_bit_out_cache, BITS_IN_BUF - i_n_bit_out);
858                 // end saved motion data...
859
860                 if (macroblock_modes & MACROBLOCK_PATTERN)
861                 {
862                     /* Write CBP */
863                     bs_write( bs, cbptable[new_coded_block_pattern].code,
864                               cbptable[new_coded_block_pattern].len );
865
866                     for ( i = 0; i < 6; i++ )
867                     {
868                         if ( new_coded_block_pattern & (1 << (5 - i)) )
869                         {
870                             putnonintrablk( bs, new_block[i] );
871                         }
872                     }
873                 }
874             }
875             else
876             {
877                 /* skipped macroblock */
878                 mba_inc++;
879             }
880         }
881
882         if (bs->p_c > bs->p_r || bs->p_w > bs->p_rw)
883         {
884             tr->b_error = 1;
885             return;
886         }
887         //LOGF("\n\to: %i c: %i n: %i\n", quantizer_scale, last_coded_scale, new_quantizer_scale);
888
889         NEXT_MACROBLOCK;
890
891         first_in_slice = 0;
892         mba_local = 0;
893         for ( ; ; )
894         {
895             if ( bs->i_bit_in_cache >= 0x10000000 )
896             {
897                 mba = MBA_5 + (UBITS (bs->i_bit_in_cache, 5) - 2);
898                 break;
899             }
900             else if ( bs->i_bit_in_cache >= 0x03000000 )
901             {
902                 mba = MBA_11 + (UBITS (bs->i_bit_in_cache, 11) - 24);
903                 break;
904             }
905             else if ( UBITS( bs->i_bit_in_cache, 11 ) == 8 )
906             {
907                 /* macroblock_escape */
908                 mba_inc += 33;
909                 mba_local += 33;
910                 bs_flush(bs, 11);
911             }
912             else
913             {
914                 /* EOS or error */
915                 return;
916             }
917         }
918         bs_flush(bs, mba->len);
919         mba_inc += mba->mba;
920         mba_local += mba->mba;
921
922         while( mba_local-- )
923         {
924             NEXT_MACROBLOCK;
925         }
926     }
927 }
928
929 static const uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) = {
930     /* Zig-Zag scan pattern */
931      0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
932     12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
933     35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
934     58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
935 };
936
937 static const uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) = {
938     /* Alternate scan pattern */
939      0, 8,  16, 24,  1,  9,  2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
940     41, 33, 26, 18,  3, 11,  4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
941     51, 59, 20, 28,  5, 13,  6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
942     53, 61, 22, 30,  7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
943 };
944
945 static const int16_t default_intra_matrix[64] = {
946         8, 16, 19, 22, 26, 27, 29, 34,
947         16, 16, 22, 24, 27, 29, 34, 37,
948         19, 22, 26, 27, 29, 34, 34, 38,
949         22, 22, 26, 27, 29, 34, 37, 40,
950         22, 26, 27, 29, 32, 35, 40, 48,
951         26, 27, 29, 32, 35, 40, 48, 58,
952         26, 27, 29, 34, 38, 46, 56, 69,
953         27, 29, 35, 38, 46, 56, 69, 83
954 };
955
956 static int mpeg2_header_sequence( transrate_t * tr )
957 {
958     bs_transrate_t *bs = &tr->bs;
959     int has_intra = 0, has_non_intra = 0;
960     int i;
961
962     i = (bs->p_c[0] << 16) | (bs->p_c[1] << 8) | bs->p_c[2];
963     tr->horizontal_size_value = i >> 12;
964     tr->vertical_size_value = i & 0xfff;
965     tr->horizontal_size_value = (tr->horizontal_size_value + 15) & ~15;
966     tr->vertical_size_value = (tr->vertical_size_value + 15) & ~15;
967     if ( !tr->horizontal_size_value || !tr->vertical_size_value )
968     {
969         return -1;
970     }
971
972     if ( tr->mpeg4_matrix )
973     {
974         if (bs->p_c[7] & 2)
975         {
976             has_intra = 1;
977             for (i = 0; i < 64; i++)
978                 tr->intra_quantizer_matrix[mpeg2_scan_norm[i]] =
979                 (bs->p_c[i+7] << 7) | (bs->p_c[i+8] >> 1);
980         }
981         else
982         {
983             for (i = 0; i < 64; i++)
984                 tr->intra_quantizer_matrix[mpeg2_scan_norm[i]] =
985                 default_intra_matrix[i];
986         }
987
988         if (bs->p_c[7+64] & 1)
989         {
990             has_non_intra = 1;
991             for (i = 0; i < 64; i++)
992                 tr->non_intra_quantizer_matrix[mpeg2_scan_norm[i]] =
993                 bs->p_c[i+8+64];
994         }
995         else
996         {
997             for (i = 0; i < 64; i++)
998                 tr->non_intra_quantizer_matrix[i] = 16;
999         }
1000     }
1001
1002     /* Write quantization matrices */
1003     memcpy( bs->p_w, bs->p_c, 8 );
1004     bs->p_c += 8;
1005
1006     if ( tr->mpeg4_matrix )
1007     {
1008         memset( &bs->p_w[8], 0, 128 );
1009         bs->p_w[7] |= 2;
1010         bs->p_w[7] &= ~1;
1011         for (i = 0; i < 64; i++)
1012         {
1013             bs->p_w[i+7] |= mpeg4_default_intra_matrix[mpeg2_scan_norm[i]] >> 7;
1014             bs->p_w[i+8] |= mpeg4_default_intra_matrix[mpeg2_scan_norm[i]] << 1;
1015         }
1016
1017         bs->p_w[7+64] |= 1;
1018         for (i = 0; i < 64; i++)
1019         {
1020             bs->p_w[i+8+64] |= mpeg4_default_intra_matrix[mpeg2_scan_norm[i]];
1021         }
1022         bs->p_w += 8 + 128;
1023         bs->p_c += (has_intra + has_non_intra) * 64;
1024     }
1025     else
1026     {
1027         bs->p_w += 8;
1028     }
1029
1030     tr->scan = mpeg2_scan_norm;
1031
1032     return 0;
1033 }
1034
1035 /////---- end ext mpeg code
1036
1037 static int do_next_start_code( transrate_t *tr )
1038 {
1039     bs_transrate_t *bs = &tr->bs;
1040     uint8_t ID;
1041
1042     // get start code
1043     ID = bs->p_c[0];
1044
1045     /* Copy one byte */
1046     *bs->p_w++ = *bs->p_c++;
1047
1048     if (ID == 0x00) // pic header
1049     {
1050         tr->picture_coding_type = (bs->p_c[1] >> 3) & 0x7;
1051         bs->p_c[1] |= 0x7; bs->p_c[2] = 0xFF; bs->p_c[3] |= 0xF8; // vbv_delay is now 0xFFFF
1052
1053         memcpy(bs->p_w, bs->p_c, 4);
1054         bs->p_c += 4;
1055         bs->p_w += 4;
1056     }
1057     else if (ID == 0xB3) // seq header
1058     {
1059         mpeg2_header_sequence(tr);
1060     }
1061     else if (ID == 0xB5) // extension
1062     {
1063         if ((bs->p_c[0] >> 4) == 0x8) // pic coding ext
1064         {
1065             tr->f_code[0][0] = (bs->p_c[0] & 0xF) - 1;
1066             tr->f_code[0][1] = (bs->p_c[1] >> 4) - 1;
1067             tr->f_code[1][0] = (bs->p_c[1] & 0xF) - 1;
1068             tr->f_code[1][1] = (bs->p_c[2] >> 4) - 1;
1069
1070             /* tr->intra_dc_precision = (bs->p_c[2] >> 2) & 0x3; */
1071             tr->picture_structure = bs->p_c[2] & 0x3;
1072             tr->frame_pred_frame_dct = (bs->p_c[3] >> 6) & 0x1;
1073             tr->concealment_motion_vectors = (bs->p_c[3] >> 5) & 0x1;
1074             tr->q_scale_type = (bs->p_c[3] >> 4) & 0x1;
1075             tr->intra_vlc_format = (bs->p_c[3] >> 3) & 0x1;
1076             if ( (bs->p_c[3] >> 2) & 0x1 )
1077                 tr->scan = mpeg2_scan_alt;
1078
1079             memcpy(bs->p_w, bs->p_c, 5);
1080             bs->p_c += 5;
1081             bs->p_w += 5;
1082         }
1083         else
1084         {
1085             *bs->p_w++ = *bs->p_c++;
1086         }
1087     }
1088     else if (ID == 0xB8) // gop header
1089     {
1090         memcpy(bs->p_w, bs->p_c, 4);
1091         bs->p_c += 4;
1092         bs->p_w += 4;
1093     }
1094     else if ((ID >= 0x01) && (ID <= 0xAF)) // slice
1095     {
1096         uint8_t *outTemp = bs->p_w, *inTemp = bs->p_c;
1097
1098         if( tr->qrate != 1.0 )
1099         {
1100             if( !tr->horizontal_size_value || !tr->vertical_size_value )
1101             {
1102                 return -1;
1103             }
1104
1105             // init bit buffer
1106             bs->i_bit_in_cache = 0; bs->i_bit_in = 0;
1107             bs->i_bit_out_cache = 0; bs->i_bit_out = BITS_IN_BUF;
1108
1109             // get 32 bits
1110             bs_refill( bs );
1111             bs_refill( bs );
1112             bs_refill( bs );
1113             bs_refill( bs );
1114
1115             // begin bit level recoding
1116             mpeg2_slice(tr, ID);
1117             if (tr->b_error) return -1;
1118
1119             bs_flush_read( bs );
1120             bs_flush_write( bs );
1121             // end bit level recoding
1122
1123             /* Basic sanity checks --Meuuh */
1124             if (bs->p_c > bs->p_r || bs->p_w > bs->p_rw)
1125             {
1126                 return -1;
1127             }
1128
1129             /*LOGF("type: %s code: %02i in : %6i out : %6i diff : %6i fact: %2.2f\n",
1130             (picture_coding_type == I_TYPE ? "I_TYPE" : (picture_coding_type == P_TYPE ? "P_TYPE" : "B_TYPE")),
1131             ID,  bs->p_c - inTemp, bs->p_w - outTemp, (bs->p_w - outTemp) - (bs->p_c - inTemp), (float)(bs->p_c - inTemp) / (float)(bs->p_w - outTemp));*/
1132
1133             if (bs->p_w - outTemp > bs->p_c - inTemp) // yes that might happen, rarely
1134             {
1135
1136                 /*LOGF("*** slice bigger than before !! (type: %s code: %i in : %i out : %i diff : %i)\n",
1137                 (picture_coding_type == I_TYPE ? "I_TYPE" : (picture_coding_type == P_TYPE ? "P_TYPE" : "B_TYPE")),
1138                 ID, bs->p_c - inTemp, bs->p_w - outTemp, (bs->p_w - outTemp) - (bs->p_c - inTemp));*/
1139
1140                 if ( !tr->mpeg4_matrix )
1141                 {
1142                     // in this case, we'll just use the original slice !
1143                     memcpy(outTemp, inTemp, bs->p_c - inTemp);
1144                     bs->p_w = outTemp + (bs->p_c - inTemp);
1145
1146                     // adjust bs->i_byte_out
1147                     bs->i_byte_out -= (bs->p_w - outTemp) - (bs->p_c - inTemp);
1148                 }
1149                 else
1150                 {
1151                     fprintf(stderr, "bad choice for mpeg4-matrix...\n");
1152                 }
1153             }
1154         }
1155     }
1156     return 0;
1157 }
1158
1159 int process_frame( sout_stream_t *p_stream, sout_stream_id_t *id,
1160                    block_t *in, block_t **out, int i_handicap )
1161 {
1162     transrate_t *tr = &id->tr;
1163     bs_transrate_t *bs = &tr->bs;
1164
1165     block_t       *p_out;
1166
1167     double        f_drift, f_fact;
1168     int           i_drift;
1169
1170     p_out = block_New( p_stream, in->i_buffer * 3 );
1171
1172     p_out->i_length = in->i_length;
1173     p_out->i_dts    = in->i_dts;
1174     p_out->i_pts    = in->i_pts;
1175     p_out->i_flags  = in->i_flags;
1176
1177     bs->p_rw = bs->p_ow = bs->p_w = p_out->p_buffer;
1178     bs->p_c = bs->p_r = in->p_buffer;
1179     bs->p_r += in->i_buffer + 4;
1180     bs->p_rw += in->i_buffer * 2;
1181     *(in->p_buffer + in->i_buffer) = 0;
1182     *(in->p_buffer + in->i_buffer + 1) = 0;
1183     *(in->p_buffer + in->i_buffer + 2) = 1;
1184     *(in->p_buffer + in->i_buffer + 3) = 0;
1185
1186     /* Calculate how late we are */
1187     bs->i_byte_in = in->i_buffer;
1188     bs->i_byte_out  = 0;
1189
1190     i_drift = tr->i_current_output + tr->i_remaining_input
1191                 - tr->i_wanted_output;
1192     f_drift = (double)i_drift / tr->i_wanted_output;
1193     f_fact = (double)(tr->i_wanted_output - tr->i_current_output)
1194                     / tr->i_remaining_input;
1195
1196     if ( in->i_flags & BLOCK_FLAG_TYPE_I )
1197     {
1198         /* This is the last picture of the GOP ; only transrate if we're
1199          * very late. */
1200         if ( 0 && f_drift > 0.085 )
1201         {
1202             tr->i_minimum_error = (f_drift - 0.085) * 50.0 * 50.0;
1203             tr->i_admissible_error = (f_drift - 0.085) * 50.0 * 75.0;
1204             tr->qrate = 1.0 + (f_drift - 0.085) * 50.0;
1205             msg_Warn( p_stream, "transrating I %d/%d",
1206                       tr->i_minimum_error, tr->i_admissible_error );
1207         }
1208         else
1209         {
1210             tr->i_minimum_error = 0;
1211             tr->i_admissible_error = 0;
1212             tr->qrate = 1.0;
1213         }
1214     }
1215     else if ( in->i_flags & BLOCK_FLAG_TYPE_P )
1216     {
1217         if ( f_fact < 0.8 )
1218         {
1219             tr->i_minimum_error = (0.8 - f_fact) * 3000.0 + i_handicap;
1220             tr->i_admissible_error = (0.8 - f_fact) * 3500.0 + i_handicap;
1221             tr->qrate = 1.0 + (0.8 - f_fact) * 70.0;
1222         }
1223         else
1224         {
1225             tr->i_minimum_error = 0;
1226             tr->i_admissible_error = 0;
1227             tr->qrate = 1.0;
1228         }
1229     }
1230     else
1231     {
1232         if ( f_fact < 1.2 )
1233         {
1234             tr->i_minimum_error = (1.2 - f_fact) * 1750.0 + i_handicap;
1235             tr->i_admissible_error = (1.2 - f_fact) * 2250.0 + i_handicap;
1236             tr->qrate = 1.0 + (1.2 - f_fact) * 45.0;
1237         }
1238         else
1239         {
1240             tr->i_minimum_error = 0;
1241             tr->i_admissible_error = 0;
1242             tr->qrate = 1.0;
1243         }
1244     }
1245
1246     tr->new_quantizer_scale = 0;
1247     tr->b_error = 0;
1248
1249     for ( ; ; )
1250     {
1251         uint8_t *p_end = &in->p_buffer[in->i_buffer];
1252
1253         /* Search next start code */
1254         for( ;; )
1255         {
1256             if( bs->p_c < p_end - 3 && bs->p_c[0] == 0 && bs->p_c[1] == 0 && bs->p_c[2] == 1 )
1257             {
1258                 /* Next start code */
1259                 break;
1260             }
1261             else if( bs->p_c < p_end - 6 &&
1262                      bs->p_c[0] == 0 && bs->p_c[1] == 0 && bs->p_c[2] == 0 &&
1263                      bs->p_c[3] == 0 && bs->p_c[4] == 0 && bs->p_c[5] == 0 )
1264             {
1265                 /* remove stuffing (looking for 6 0x00 bytes) */
1266                 bs->p_c++;
1267             }
1268             else
1269             {
1270                 /* Copy */
1271                 *bs->p_w++ = *bs->p_c++;
1272             }
1273
1274             if( bs->p_c >= p_end )
1275             {
1276                 break;
1277             }
1278         }
1279
1280         if( bs->p_c >= p_end )
1281         {
1282             break;
1283         }
1284
1285         /* Copy the start code */
1286         memcpy( bs->p_w, bs->p_c, 3 );
1287         bs->p_c += 3;
1288         bs->p_w += 3;
1289
1290         if ( do_next_start_code( tr ) )
1291         {
1292             /* Error */
1293             msg_Err( p_stream, "error in do_next_start_code()" );
1294             block_Release( p_out );
1295             tr->i_remaining_input -= in->i_buffer;
1296             tr->i_current_output += in->i_buffer;
1297             return -1;
1298         }
1299     }
1300
1301     bs->i_byte_out += bs->p_w - bs->p_ow;
1302     p_out->i_buffer = bs->p_w - bs->p_ow;
1303
1304 #if 0
1305     if ( in->i_flags & BLOCK_FLAG_TYPE_P && f_fact < 0.8 )
1306     {
1307         double f_ratio = (in->i_buffer - p_out->i_buffer) / in->i_buffer;
1308         if ( f_ratio < (0.8 - f_fact) * 0.1 && i_handicap < 200 )
1309         {
1310             block_Release( p_out );
1311             return process_frame( p_stream, id, in, out, i_handicap + 50 );
1312         }
1313     }
1314
1315     if ( in->i_flags & BLOCK_FLAG_TYPE_B && f_fact < 1.1 )
1316     {
1317         double f_ratio = (double)(in->i_buffer - p_out->i_buffer)
1318                             / in->i_buffer;
1319         if ( f_ratio < (1.1 - f_fact) * 0.1 && i_handicap < 400 )
1320         {
1321 #ifdef DEBUG_TRANSRATER
1322             msg_Dbg( p_stream, "%d: %d -> %d big (f: %f d: %f)",
1323                      tr->picture_coding_type, in->i_buffer, p_out->i_buffer,
1324                      f_fact, f_drift);
1325 #endif
1326             block_Release( p_out );
1327             return process_frame( p_stream, id, in, out, i_handicap + 100 );
1328         }
1329     }
1330 #endif
1331
1332 #if 0
1333     {
1334         int toto;
1335         for ( toto = 0; toto < p_out->i_buffer; toto++ )
1336             if (in->p_buffer[toto] != p_out->p_buffer[toto])
1337                 msg_Dbg(p_stream, "toto %d %x %x", toto, in->p_buffer[toto], p_out->p_buffer[toto]);
1338     }
1339 #endif
1340
1341     block_ChainAppend( out, p_out );
1342     tr->i_remaining_input -= in->i_buffer;
1343     tr->i_current_output += p_out->i_buffer;
1344
1345 #ifdef DEBUG_TRANSRATER
1346     msg_Dbg( p_stream, "%d: %d -> %d (%d/%d)",
1347              tr->picture_coding_type, in->i_buffer, p_out->i_buffer,
1348              tr->i_minimum_error, tr->i_admissible_error );
1349 #endif
1350
1351     return 0;
1352 }
1353
1354