开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
frame.c
资源名称：X264CODEC.rar　[点击查看]
上传用户：lctgjx
上传日期：2022-06-04
资源大小：8887k
文件大小：39k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

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