* all: re-import of the CVS.
[x264/x264-sandbox.git] / encoder / cavlc.c
1 /*****************************************************************************
2  * cavlc.c: h264 encoder library
3  *****************************************************************************
4  * Copyright (C) 2003 Laurent Aimar
5  * $Id: cavlc.c,v 1.1 2004/06/03 19:27:08 fenrir Exp $
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <stdint.h>
28
29 #include "../core/common.h"
30 #include "../core/vlc.h"
31 #include "macroblock.h"
32
33 static const uint8_t intra4x4_cbp_to_golomb[48]=
34 {
35   3, 29, 30, 17, 31, 18, 37,  8, 32, 38, 19,  9, 20, 10, 11,  2,
36  16, 33, 34, 21, 35, 22, 39,  4, 36, 40, 23,  5, 24,  6,  7,  1,
37  41, 42, 43, 25, 44, 26, 46, 12, 45, 47, 27, 13, 28, 14, 15,  0
38 };
39 static const uint8_t inter_cbp_to_golomb[48]=
40 {
41   0,  2,  3,  7,  4,  8, 17, 13,  5, 18,  9, 14, 10, 15, 16, 11,
42   1, 32, 33, 36, 34, 37, 44, 40, 35, 45, 38, 41, 39, 42, 43, 19,
43   6, 24, 25, 20, 26, 21, 46, 28, 27, 47, 22, 29, 23, 30, 31, 12
44 };
45
46 static const uint8_t block_idx_x[16] =
47 {
48     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
49 };
50 static const uint8_t block_idx_y[16] =
51 {
52     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
53 };
54 static const uint8_t block_idx_xy[4][4] =
55 {
56     { 0, 2, 8,  10},
57     { 1, 3, 9,  11},
58     { 4, 6, 12, 14},
59     { 5, 7, 13, 15}
60 };
61
62 #define BLOCK_INDEX_CHROMA_DC   (-1)
63 #define BLOCK_INDEX_LUMA_DC     (-2)
64
65 static inline void bs_write_vlc( bs_t *s, vlc_t v )
66 {
67     bs_write( s, v.i_size, v.i_bits );
68 }
69
70 /****************************************************************************
71  * block_residual_write_cavlc:
72  ****************************************************************************/
73 static void block_residual_write_cavlc( x264_t *h, bs_t *s, int i_idx, int *l, int i_count )
74 {
75     int level[16], run[16];
76     int i_total, i_trailing;
77     int i_total_zero;
78     int i_last;
79     unsigned int i_sign;
80
81     int i;
82     int i_zero_left;
83     int i_suffix_length;
84
85     /* first find i_last */
86     i_last = i_count - 1;
87     while( i_last >= 0 && l[i_last] == 0 )
88     {
89         i_last--;
90     }
91
92     i_sign = 0;
93     i_total = 0;
94     i_trailing = 0;
95     i_total_zero = 0;
96
97     if( i_last >= 0 )
98     {
99         int b_trailing = 1;
100         int idx = 0;
101
102         /* level and run and total */
103         while( i_last >= 0 )
104         {
105             level[idx] = l[i_last--];
106
107             run[idx] = 0;
108             while( i_last >= 0 && l[i_last] == 0 )
109             {
110                 run[idx]++;
111                 i_last--;
112             }
113
114             i_total++;
115             i_total_zero += run[idx];
116
117             if( b_trailing && abs( level[idx] ) == 1 && i_trailing < 3 )
118             {
119                 i_sign <<= 1;
120                 if( level[idx] < 0 )
121                 {
122                     i_sign |= 0x01;
123                 }
124
125                 i_trailing++;
126             }
127             else
128             {
129                 b_trailing = 0;
130             }
131
132             idx++;
133         }
134     }
135
136     /* total/trailing */
137     if( i_idx == BLOCK_INDEX_CHROMA_DC )
138     {
139         bs_write_vlc( s, x264_coeff_token[4][i_total*4+i_trailing] );
140     }
141     else
142     {
143         /* x264_mb_predict_non_zero_code return 0 <-> (16+16+1)>>1 = 16 */
144         static const int ct_index[17] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,3 };
145         int nC;
146
147         if( i_idx == BLOCK_INDEX_LUMA_DC )
148         {
149             nC = x264_mb_predict_non_zero_code( h, 0 );
150         }
151         else
152         {
153             nC = x264_mb_predict_non_zero_code( h, i_idx );
154         }
155
156         bs_write_vlc( s, x264_coeff_token[ct_index[nC]][i_total*4+i_trailing] );
157     }
158
159     if( i_total <= 0 )
160     {
161         return;
162     }
163
164     i_suffix_length = i_total > 10 && i_trailing < 3 ? 1 : 0;
165     if( i_trailing > 0 )
166     {
167         bs_write( s, i_trailing, i_sign );
168     }
169     for( i = i_trailing; i < i_total; i++ )
170     {
171         int i_level_code;
172
173         /* calculate level code */
174         if( level[i] < 0 )
175         {
176             i_level_code = -2*level[i] - 1;
177         }
178         else /* if( level[i] > 0 ) */
179         {
180             i_level_code = 2 * level[i] - 2;
181         }
182         if( i == i_trailing && i_trailing < 3 )
183         {
184             i_level_code -=2; /* as level[i] can't be 1 for the first one if i_trailing < 3 */
185         }
186
187         if( ( i_level_code >> i_suffix_length ) < 14 )
188         {
189             bs_write_vlc( s, x264_level_prefix[i_level_code >> i_suffix_length] );
190             if( i_suffix_length > 0 )
191             {
192                 bs_write( s, i_suffix_length, i_level_code );
193             }
194         }
195         else if( i_suffix_length == 0 && i_level_code < 30 )
196         {
197             bs_write_vlc( s, x264_level_prefix[14] );
198             bs_write( s, 4, i_level_code - 14 );
199         }
200         else if( i_suffix_length > 0 && ( i_level_code >> i_suffix_length ) == 14 )
201         {
202             bs_write_vlc( s, x264_level_prefix[14] );
203             bs_write( s, i_suffix_length, i_level_code );
204         }
205         else
206         {
207             bs_write_vlc( s, x264_level_prefix[15] );
208             i_level_code -= 15 << i_suffix_length;
209             if( i_suffix_length == 0 )
210             {
211                 i_level_code -= 15;
212             }
213
214             if( i_level_code >= ( 1 << 12 ) || i_level_code < 0 )
215             {
216                 fprintf( stderr, "OVERFLOW levelcode=%d\n", i_level_code );
217             }
218
219             bs_write( s, 12, i_level_code );    /* check overflow ?? */
220         }
221
222         if( i_suffix_length == 0 )
223         {
224             i_suffix_length++;
225         }
226         if( abs( level[i] ) > ( 3 << ( i_suffix_length - 1 ) ) && i_suffix_length < 6 )
227         {
228             i_suffix_length++;
229         }
230     }
231
232     if( i_total < i_count )
233     {
234         if( i_idx == BLOCK_INDEX_CHROMA_DC )
235         {
236             bs_write_vlc( s, x264_total_zeros_dc[i_total-1][i_total_zero] );
237         }
238         else
239         {
240             bs_write_vlc( s, x264_total_zeros[i_total-1][i_total_zero] );
241         }
242     }
243
244     for( i = 0, i_zero_left = i_total_zero; i < i_total - 1; i++ )
245     {
246         int i_zl;
247
248         if( i_zero_left <= 0 )
249         {
250             break;
251         }
252
253         i_zl = X264_MIN( i_zero_left - 1, 6 );
254
255         bs_write_vlc( s, x264_run_before[i_zl][run[i]] );
256
257         i_zero_left -= run[i];
258     }
259 }
260
261 /*****************************************************************************
262  * x264_macroblock_write:
263  *****************************************************************************/
264 void x264_macroblock_write_cavlc( x264_t *h, bs_t *s )
265 {
266     const int i_mb_type = h->mb.i_type;
267     int i_mb_i_offset;
268     int i;
269
270     switch( h->sh.i_type )
271     {
272         case SLICE_TYPE_I:
273             i_mb_i_offset = 0;
274             break;
275         case SLICE_TYPE_P:
276             i_mb_i_offset = 5;
277             break;
278         case SLICE_TYPE_B:
279             i_mb_i_offset = 23;
280             break;
281         default:
282             fprintf( stderr, "internal error or slice unsupported\n" );
283             return;
284     }
285
286     /* Write:
287       - type
288       - prediction
289       - mv */
290     if( i_mb_type == I_PCM )
291     {
292         /* Untested */
293         bs_write_ue( s, i_mb_i_offset + 25 );
294
295         bs_align_0( s );
296         /* Luma */
297         for( i = 0; i < 16*16; i++ )
298         {
299             const int x = 16 * h->mb.i_mb_x + (i % 16);
300             const int y = 16 * h->mb.i_mb_y + (i / 16);
301             bs_write( s, 8, h->fenc->plane[0][y*h->mb.pic.i_stride[0]+x] );
302         }
303         /* Cb */
304         for( i = 0; i < 8*8; i++ )
305         {
306             const int x = 8 * h->mb.i_mb_x + (i % 8);
307             const int y = 8 * h->mb.i_mb_y + (i / 8);
308             bs_write( s, 8, h->fenc->plane[1][y*h->mb.pic.i_stride[1]+x] );
309         }
310         /* Cr */
311         for( i = 0; i < 8*8; i++ )
312         {
313             const int x = 8 * h->mb.i_mb_x + (i % 8);
314             const int y = 8 * h->mb.i_mb_y + (i / 8);
315             bs_write( s, 8, h->fenc->plane[2][y*h->mb.pic.i_stride[2]+x] );
316         }
317         return;
318     }
319     else if( i_mb_type == I_4x4 )
320     {
321         bs_write_ue( s, i_mb_i_offset + 0 );
322
323         /* Prediction: Luma */
324         for( i = 0; i < 16; i++ )
325         {
326             int i_pred = x264_mb_predict_intra4x4_mode( h, i );
327             int i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[i]];
328
329             if( i_pred == i_mode)
330             {
331                 bs_write1( s, 1 );  /* b_prev_intra4x4_pred_mode */
332             }
333             else
334             {
335                 bs_write1( s, 0 );  /* b_prev_intra4x4_pred_mode */
336                 if( i_mode < i_pred )
337                 {
338                     bs_write( s, 3, i_mode );
339                 }
340                 else
341                 {
342                     bs_write( s, 3, i_mode - 1 );
343                 }
344             }
345         }
346         bs_write_ue( s, h->mb.i_chroma_pred_mode );
347     }
348     else if( i_mb_type == I_16x16 )
349     {
350         bs_write_ue( s, i_mb_i_offset + 1 + h->mb.i_intra16x16_pred_mode +
351                         h->mb.i_cbp_chroma * 4 + ( h->mb.i_cbp_luma == 0 ? 0 : 12 ) );
352         bs_write_ue( s, h->mb.i_chroma_pred_mode );
353     }
354     else if( i_mb_type == P_L0 )
355     {
356         int mvp[2];
357
358         if( h->mb.i_partition == D_16x16 )
359         {
360             bs_write_ue( s, 0 );
361
362             if( h->sh.i_num_ref_idx_l0_active > 1 )
363             {
364                 bs_write_te( s, h->sh.i_num_ref_idx_l0_active - 1, h->mb.cache.ref[0][x264_scan8[0]] );
365             }
366             x264_mb_predict_mv( h, 0, 0, 4, mvp );
367             bs_write_se( s, h->mb.cache.mv[0][x264_scan8[0]][0] - mvp[0] );
368             bs_write_se( s, h->mb.cache.mv[0][x264_scan8[0]][1] - mvp[1] );
369         }
370         else if( h->mb.i_partition == D_16x8 )
371         {
372             bs_write_ue( s, 1 );
373             if( h->sh.i_num_ref_idx_l0_active > 1 )
374             {
375                 bs_write_te( s, h->sh.i_num_ref_idx_l0_active - 1, h->mb.cache.ref[0][x264_scan8[0]] );
376                 bs_write_te( s, h->sh.i_num_ref_idx_l0_active - 1, h->mb.cache.ref[0][x264_scan8[8]] );
377             }
378
379             x264_mb_predict_mv( h, 0, 0, 4, mvp );
380             bs_write_se( s, h->mb.cache.mv[0][x264_scan8[0]][0] - mvp[0] );
381             bs_write_se( s, h->mb.cache.mv[0][x264_scan8[0]][1] - mvp[1] );
382
383             x264_mb_predict_mv( h, 0, 8, 4, mvp );
384             bs_write_se( s, h->mb.cache.mv[0][x264_scan8[8]][0] - mvp[0] );
385             bs_write_se( s, h->mb.cache.mv[0][x264_scan8[8]][1] - mvp[1] );
386         }
387         else if( h->mb.i_partition == D_8x16 )
388         {
389             bs_write_ue( s, 2 );
390             if( h->sh.i_num_ref_idx_l0_active > 1 )
391             {
392                 bs_write_te( s, h->sh.i_num_ref_idx_l0_active - 1, h->mb.cache.ref[0][x264_scan8[0]] );
393                 bs_write_te( s, h->sh.i_num_ref_idx_l0_active - 1, h->mb.cache.ref[0][x264_scan8[4]] );
394             }
395
396             x264_mb_predict_mv( h, 0, 0, 2, mvp );
397             bs_write_se( s, h->mb.cache.mv[0][x264_scan8[0]][0] - mvp[0] );
398             bs_write_se( s, h->mb.cache.mv[0][x264_scan8[0]][1] - mvp[1] );
399
400             x264_mb_predict_mv( h, 0, 4, 2, mvp );
401             bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4]][0] - mvp[0] );
402             bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4]][1] - mvp[1] );
403         }
404     }
405     else if( i_mb_type == P_8x8 )
406     {
407         int b_sub_ref0;
408
409         if( h->mb.cache.ref[0][x264_scan8[0]] == 0 && h->mb.cache.ref[0][x264_scan8[4]] == 0 &&
410             h->mb.cache.ref[0][x264_scan8[8]] == 0 && h->mb.cache.ref[0][x264_scan8[12]] == 0 )
411         {
412             bs_write_ue( s, 4 );
413             b_sub_ref0 = 0;
414         }
415         else
416         {
417             bs_write_ue( s, 3 );
418             b_sub_ref0 = 1;
419         }
420         /* sub mb type */
421         for( i = 0; i < 4; i++ )
422         {
423             switch( h->mb.i_sub_partition[i] )
424             {
425                 case D_L0_8x8:
426                     bs_write_ue( s, 0 );
427                     break;
428                 case D_L0_8x4:
429                     bs_write_ue( s, 1 );
430                     break;
431                 case D_L0_4x8:
432                     bs_write_ue( s, 2 );
433                     break;
434                 case D_L0_4x4:
435                     bs_write_ue( s, 3 );
436                     break;
437             }
438         }
439         /* ref0 */
440         if( h->sh.i_num_ref_idx_l0_active > 1 && b_sub_ref0 )
441         {
442             bs_write_te( s, h->sh.i_num_ref_idx_l0_active - 1, h->mb.cache.ref[0][x264_scan8[0]] );
443             bs_write_te( s, h->sh.i_num_ref_idx_l0_active - 1, h->mb.cache.ref[0][x264_scan8[4]] );
444             bs_write_te( s, h->sh.i_num_ref_idx_l0_active - 1, h->mb.cache.ref[0][x264_scan8[8]] );
445             bs_write_te( s, h->sh.i_num_ref_idx_l0_active - 1, h->mb.cache.ref[0][x264_scan8[12]] );
446         }
447         for( i = 0; i < 4; i++ )
448         {
449             int mvp[2];
450
451             switch( h->mb.i_sub_partition[i] )
452             {
453                 case D_L0_8x8:
454                     x264_mb_predict_mv( h, 0, 4*i, 2, mvp );
455                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i]][0] - mvp[0] );
456                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i]][1] - mvp[1] );
457                     break;
458                 case D_L0_8x4:
459                     x264_mb_predict_mv( h, 0, 4*i+0, 2, mvp );
460                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i]][0] - mvp[0] );
461                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i]][1] - mvp[1] );
462
463                     x264_mb_predict_mv( h, 0, 4*i+2, 2, mvp );
464                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i+2]][0] - mvp[0] );
465                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i+2]][1] - mvp[1] );
466                     break;
467                 case D_L0_4x8:
468                     x264_mb_predict_mv( h, 0, 4*i+0, 1, mvp );
469                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i]][0] - mvp[0] );
470                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i]][1] - mvp[1] );
471
472                     x264_mb_predict_mv( h, 0, 4*i+1, 1, mvp );
473                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i+1]][0] - mvp[0] );
474                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i+1]][1] - mvp[1] );
475                     break;
476                 case D_L0_4x4:
477                     x264_mb_predict_mv( h, 0, 4*i+0, 1, mvp );
478                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i]][0] - mvp[0] );
479                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i]][1] - mvp[1] );
480
481                     x264_mb_predict_mv( h, 0, 4*i+1, 1, mvp );
482                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i+1]][0] - mvp[0] );
483                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i+1]][1] - mvp[1] );
484
485                     x264_mb_predict_mv( h, 0, 4*i+2, 1, mvp );
486                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i+2]][0] - mvp[0] );
487                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i+2]][1] - mvp[1] );
488
489                     x264_mb_predict_mv( h, 0, 4*i+3, 1, mvp );
490                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i+3]][0] - mvp[0] );
491                     bs_write_se( s, h->mb.cache.mv[0][x264_scan8[4*i+3]][1] - mvp[1] );
492                     break;
493             }
494         }
495     }
496     else if( i_mb_type == B_8x8 )
497     {
498         fprintf( stderr, "invalid/unhandled mb_type (B_8x8)\n" );
499         return;
500     }
501     else if( i_mb_type != B_DIRECT )
502     {
503         /* All B mode */
504         /* Motion Vector */
505         int i_list;
506         int mvp[2];
507
508         int b_list[2][2];
509
510         /* init ref list utilisations */
511         for( i = 0; i < 2; i++ )
512         {
513             b_list[0][i] = x264_mb_type_list0_table[i_mb_type][i];
514             b_list[1][i] = x264_mb_type_list1_table[i_mb_type][i];
515         }
516
517
518         if( h->mb.i_partition == D_16x16 )
519         {
520             if( b_list[0][0] && b_list[1][0] )
521             {
522                 bs_write_ue( s, 3 );
523             }
524             else if( b_list[1][0] )
525             {
526                 bs_write_ue( s, 2 );
527             }
528             else
529             {
530                 bs_write_ue( s, 1 );
531             }
532         }
533         else
534         {
535             if( i_mb_type == B_BI_BI )
536             {
537                 bs_write_ue( s, 20 + (h->mb.i_partition == D_16x8 ? 0 : 1 ) );
538             }
539             else if( b_list[0][0] && b_list[1][0] )
540             {
541                 /* B_BI_LX* */
542                 bs_write_ue( s, 16 + (b_list[0][1]?0:2) + (h->mb.i_partition == D_16x8?0:1) );
543             }
544             else if( b_list[0][1] && b_list[1][1] )
545             {
546                 /* B_LX_BI */
547                 bs_write_ue( s, 12 + (b_list[0][1]?0:2) + (h->mb.i_partition == D_16x8?0:1) );
548             }
549             else if( b_list[1][1] )
550             {
551                 /* B_LX_L1 */
552                 bs_write_ue( s, 6 + (b_list[0][0]?2:0) + (h->mb.i_partition == D_16x8?0:1) );
553             }
554             else if( b_list[0][1] )
555             {
556                 /* B_LX_L0 */
557                 bs_write_ue( s, 4 + (b_list[0][0]?0:6) + (h->mb.i_partition == D_16x8?0:1) );
558             }
559         }
560
561         for( i_list = 0; i_list < 2; i_list++ )
562         {
563             const int i_ref_max = i_list == 0 ? h->sh.i_num_ref_idx_l0_active : h->sh.i_num_ref_idx_l1_active;
564
565             if( i_ref_max > 1 )
566             {
567                 switch( h->mb.i_partition )
568                 {
569                     case D_16x16:
570                         if( b_list[i_list][0] ) bs_write_te( s, i_ref_max - 1, h->mb.cache.ref[i_list][x264_scan8[0]] );
571                         break;
572                     case D_16x8:
573                         if( b_list[i_list][0] ) bs_write_te( s, i_ref_max - 1, h->mb.cache.ref[i_list][x264_scan8[0]] );
574                         if( b_list[i_list][1] ) bs_write_te( s, i_ref_max - 1, h->mb.cache.ref[i_list][x264_scan8[8]] );
575                         break;
576                     case D_8x16:
577                         if( b_list[i_list][0] ) bs_write_te( s, i_ref_max - 1, h->mb.cache.ref[i_list][x264_scan8[0]] );
578                         if( b_list[i_list][1] ) bs_write_te( s, i_ref_max - 1, h->mb.cache.ref[i_list][x264_scan8[4]] );
579                         break;
580                 }
581             }
582         }
583         for( i_list = 0; i_list < 2; i_list++ )
584         {
585             switch( h->mb.i_partition )
586             {
587                 case D_16x16:
588                     if( b_list[i_list][0] )
589                     {
590                         x264_mb_predict_mv( h, i_list, 0, 4, mvp );
591                         bs_write_se( s, h->mb.cache.mv[i_list][x264_scan8[0]][0] - mvp[0] );
592                         bs_write_se( s, h->mb.cache.mv[i_list][x264_scan8[0]][1] - mvp[1] );
593                     }
594                     break;
595                 case D_16x8:
596                     if( b_list[i_list][0] )
597                     {
598                         x264_mb_predict_mv( h, i_list, 0, 4, mvp );
599                         bs_write_se( s, h->mb.cache.mv[i_list][x264_scan8[0]][0] - mvp[0] );
600                         bs_write_se( s, h->mb.cache.mv[i_list][x264_scan8[0]][1] - mvp[1] );
601                     }
602                     if( b_list[i_list][1] )
603                     {
604                         x264_mb_predict_mv( h, i_list, 8, 4, mvp );
605                         bs_write_se( s, h->mb.cache.mv[i_list][x264_scan8[8]][0] - mvp[0] );
606                         bs_write_se( s, h->mb.cache.mv[i_list][x264_scan8[8]][1] - mvp[1] );
607                     }
608                     break;
609                 case D_8x16:
610                     if( b_list[i_list][0] )
611                     {
612                         x264_mb_predict_mv( h, i_list, 0, 2, mvp );
613                         bs_write_se( s, h->mb.cache.mv[i_list][x264_scan8[0]][0] - mvp[0] );
614                         bs_write_se( s, h->mb.cache.mv[i_list][x264_scan8[0]][1] - mvp[1] );
615                     }
616                     if( b_list[i_list][1] )
617                     {
618                         x264_mb_predict_mv( h, i_list, 4, 2, mvp );
619                         bs_write_se( s, h->mb.cache.mv[i_list][x264_scan8[4]][0] - mvp[0] );
620                         bs_write_se( s, h->mb.cache.mv[i_list][x264_scan8[4]][1] - mvp[1] );
621                     }
622                     break;
623             }
624         }
625     }
626     else if( i_mb_type == B_DIRECT )
627     {
628         bs_write_ue( s, 0 );
629     }
630     else
631     {
632         fprintf( stderr, "invalid/unhandled mb_type\n" );
633         return;
634     }
635
636     /* Coded block patern */
637     if( i_mb_type == I_4x4 )
638     {
639         bs_write_ue( s, intra4x4_cbp_to_golomb[( h->mb.i_cbp_chroma << 4 )|h->mb.i_cbp_luma] );
640     }
641     else if( i_mb_type != I_16x16 )
642     {
643         bs_write_ue( s, inter_cbp_to_golomb[( h->mb.i_cbp_chroma << 4 )|h->mb.i_cbp_luma] );
644     }
645
646     /* write residual */
647     if( i_mb_type == I_16x16 )
648     {
649         bs_write_se( s, h->mb.qp[h->mb.i_mb_xy] - h->mb.i_last_qp );
650
651         /* DC Luma */
652         block_residual_write_cavlc( h, s, BLOCK_INDEX_LUMA_DC , h->dct.luma16x16_dc, 16 );
653
654         if( h->mb.i_cbp_luma != 0 )
655         {
656             /* AC Luma */
657             for( i = 0; i < 16; i++ )
658             {
659                 block_residual_write_cavlc( h, s, i, h->dct.block[i].residual_ac, 15 );
660             }
661         }
662     }
663     else if( h->mb.i_cbp_luma != 0 || h->mb.i_cbp_chroma != 0 )
664     {
665         bs_write_se( s, h->mb.qp[h->mb.i_mb_xy] - h->mb.i_last_qp );
666
667         for( i = 0; i < 16; i++ )
668         {
669             if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
670             {
671                 block_residual_write_cavlc( h, s, i, h->dct.block[i].luma4x4, 16 );
672             }
673         }
674     }
675     if( h->mb.i_cbp_chroma != 0 )
676     {
677         /* Chroma DC residual present */
678         block_residual_write_cavlc( h, s, BLOCK_INDEX_CHROMA_DC, h->dct.chroma_dc[0], 4 );
679         block_residual_write_cavlc( h, s, BLOCK_INDEX_CHROMA_DC, h->dct.chroma_dc[1], 4 );
680         if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
681         {
682             for( i = 0; i < 8; i++ )
683             {
684                 block_residual_write_cavlc( h, s, 16 + i, h->dct.block[16+i].residual_ac, 15 );
685             }
686         }
687     }
688 }