Lookahead VBV
[x262.git] / common / frame.c
1 /*****************************************************************************
2  * frame.c: h264 encoder library
3  *****************************************************************************
4  * Copyright (C) 2003-2008 x264 project
5  *
6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7  *          Loren Merritt <lorenm@u.washington.edu>
8  *          Jason Garrett-Glaser <darkshikari@gmail.com>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 #include "common.h"
26
27 #define ALIGN(x,a) (((x)+((a)-1))&~((a)-1))
28
29 x264_frame_t *x264_frame_new( x264_t *h )
30 {
31     x264_frame_t *frame;
32     int i, j;
33
34     int i_mb_count = h->mb.i_mb_count;
35     int i_stride, i_width, i_lines;
36     int i_padv = PADV << h->param.b_interlaced;
37     int luma_plane_size;
38     int chroma_plane_size;
39     int align = h->param.cpu&X264_CPU_CACHELINE_64 ? 64 : h->param.cpu&X264_CPU_CACHELINE_32 ? 32 : 16;
40
41     CHECKED_MALLOCZERO( frame, sizeof(x264_frame_t) );
42
43     /* allocate frame data (+64 for extra data for me) */
44     i_width  = ALIGN( h->param.i_width, 16 );
45     i_stride = ALIGN( i_width + 2*PADH, align );
46     i_lines  = ALIGN( h->param.i_height, 16<<h->param.b_interlaced );
47
48     frame->i_plane = 3;
49     for( i = 0; i < 3; i++ )
50     {
51         frame->i_stride[i] = ALIGN( i_stride >> !!i, align );
52         frame->i_width[i] = i_width >> !!i;
53         frame->i_lines[i] = i_lines >> !!i;
54     }
55
56     luma_plane_size = (frame->i_stride[0] * ( frame->i_lines[0] + 2*i_padv ));
57     chroma_plane_size = (frame->i_stride[1] * ( frame->i_lines[1] + 2*i_padv ));
58     for( i = 1; i < 3; i++ )
59     {
60         CHECKED_MALLOC( frame->buffer[i], chroma_plane_size );
61         frame->plane[i] = frame->buffer[i] + (frame->i_stride[i] * i_padv + PADH)/2;
62     }
63     /* all 4 luma planes allocated together, since the cacheline split code
64      * requires them to be in-phase wrt cacheline alignment. */
65     if( h->param.analyse.i_subpel_refine )
66     {
67         CHECKED_MALLOC( frame->buffer[0], 4*luma_plane_size);
68         for( i = 0; i < 4; i++ )
69             frame->filtered[i] = frame->buffer[0] + i*luma_plane_size + frame->i_stride[0] * i_padv + PADH;
70         frame->plane[0] = frame->filtered[0];
71     }
72     else
73     {
74         CHECKED_MALLOC( frame->buffer[0], luma_plane_size);
75         frame->plane[0] = frame->buffer[0] + frame->i_stride[0] * i_padv + PADH;
76     }
77
78     if( h->frames.b_have_lowres )
79     {
80         frame->i_width_lowres = frame->i_width[0]/2;
81         frame->i_stride_lowres = ALIGN( frame->i_width_lowres + 2*PADH, align );
82         frame->i_lines_lowres = frame->i_lines[0]/2;
83
84         luma_plane_size = frame->i_stride_lowres * ( frame->i_lines[0]/2 + 2*i_padv );
85
86         CHECKED_MALLOC( frame->buffer_lowres[0], 4 * luma_plane_size );
87         for( i = 0; i < 4; i++ )
88             frame->lowres[i] = frame->buffer_lowres[0] + (frame->i_stride_lowres * i_padv + PADH) + i * luma_plane_size;
89
90         for( j = 0; j <= !!h->param.i_bframe; j++ )
91             for( i = 0; i <= h->param.i_bframe; i++ )
92             {
93                 CHECKED_MALLOCZERO( frame->lowres_mvs[j][i], 2*h->mb.i_mb_count*sizeof(int16_t) );
94                 CHECKED_MALLOC( frame->lowres_mv_costs[j][i], h->mb.i_mb_count*sizeof(int) );
95             }
96         CHECKED_MALLOC( frame->i_propagate_cost, (i_mb_count+3) * sizeof(uint16_t) );
97         for( j = 0; j <= h->param.i_bframe+1; j++ )
98             for( i = 0; i <= h->param.i_bframe+1; i++ )
99             {
100                 CHECKED_MALLOC( frame->lowres_costs[j][i], (i_mb_count+3) * sizeof(uint16_t) );
101                 CHECKED_MALLOC( frame->lowres_inter_types[j][i], (i_mb_count+3) * sizeof(uint8_t) );
102             }
103         frame->i_intra_cost = frame->lowres_costs[0][0];
104         memset( frame->i_intra_cost, -1, (i_mb_count+3) * sizeof(uint16_t) );
105     }
106
107     if( h->param.analyse.i_me_method >= X264_ME_ESA )
108     {
109         CHECKED_MALLOC( frame->buffer[3],
110                         frame->i_stride[0] * (frame->i_lines[0] + 2*i_padv) * sizeof(uint16_t) << h->frames.b_have_sub8x8_esa );
111         frame->integral = (uint16_t*)frame->buffer[3] + frame->i_stride[0] * i_padv + PADH;
112     }
113
114     frame->i_poc = -1;
115     frame->i_type = X264_TYPE_AUTO;
116     frame->i_qpplus1 = 0;
117     frame->i_pts = -1;
118     frame->i_frame = -1;
119     frame->i_frame_num = -1;
120     frame->i_lines_completed = -1;
121
122     CHECKED_MALLOC( frame->mb_type, i_mb_count * sizeof(int8_t));
123     CHECKED_MALLOC( frame->mv[0], 2*16 * i_mb_count * sizeof(int16_t) );
124     CHECKED_MALLOC( frame->ref[0], 4 * i_mb_count * sizeof(int8_t) );
125     if( h->param.i_bframe )
126     {
127         CHECKED_MALLOC( frame->mv[1], 2*16 * i_mb_count * sizeof(int16_t) );
128         CHECKED_MALLOC( frame->ref[1], 4 * i_mb_count * sizeof(int8_t) );
129     }
130     else
131     {
132         frame->mv[1]  = NULL;
133         frame->ref[1] = NULL;
134     }
135
136     CHECKED_MALLOC( frame->i_row_bits, i_lines/16 * sizeof(int) );
137     CHECKED_MALLOC( frame->i_row_qp, i_lines/16 * sizeof(int) );
138     for( i = 0; i < h->param.i_bframe + 2; i++ )
139         for( j = 0; j < h->param.i_bframe + 2; j++ )
140             CHECKED_MALLOC( frame->i_row_satds[i][j], i_lines/16 * sizeof(int) );
141
142     if( h->param.rc.i_aq_mode )
143     {
144         CHECKED_MALLOC( frame->f_qp_offset, h->mb.i_mb_count * sizeof(float) );
145         CHECKED_MALLOC( frame->f_qp_offset_aq, h->mb.i_mb_count * sizeof(float) );
146         if( h->frames.b_have_lowres )
147             /* shouldn't really be initialized, just silences a valgrind false-positive in x264_mbtree_propagate_cost_sse2 */
148             CHECKED_MALLOCZERO( frame->i_inv_qscale_factor, (h->mb.i_mb_count+3) * sizeof(uint16_t) );
149     }
150
151     if( x264_pthread_mutex_init( &frame->mutex, NULL ) )
152         goto fail;
153     if( x264_pthread_cond_init( &frame->cv, NULL ) )
154         goto fail;
155
156     return frame;
157
158 fail:
159     x264_free( frame );
160     return NULL;
161 }
162
163 void x264_frame_delete( x264_frame_t *frame )
164 {
165     int i, j;
166     for( i = 0; i < 4; i++ )
167         x264_free( frame->buffer[i] );
168     for( i = 0; i < 4; i++ )
169         x264_free( frame->buffer_lowres[i] );
170     for( i = 0; i < X264_BFRAME_MAX+2; i++ )
171         for( j = 0; j < X264_BFRAME_MAX+2; j++ )
172             x264_free( frame->i_row_satds[i][j] );
173     for( j = 0; j < 2; j++ )
174         for( i = 0; i <= X264_BFRAME_MAX; i++ )
175         {
176             x264_free( frame->lowres_mvs[j][i] );
177             x264_free( frame->lowres_mv_costs[j][i] );
178         }
179     x264_free( frame->i_propagate_cost );
180     for( j = 0; j <= X264_BFRAME_MAX+1; j++ )
181         for( i = 0; i <= X264_BFRAME_MAX+1; i++ )
182         {
183             x264_free( frame->lowres_costs[j][i] );
184             x264_free( frame->lowres_inter_types[j][i] );
185         }
186     x264_free( frame->f_qp_offset );
187     x264_free( frame->f_qp_offset_aq );
188     x264_free( frame->i_inv_qscale_factor );
189     x264_free( frame->i_row_bits );
190     x264_free( frame->i_row_qp );
191     x264_free( frame->mb_type );
192     x264_free( frame->mv[0] );
193     x264_free( frame->mv[1] );
194     x264_free( frame->ref[0] );
195     x264_free( frame->ref[1] );
196     x264_pthread_mutex_destroy( &frame->mutex );
197     x264_pthread_cond_destroy( &frame->cv );
198     x264_free( frame );
199 }
200
201 int x264_frame_copy_picture( x264_t *h, x264_frame_t *dst, x264_picture_t *src )
202 {
203     int i_csp = src->img.i_csp & X264_CSP_MASK;
204     int i;
205     if( i_csp != X264_CSP_I420 && i_csp != X264_CSP_YV12 )
206     {
207         x264_log( h, X264_LOG_ERROR, "Arg invalid CSP\n" );
208         return -1;
209     }
210
211     dst->i_type     = src->i_type;
212     dst->i_qpplus1  = src->i_qpplus1;
213     dst->i_pts      = src->i_pts;
214
215     for( i=0; i<3; i++ )
216     {
217         int s = (i_csp == X264_CSP_YV12 && i) ? i^3 : i;
218         uint8_t *plane = src->img.plane[s];
219         int stride = src->img.i_stride[s];
220         int width = h->param.i_width >> !!i;
221         int height = h->param.i_height >> !!i;
222         if( src->img.i_csp & X264_CSP_VFLIP )
223         {
224             plane += (height-1)*stride;
225             stride = -stride;
226         }
227         h->mc.plane_copy( dst->plane[i], dst->i_stride[i], plane, stride, width, height );
228     }
229     return 0;
230 }
231
232
233
234 static void plane_expand_border( uint8_t *pix, int i_stride, int i_width, int i_height, int i_padh, int i_padv, int b_pad_top, int b_pad_bottom )
235 {
236 #define PPIXEL(x, y) ( pix + (x) + (y)*i_stride )
237     int y;
238     for( y = 0; y < i_height; y++ )
239     {
240         /* left band */
241         memset( PPIXEL(-i_padh, y), PPIXEL(0, y)[0], i_padh );
242         /* right band */
243         memset( PPIXEL(i_width, y), PPIXEL(i_width-1, y)[0], i_padh );
244     }
245     /* upper band */
246     if( b_pad_top )
247     for( y = 0; y < i_padv; y++ )
248         memcpy( PPIXEL(-i_padh, -y-1), PPIXEL(-i_padh, 0), i_width+2*i_padh );
249     /* lower band */
250     if( b_pad_bottom )
251     for( y = 0; y < i_padv; y++ )
252         memcpy( PPIXEL(-i_padh, i_height+y), PPIXEL(-i_padh, i_height-1), i_width+2*i_padh );
253 #undef PPIXEL
254 }
255
256 void x264_frame_expand_border( x264_t *h, x264_frame_t *frame, int mb_y, int b_end )
257 {
258     int i;
259     int b_start = !mb_y;
260     if( mb_y & h->sh.b_mbaff )
261         return;
262     for( i = 0; i < frame->i_plane; i++ )
263     {
264         int stride = frame->i_stride[i];
265         int width = 16*h->sps->i_mb_width >> !!i;
266         int height = (b_end ? 16*(h->sps->i_mb_height - mb_y) >> h->sh.b_mbaff : 16) >> !!i;
267         int padh = PADH >> !!i;
268         int padv = PADV >> !!i;
269         // buffer: 2 chroma, 3 luma (rounded to 4) because deblocking goes beyond the top of the mb
270         uint8_t *pix = frame->plane[i] + X264_MAX(0, (16*mb_y-4)*stride >> !!i);
271         if( b_end && !b_start )
272             height += 4 >> (!!i + h->sh.b_mbaff);
273         if( h->sh.b_mbaff )
274         {
275             plane_expand_border( pix, stride*2, width, height, padh, padv, b_start, b_end );
276             plane_expand_border( pix+stride, stride*2, width, height, padh, padv, b_start, b_end );
277         }
278         else
279         {
280             plane_expand_border( pix, stride, width, height, padh, padv, b_start, b_end );
281         }
282     }
283 }
284
285 void x264_frame_expand_border_filtered( x264_t *h, x264_frame_t *frame, int mb_y, int b_end )
286 {
287     /* during filtering, 8 extra pixels were filtered on each edge,
288      * but up to 3 of the horizontal ones may be wrong.
289        we want to expand border from the last filtered pixel */
290     int b_start = !mb_y;
291     int stride = frame->i_stride[0];
292     int width = 16*h->sps->i_mb_width + 8;
293     int height = b_end ? (16*(h->sps->i_mb_height - mb_y) >> h->sh.b_mbaff) + 16 : 16;
294     int padh = PADH - 4;
295     int padv = PADV - 8;
296     int i;
297     for( i = 1; i < 4; i++ )
298     {
299         // buffer: 8 luma, to match the hpel filter
300         uint8_t *pix = frame->filtered[i] + (16*mb_y - (8 << h->sh.b_mbaff)) * stride - 4;
301         if( h->sh.b_mbaff )
302         {
303             plane_expand_border( pix, stride*2, width, height, padh, padv, b_start, b_end );
304             plane_expand_border( pix+stride, stride*2, width, height, padh, padv, b_start, b_end );
305         }
306         else
307         {
308             plane_expand_border( pix, stride, width, height, padh, padv, b_start, b_end );
309         }
310     }
311 }
312
313 void x264_frame_expand_border_lowres( x264_frame_t *frame )
314 {
315     int i;
316     for( i = 0; i < 4; i++ )
317         plane_expand_border( frame->lowres[i], frame->i_stride_lowres, frame->i_width_lowres, frame->i_lines_lowres, PADH, PADV, 1, 1 );
318 }
319
320 void x264_frame_expand_border_mod16( x264_t *h, x264_frame_t *frame )
321 {
322     int i, y;
323     for( i = 0; i < frame->i_plane; i++ )
324     {
325         int i_subsample = i ? 1 : 0;
326         int i_width = h->param.i_width >> i_subsample;
327         int i_height = h->param.i_height >> i_subsample;
328         int i_padx = ( h->sps->i_mb_width * 16 - h->param.i_width ) >> i_subsample;
329         int i_pady = ( h->sps->i_mb_height * 16 - h->param.i_height ) >> i_subsample;
330
331         if( i_padx )
332         {
333             for( y = 0; y < i_height; y++ )
334                 memset( &frame->plane[i][y*frame->i_stride[i] + i_width],
335                          frame->plane[i][y*frame->i_stride[i] + i_width - 1],
336                          i_padx );
337         }
338         if( i_pady )
339         {
340             //FIXME interlace? or just let it pad using the wrong field
341             for( y = i_height; y < i_height + i_pady; y++ )
342                 memcpy( &frame->plane[i][y*frame->i_stride[i]],
343                         &frame->plane[i][(i_height-1)*frame->i_stride[i]],
344                         i_width + i_padx );
345         }
346     }
347 }
348
349
350 /* cavlc + 8x8 transform stores nnz per 16 coeffs for the purpose of
351  * entropy coding, but per 64 coeffs for the purpose of deblocking */
352 static void munge_cavlc_nnz_row( x264_t *h, int mb_y, uint8_t (*buf)[16] )
353 {
354     uint32_t (*src)[6] = (uint32_t(*)[6])h->mb.non_zero_count + mb_y * h->sps->i_mb_width;
355     int8_t *transform = h->mb.mb_transform_size + mb_y * h->sps->i_mb_width;
356     int x, nnz;
357     for( x=0; x<h->sps->i_mb_width; x++ )
358     {
359         memcpy( buf+x, src+x, 16 );
360         if( transform[x] )
361         {
362             nnz = src[x][0] | src[x][1];
363             src[x][0] = src[x][1] = ((uint16_t)nnz ? 0x0101 : 0) + (nnz>>16 ? 0x01010000 : 0);
364             nnz = src[x][2] | src[x][3];
365             src[x][2] = src[x][3] = ((uint16_t)nnz ? 0x0101 : 0) + (nnz>>16 ? 0x01010000 : 0);
366         }
367     }
368 }
369
370 static void restore_cavlc_nnz_row( x264_t *h, int mb_y, uint8_t (*buf)[16] )
371 {
372     uint8_t (*dst)[24] = h->mb.non_zero_count + mb_y * h->sps->i_mb_width;
373     int x;
374     for( x=0; x<h->sps->i_mb_width; x++ )
375         memcpy( dst+x, buf+x, 16 );
376 }
377
378 static void munge_cavlc_nnz( x264_t *h, int mb_y, uint8_t (*buf)[16], void (*func)(x264_t*, int, uint8_t (*)[16]) )
379 {
380     func( h, mb_y, buf );
381     if( mb_y > 0 )
382         func( h, mb_y-1, buf + h->sps->i_mb_width );
383     if( h->sh.b_mbaff )
384     {
385         func( h, mb_y+1, buf + h->sps->i_mb_width * 2 );
386         if( mb_y > 0 )
387             func( h, mb_y-2, buf + h->sps->i_mb_width * 3 );
388     }
389 }
390
391
392 /* Deblocking filter */
393 static const uint8_t i_alpha_table[52+12*2] =
394 {
395      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
396      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
397      0,  0,  0,  0,  0,  0,  4,  4,  5,  6,
398      7,  8,  9, 10, 12, 13, 15, 17, 20, 22,
399     25, 28, 32, 36, 40, 45, 50, 56, 63, 71,
400     80, 90,101,113,127,144,162,182,203,226,
401    255,255,
402    255,255,255,255,255,255,255,255,255,255,255,255,
403 };
404 static const uint8_t i_beta_table[52+12*2] =
405 {
406      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
407      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
408      0,  0,  0,  0,  0,  0,  2,  2,  2,  3,
409      3,  3,  3,  4,  4,  4,  6,  6,  7,  7,
410      8,  8,  9,  9, 10, 10, 11, 11, 12, 12,
411     13, 13, 14, 14, 15, 15, 16, 16, 17, 17,
412     18, 18,
413     18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
414 };
415 static const int8_t i_tc0_table[52+12*2][4] =
416 {
417     {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
418     {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
419     {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
420     {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
421     {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 1 },
422     {-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 1, 1 }, {-1, 0, 1, 1 }, {-1, 1, 1, 1 },
423     {-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 },
424     {-1, 1, 1, 2 }, {-1, 1, 2, 3 }, {-1, 1, 2, 3 }, {-1, 2, 2, 3 }, {-1, 2, 2, 4 }, {-1, 2, 3, 4 },
425     {-1, 2, 3, 4 }, {-1, 3, 3, 5 }, {-1, 3, 4, 6 }, {-1, 3, 4, 6 }, {-1, 4, 5, 7 }, {-1, 4, 5, 8 },
426     {-1, 4, 6, 9 }, {-1, 5, 7,10 }, {-1, 6, 8,11 }, {-1, 6, 8,13 }, {-1, 7,10,14 }, {-1, 8,11,16 },
427     {-1, 9,12,18 }, {-1,10,13,20 }, {-1,11,15,23 }, {-1,13,17,25 },
428     {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
429     {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
430 };
431 #define alpha_table(x) i_alpha_table[(x)+12]
432 #define beta_table(x)  i_beta_table[(x)+12]
433 #define tc0_table(x)   i_tc0_table[(x)+12]
434
435 /* From ffmpeg */
436 static inline void deblock_luma_c( uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0 )
437 {
438     int i, d;
439     for( i = 0; i < 4; i++ )
440     {
441         if( tc0[i] < 0 )
442         {
443             pix += 4*ystride;
444             continue;
445         }
446         for( d = 0; d < 4; d++ )
447         {
448             const int p2 = pix[-3*xstride];
449             const int p1 = pix[-2*xstride];
450             const int p0 = pix[-1*xstride];
451             const int q0 = pix[ 0*xstride];
452             const int q1 = pix[ 1*xstride];
453             const int q2 = pix[ 2*xstride];
454
455             if( abs( p0 - q0 ) < alpha && abs( p1 - p0 ) < beta && abs( q1 - q0 ) < beta )
456             {
457                 int tc = tc0[i];
458                 int delta;
459                 if( abs( p2 - p0 ) < beta )
460                 {
461                     pix[-2*xstride] = p1 + x264_clip3( (( p2 + ((p0 + q0 + 1) >> 1)) >> 1) - p1, -tc0[i], tc0[i] );
462                     tc++;
463                 }
464                 if( abs( q2 - q0 ) < beta )
465                 {
466                     pix[ 1*xstride] = q1 + x264_clip3( (( q2 + ((p0 + q0 + 1) >> 1)) >> 1) - q1, -tc0[i], tc0[i] );
467                     tc++;
468                 }
469
470                 delta = x264_clip3( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
471                 pix[-1*xstride] = x264_clip_uint8( p0 + delta );    /* p0' */
472                 pix[ 0*xstride] = x264_clip_uint8( q0 - delta );    /* q0' */
473             }
474             pix += ystride;
475         }
476     }
477 }
478 static void deblock_v_luma_c( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 )
479 {
480     deblock_luma_c( pix, stride, 1, alpha, beta, tc0 );
481 }
482 static void deblock_h_luma_c( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 )
483 {
484     deblock_luma_c( pix, 1, stride, alpha, beta, tc0 );
485 }
486
487 static inline void deblock_chroma_c( uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0 )
488 {
489     int i, d;
490     for( i = 0; i < 4; i++ )
491     {
492         const int tc = tc0[i];
493         if( tc <= 0 )
494         {
495             pix += 2*ystride;
496             continue;
497         }
498         for( d = 0; d < 2; d++ )
499         {
500             const int p1 = pix[-2*xstride];
501             const int p0 = pix[-1*xstride];
502             const int q0 = pix[ 0*xstride];
503             const int q1 = pix[ 1*xstride];
504
505             if( abs( p0 - q0 ) < alpha && abs( p1 - p0 ) < beta && abs( q1 - q0 ) < beta )
506             {
507                 int delta = x264_clip3( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
508                 pix[-1*xstride] = x264_clip_uint8( p0 + delta );    /* p0' */
509                 pix[ 0*xstride] = x264_clip_uint8( q0 - delta );    /* q0' */
510             }
511             pix += ystride;
512         }
513     }
514 }
515 static void deblock_v_chroma_c( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 )
516 {
517     deblock_chroma_c( pix, stride, 1, alpha, beta, tc0 );
518 }
519 static void deblock_h_chroma_c( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 )
520 {
521     deblock_chroma_c( pix, 1, stride, alpha, beta, tc0 );
522 }
523
524 static inline void deblock_luma_intra_c( uint8_t *pix, int xstride, int ystride, int alpha, int beta )
525 {
526     int d;
527     for( d = 0; d < 16; d++ )
528     {
529         const int p2 = pix[-3*xstride];
530         const int p1 = pix[-2*xstride];
531         const int p0 = pix[-1*xstride];
532         const int q0 = pix[ 0*xstride];
533         const int q1 = pix[ 1*xstride];
534         const int q2 = pix[ 2*xstride];
535
536         if( abs( p0 - q0 ) < alpha && abs( p1 - p0 ) < beta && abs( q1 - q0 ) < beta )
537         {
538             if(abs( p0 - q0 ) < ((alpha >> 2) + 2) )
539             {
540                 if( abs( p2 - p0 ) < beta ) /* p0', p1', p2' */
541                 {
542                     const int p3 = pix[-4*xstride];
543                     pix[-1*xstride] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
544                     pix[-2*xstride] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
545                     pix[-3*xstride] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
546                 }
547                 else /* p0' */
548                     pix[-1*xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
549                 if( abs( q2 - q0 ) < beta ) /* q0', q1', q2' */
550                 {
551                     const int q3 = pix[3*xstride];
552                     pix[0*xstride] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
553                     pix[1*xstride] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
554                     pix[2*xstride] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
555                 }
556                 else /* q0' */
557                     pix[0*xstride] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
558             }
559             else /* p0', q0' */
560             {
561                 pix[-1*xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
562                 pix[ 0*xstride] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
563             }
564         }
565         pix += ystride;
566     }
567 }
568 static void deblock_v_luma_intra_c( uint8_t *pix, int stride, int alpha, int beta )
569 {
570     deblock_luma_intra_c( pix, stride, 1, alpha, beta );
571 }
572 static void deblock_h_luma_intra_c( uint8_t *pix, int stride, int alpha, int beta )
573 {
574     deblock_luma_intra_c( pix, 1, stride, alpha, beta );
575 }
576
577 static inline void deblock_chroma_intra_c( uint8_t *pix, int xstride, int ystride, int alpha, int beta )
578 {
579     int d;
580     for( d = 0; d < 8; d++ )
581     {
582         const int p1 = pix[-2*xstride];
583         const int p0 = pix[-1*xstride];
584         const int q0 = pix[ 0*xstride];
585         const int q1 = pix[ 1*xstride];
586
587         if( abs( p0 - q0 ) < alpha && abs( p1 - p0 ) < beta && abs( q1 - q0 ) < beta )
588         {
589             pix[-1*xstride] = (2*p1 + p0 + q1 + 2) >> 2;   /* p0' */
590             pix[ 0*xstride] = (2*q1 + q0 + p1 + 2) >> 2;   /* q0' */
591         }
592         pix += ystride;
593     }
594 }
595 static void deblock_v_chroma_intra_c( uint8_t *pix, int stride, int alpha, int beta )
596 {
597     deblock_chroma_intra_c( pix, stride, 1, alpha, beta );
598 }
599 static void deblock_h_chroma_intra_c( uint8_t *pix, int stride, int alpha, int beta )
600 {
601     deblock_chroma_intra_c( pix, 1, stride, alpha, beta );
602 }
603
604 static inline void deblock_edge( x264_t *h, uint8_t *pix1, uint8_t *pix2, int i_stride, uint8_t bS[4], int i_qp, int b_chroma, x264_deblock_inter_t pf_inter )
605 {
606     const int index_a = i_qp + h->sh.i_alpha_c0_offset;
607     const int alpha = alpha_table(index_a);
608     const int beta  = beta_table(i_qp + h->sh.i_beta_offset);
609     int8_t tc[4];
610
611     if( !alpha || !beta )
612         return;
613
614     tc[0] = tc0_table(index_a)[bS[0]] + b_chroma;
615     tc[1] = tc0_table(index_a)[bS[1]] + b_chroma;
616     tc[2] = tc0_table(index_a)[bS[2]] + b_chroma;
617     tc[3] = tc0_table(index_a)[bS[3]] + b_chroma;
618
619     pf_inter( pix1, i_stride, alpha, beta, tc );
620     if( b_chroma )
621         pf_inter( pix2, i_stride, alpha, beta, tc );
622 }
623
624 static inline void deblock_edge_intra( x264_t *h, uint8_t *pix1, uint8_t *pix2, int i_stride, uint8_t bS[4], int i_qp, int b_chroma, x264_deblock_intra_t pf_intra )
625 {
626     const int alpha = alpha_table(i_qp + h->sh.i_alpha_c0_offset);
627     const int beta  = beta_table(i_qp + h->sh.i_beta_offset);
628
629     if( !alpha || !beta )
630         return;
631
632     pf_intra( pix1, i_stride, alpha, beta );
633     if( b_chroma )
634         pf_intra( pix2, i_stride, alpha, beta );
635 }
636
637 void x264_frame_deblock_row( x264_t *h, int mb_y )
638 {
639     const int s8x8 = 2 * h->mb.i_mb_stride;
640     const int s4x4 = 4 * h->mb.i_mb_stride;
641     const int b_interlaced = h->sh.b_mbaff;
642     const int mvy_limit = 4 >> b_interlaced;
643     const int qp_thresh = 15 - X264_MIN(h->sh.i_alpha_c0_offset, h->sh.i_beta_offset) - X264_MAX(0, h->param.analyse.i_chroma_qp_offset);
644     const int no_sub8x8 = !(h->param.analyse.inter & X264_ANALYSE_PSUB8x8);
645     int mb_x;
646     int stridey   = h->fdec->i_stride[0];
647     int stride2y  = stridey << b_interlaced;
648     int strideuv  = h->fdec->i_stride[1];
649     int stride2uv = strideuv << b_interlaced;
650
651     if( !h->pps->b_cabac && h->pps->b_transform_8x8_mode )
652         munge_cavlc_nnz( h, mb_y, h->mb.nnz_backup, munge_cavlc_nnz_row );
653
654     for( mb_x = 0; mb_x < h->sps->i_mb_width; mb_x += (~b_interlaced | mb_y)&1, mb_y ^= b_interlaced )
655     {
656         const int mb_xy  = mb_y * h->mb.i_mb_stride + mb_x;
657         const int mb_8x8 = 2 * s8x8 * mb_y + 2 * mb_x;
658         const int mb_4x4 = 4 * s4x4 * mb_y + 4 * mb_x;
659         const int b_8x8_transform = h->mb.mb_transform_size[mb_xy];
660         const int i_qp = h->mb.qp[mb_xy];
661         int i_edge_end = (h->mb.type[mb_xy] == P_SKIP) ? 1 : 4;
662         uint8_t *pixy = h->fdec->plane[0] + 16*mb_y*stridey  + 16*mb_x;
663         uint8_t *pixu = h->fdec->plane[1] +  8*mb_y*strideuv +  8*mb_x;
664         uint8_t *pixv = h->fdec->plane[2] +  8*mb_y*strideuv +  8*mb_x;
665         if( b_interlaced && (mb_y&1) )
666         {
667             pixy -= 15*stridey;
668             pixu -=  7*strideuv;
669             pixv -=  7*strideuv;
670         }
671
672         x264_prefetch_fenc( h, h->fdec, mb_x, mb_y );
673
674         if( i_qp <= qp_thresh )
675             i_edge_end = 1;
676
677         #define FILTER_DIR(intra, i_dir)\
678         {\
679             /* Y plane */\
680             i_qpn= h->mb.qp[mbn_xy];\
681             if( i_dir == 0 )\
682             {\
683                 /* vertical edge */\
684                 deblock_edge##intra( h, pixy + 4*i_edge, NULL,\
685                               stride2y, bS, (i_qp+i_qpn+1) >> 1, 0,\
686                               h->loopf.deblock_h_luma##intra );\
687                 if( !(i_edge & 1) )\
688                 {\
689                     /* U/V planes */\
690                     int i_qpc = (h->chroma_qp_table[i_qp] + h->chroma_qp_table[i_qpn] + 1) >> 1;\
691                     deblock_edge##intra( h, pixu + 2*i_edge, pixv + 2*i_edge,\
692                                   stride2uv, bS, i_qpc, 1,\
693                                   h->loopf.deblock_h_chroma##intra );\
694                 }\
695             }\
696             else\
697             {\
698                 /* horizontal edge */\
699                 deblock_edge##intra( h, pixy + 4*i_edge*stride2y, NULL,\
700                               stride2y, bS, (i_qp+i_qpn+1) >> 1, 0,\
701                               h->loopf.deblock_v_luma##intra );\
702                 /* U/V planes */\
703                 if( !(i_edge & 1) )\
704                 {\
705                     int i_qpc = (h->chroma_qp_table[i_qp] + h->chroma_qp_table[i_qpn] + 1) >> 1;\
706                     deblock_edge##intra( h, pixu + 2*i_edge*stride2uv, pixv + 2*i_edge*stride2uv,\
707                                   stride2uv, bS, i_qpc, 1,\
708                                   h->loopf.deblock_v_chroma##intra );\
709                 }\
710             }\
711         }
712
713         #define DEBLOCK_STRENGTH(i_dir)\
714         {\
715             /* *** Get bS for each 4px for the current edge *** */\
716             if( IS_INTRA( h->mb.type[mb_xy] ) || IS_INTRA( h->mb.type[mbn_xy]) )\
717                 *(uint32_t*)bS = 0x03030303;\
718             else\
719             {\
720                 *(uint32_t*)bS = 0x00000000;\
721                 for( i = 0; i < 4; i++ )\
722                 {\
723                     int x  = i_dir == 0 ? i_edge : i;\
724                     int y  = i_dir == 0 ? i      : i_edge;\
725                     int xn = i_dir == 0 ? (x - 1)&0x03 : x;\
726                     int yn = i_dir == 0 ? y : (y - 1)&0x03;\
727                     if( h->mb.non_zero_count[mb_xy][x+y*4] != 0 ||\
728                         h->mb.non_zero_count[mbn_xy][xn+yn*4] != 0 )\
729                         bS[i] = 2;\
730                     else if(!(i_edge&no_sub8x8))\
731                     {\
732                         if((i&no_sub8x8) && bS[i-1] != 2)\
733                             bS[i] = bS[i-1];\
734                         else\
735                         {\
736                             /* FIXME: A given frame may occupy more than one position in\
737                              * the reference list. So we should compare the frame numbers,\
738                              * not the indices in the ref list.\
739                              * No harm yet, as we don't generate that case.*/\
740                             int i8p= mb_8x8+(x>>1)+(y>>1)*s8x8;\
741                             int i8q= mbn_8x8+(xn>>1)+(yn>>1)*s8x8;\
742                             int i4p= mb_4x4+x+y*s4x4;\
743                             int i4q= mbn_4x4+xn+yn*s4x4;\
744                             if((h->mb.ref[0][i8p] != h->mb.ref[0][i8q] ||\
745                                 abs( h->mb.mv[0][i4p][0] - h->mb.mv[0][i4q][0] ) >= 4 ||\
746                                 abs( h->mb.mv[0][i4p][1] - h->mb.mv[0][i4q][1] ) >= mvy_limit ) ||\
747                                (h->sh.i_type == SLICE_TYPE_B &&\
748                                (h->mb.ref[1][i8p] != h->mb.ref[1][i8q] ||\
749                                 abs( h->mb.mv[1][i4p][0] - h->mb.mv[1][i4q][0] ) >= 4 ||\
750                                 abs( h->mb.mv[1][i4p][1] - h->mb.mv[1][i4q][1] ) >= mvy_limit )))\
751                             {\
752                                 bS[i] = 1;\
753                             }\
754                         }\
755                     }\
756                 }\
757             }\
758         }
759
760         /* i_dir == 0 -> vertical edge
761          * i_dir == 1 -> horizontal edge */
762         #define DEBLOCK_DIR(i_dir)\
763         {\
764             int i_edge = (i_dir ? (mb_y <= b_interlaced) : (mb_x == 0));\
765             int i_qpn, i, mbn_xy, mbn_8x8, mbn_4x4;\
766             DECLARE_ALIGNED_4( uint8_t bS[4] );  /* filtering strength */\
767             if( i_edge )\
768                 i_edge+= b_8x8_transform;\
769             else\
770             {\
771                 mbn_xy  = i_dir == 0 ? mb_xy  - 1 : mb_xy - h->mb.i_mb_stride;\
772                 mbn_8x8 = i_dir == 0 ? mb_8x8 - 2 : mb_8x8 - 2 * s8x8;\
773                 mbn_4x4 = i_dir == 0 ? mb_4x4 - 4 : mb_4x4 - 4 * s4x4;\
774                 if( b_interlaced && i_dir == 1 )\
775                 {\
776                     mbn_xy -= h->mb.i_mb_stride;\
777                     mbn_8x8 -= 2 * s8x8;\
778                     mbn_4x4 -= 4 * s4x4;\
779                 }\
780                 else if( IS_INTRA( h->mb.type[mb_xy] ) || IS_INTRA( h->mb.type[mbn_xy]) )\
781                 {\
782                     FILTER_DIR( _intra, i_dir );\
783                     goto end##i_dir;\
784                 }\
785                 DEBLOCK_STRENGTH(i_dir);\
786                 if( *(uint32_t*)bS )\
787                     FILTER_DIR( , i_dir);\
788                 end##i_dir:\
789                 i_edge += b_8x8_transform+1;\
790             }\
791             mbn_xy  = mb_xy;\
792             mbn_8x8 = mb_8x8;\
793             mbn_4x4 = mb_4x4;\
794             for( ; i_edge < i_edge_end; i_edge+=b_8x8_transform+1 )\
795             {\
796                 DEBLOCK_STRENGTH(i_dir);\
797                 if( *(uint32_t*)bS )\
798                     FILTER_DIR( , i_dir);\
799             }\
800         }
801
802         DEBLOCK_DIR(0);
803         DEBLOCK_DIR(1);
804     }
805
806     if( !h->pps->b_cabac && h->pps->b_transform_8x8_mode )
807         munge_cavlc_nnz( h, mb_y, h->mb.nnz_backup, restore_cavlc_nnz_row );
808 }
809
810 void x264_frame_deblock( x264_t *h )
811 {
812     int mb_y;
813     for( mb_y = 0; mb_y < h->sps->i_mb_height; mb_y += 1 + h->sh.b_mbaff )
814         x264_frame_deblock_row( h, mb_y );
815 }
816
817 #ifdef HAVE_MMX
818 void x264_deblock_v_chroma_mmxext( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 );
819 void x264_deblock_h_chroma_mmxext( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 );
820 void x264_deblock_v_chroma_intra_mmxext( uint8_t *pix, int stride, int alpha, int beta );
821 void x264_deblock_h_chroma_intra_mmxext( uint8_t *pix, int stride, int alpha, int beta );
822
823 void x264_deblock_v_luma_sse2( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 );
824 void x264_deblock_h_luma_sse2( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 );
825 void x264_deblock_v_luma_intra_sse2( uint8_t *pix, int stride, int alpha, int beta );
826 void x264_deblock_h_luma_intra_sse2( uint8_t *pix, int stride, int alpha, int beta );
827 #ifdef ARCH_X86
828 void x264_deblock_h_luma_mmxext( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 );
829 void x264_deblock_v8_luma_mmxext( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 );
830 void x264_deblock_h_luma_intra_mmxext( uint8_t *pix, int stride, int alpha, int beta );
831 void x264_deblock_v8_luma_intra_mmxext( uint8_t *pix, int stride, int alpha, int beta );
832
833 static void x264_deblock_v_luma_mmxext( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 )
834 {
835     x264_deblock_v8_luma_mmxext( pix,   stride, alpha, beta, tc0   );
836     x264_deblock_v8_luma_mmxext( pix+8, stride, alpha, beta, tc0+2 );
837 }
838 static void x264_deblock_v_luma_intra_mmxext( uint8_t *pix, int stride, int alpha, int beta )
839 {
840     x264_deblock_v8_luma_intra_mmxext( pix,   stride, alpha, beta );
841     x264_deblock_v8_luma_intra_mmxext( pix+8, stride, alpha, beta );
842 }
843 #endif
844 #endif
845
846 #ifdef ARCH_PPC
847 void x264_deblock_v_luma_altivec( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 );
848 void x264_deblock_h_luma_altivec( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 );
849 #endif // ARCH_PPC
850
851 void x264_deblock_init( int cpu, x264_deblock_function_t *pf )
852 {
853     pf->deblock_v_luma = deblock_v_luma_c;
854     pf->deblock_h_luma = deblock_h_luma_c;
855     pf->deblock_v_chroma = deblock_v_chroma_c;
856     pf->deblock_h_chroma = deblock_h_chroma_c;
857     pf->deblock_v_luma_intra = deblock_v_luma_intra_c;
858     pf->deblock_h_luma_intra = deblock_h_luma_intra_c;
859     pf->deblock_v_chroma_intra = deblock_v_chroma_intra_c;
860     pf->deblock_h_chroma_intra = deblock_h_chroma_intra_c;
861
862 #ifdef HAVE_MMX
863     if( cpu&X264_CPU_MMXEXT )
864     {
865         pf->deblock_v_chroma = x264_deblock_v_chroma_mmxext;
866         pf->deblock_h_chroma = x264_deblock_h_chroma_mmxext;
867         pf->deblock_v_chroma_intra = x264_deblock_v_chroma_intra_mmxext;
868         pf->deblock_h_chroma_intra = x264_deblock_h_chroma_intra_mmxext;
869 #ifdef ARCH_X86
870         pf->deblock_v_luma = x264_deblock_v_luma_mmxext;
871         pf->deblock_h_luma = x264_deblock_h_luma_mmxext;
872         pf->deblock_v_luma_intra = x264_deblock_v_luma_intra_mmxext;
873         pf->deblock_h_luma_intra = x264_deblock_h_luma_intra_mmxext;
874 #endif
875         if( (cpu&X264_CPU_SSE2) && !(cpu&X264_CPU_STACK_MOD4) )
876         {
877             pf->deblock_v_luma = x264_deblock_v_luma_sse2;
878             pf->deblock_h_luma = x264_deblock_h_luma_sse2;
879             pf->deblock_v_luma_intra = x264_deblock_v_luma_intra_sse2;
880             pf->deblock_h_luma_intra = x264_deblock_h_luma_intra_sse2;
881         }
882     }
883 #endif
884
885 #ifdef ARCH_PPC
886     if( cpu&X264_CPU_ALTIVEC )
887     {
888         pf->deblock_v_luma = x264_deblock_v_luma_altivec;
889         pf->deblock_h_luma = x264_deblock_h_luma_altivec;
890    }
891 #endif // ARCH_PPC
892 }
893
894
895 /* threading */
896 void x264_frame_cond_broadcast( x264_frame_t *frame, int i_lines_completed )
897 {
898     x264_pthread_mutex_lock( &frame->mutex );
899     frame->i_lines_completed = i_lines_completed;
900     x264_pthread_cond_broadcast( &frame->cv );
901     x264_pthread_mutex_unlock( &frame->mutex );
902 }
903
904 void x264_frame_cond_wait( x264_frame_t *frame, int i_lines_completed )
905 {
906     x264_pthread_mutex_lock( &frame->mutex );
907     while( frame->i_lines_completed < i_lines_completed )
908         x264_pthread_cond_wait( &frame->cv, &frame->mutex );
909     x264_pthread_mutex_unlock( &frame->mutex );
910 }
911
912 /* list operators */
913
914 void x264_frame_push( x264_frame_t **list, x264_frame_t *frame )
915 {
916     int i = 0;
917     while( list[i] ) i++;
918     list[i] = frame;
919 }
920
921 x264_frame_t *x264_frame_pop( x264_frame_t **list )
922 {
923     x264_frame_t *frame;
924     int i = 0;
925     assert( list[0] );
926     while( list[i+1] ) i++;
927     frame = list[i];
928     list[i] = NULL;
929     return frame;
930 }
931
932 void x264_frame_unshift( x264_frame_t **list, x264_frame_t *frame )
933 {
934     int i = 0;
935     while( list[i] ) i++;
936     while( i-- )
937         list[i+1] = list[i];
938     list[0] = frame;
939 }
940
941 x264_frame_t *x264_frame_shift( x264_frame_t **list )
942 {
943     x264_frame_t *frame = list[0];
944     int i;
945     for( i = 0; list[i]; i++ )
946         list[i] = list[i+1];
947     assert(frame);
948     return frame;
949 }
950
951 void x264_frame_push_unused( x264_t *h, x264_frame_t *frame )
952 {
953     assert( frame->i_reference_count > 0 );
954     frame->i_reference_count--;
955     if( frame->i_reference_count == 0 )
956         x264_frame_push( h->frames.unused, frame );
957     assert( h->frames.unused[ sizeof(h->frames.unused) / sizeof(*h->frames.unused) - 1 ] == NULL );
958 }
959
960 x264_frame_t *x264_frame_pop_unused( x264_t *h )
961 {
962     x264_frame_t *frame;
963     if( h->frames.unused[0] )
964         frame = x264_frame_pop( h->frames.unused );
965     else
966         frame = x264_frame_new( h );
967     if( !frame )
968         return NULL;
969     frame->i_reference_count = 1;
970     frame->b_intra_calculated = 0;
971     return frame;
972 }
973
974 void x264_frame_sort( x264_frame_t **list, int b_dts )
975 {
976     int i, b_ok;
977     do {
978         b_ok = 1;
979         for( i = 0; list[i+1]; i++ )
980         {
981             int dtype = list[i]->i_type - list[i+1]->i_type;
982             int dtime = list[i]->i_frame - list[i+1]->i_frame;
983             int swap = b_dts ? dtype > 0 || ( dtype == 0 && dtime > 0 )
984                              : dtime > 0;
985             if( swap )
986             {
987                 XCHG( x264_frame_t*, list[i], list[i+1] );
988                 b_ok = 0;
989             }
990         }
991     } while( !b_ok );
992 }