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