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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
checkasm.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：21k
源码类别：

Audio

开发平台：

Visual C++

checkasm.c：源码内容
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. #include "common/common.h"
  6. #include "common/cpu.h"
  7. #ifdef HAVE_MMXEXT
  8. #include "common/i386/pixel.h"
  9. #include "common/i386/dct.h"
  10. #include "common/i386/mc.h"
  11. #endif
  12. #ifdef ARCH_PPC
  13. #include "common/ppc/pixel.h"
  14. #include "common/ppc/mc.h"
  15. #endif
  17. /* buf1, buf2: initialised to random data and shouldn't write into them */
  18. uint8_t * buf1, * buf2;
  19. /* buf3, buf4: used to store output */
  20. uint8_t * buf3, * buf4;
  21. /* buf5: temp */
  22. uint8_t * buf5;
  24. #define report( name ) { 
  25.     if( used_asm ) 
  26.         fprintf( stderr, " - %-21s [%s]n", name, ok ? "OK" : "FAILED" ); 
  27.     if( !ok ) ret = -1; 
  28. }
  30. static int check_pixel( int cpu_ref, int cpu_new )
  31. {
  32.     x264_pixel_function_t pixel_c;
  33.     x264_pixel_function_t pixel_ref;
  34.     x264_pixel_function_t pixel_asm;
  35.     int ret = 0, ok, used_asm;
  36.     int i;
  38.     x264_pixel_init( 0, &pixel_c );
  39.     x264_pixel_init( cpu_ref, &pixel_ref );
  40.     x264_pixel_init( cpu_new, &pixel_asm );
  42. #define TEST_PIXEL( name ) 
  43.     for( i = 0, ok = 1, used_asm = 0; i < 7; i++ ) 
  44.     { 
  45.         int res_c, res_asm; 
  46.         if( pixel_asm.name[i] != pixel_ref.name[i] ) 
  47.         { 
  48.             used_asm = 1; 
  49.             res_c   = pixel_c.name[i]( buf1, 32, buf2, 24 ); 
  50.             res_asm = pixel_asm.name[i]( buf1, 32, buf2, 24 ); 
  51.             if( res_c != res_asm ) 
  52.             { 
  53.                 ok = 0; 
  54.                 fprintf( stderr, #name "[%d]: %d != %d [FAILED]n", i, res_c, res_asm ); 
  55.             } 
  56.         } 
  57.     } 
  58.     report( "pixel " #name " :" );
  60.     TEST_PIXEL( sad );
  61.     TEST_PIXEL( ssd );
  62.     TEST_PIXEL( satd );
  64.     return ret;
  65. }
  67. static int check_dct( int cpu_ref, int cpu_new )
  68. {
  69.     x264_dct_function_t dct_c;
  70.     x264_dct_function_t dct_ref;
  71.     x264_dct_function_t dct_asm;
  72.     int ret = 0, ok, used_asm;
  73.     int16_t dct1[16][4][4] __attribute((aligned(16)));
  74.     int16_t dct2[16][4][4] __attribute((aligned(16)));
  76.     x264_dct_init( 0, &dct_c );
  77.     x264_dct_init( cpu_ref, &dct_ref);
  78.     x264_dct_init( cpu_new, &dct_asm );
  79. #define TEST_DCT( name, t1, t2, size ) 
  80.     if( dct_asm.name != dct_ref.name ) 
  81.     { 
  82.         used_asm = 1; 
  83.         dct_c.name( t1, buf1, 32, buf2, 24 ); 
  84.         dct_asm.name( t2, buf1, 32, buf2, 24 ); 
  85.         if( memcmp( t1, t2, size ) ) 
  86.         { 
  87.             ok = 0; 
  88.             fprintf( stderr, #name " [FAILED]n" ); 
  89.         } 
  90.     }
  91.     ok = 1; used_asm = 0;
  92.     TEST_DCT( sub4x4_dct, dct1[0], dct2[0], 16*2 );
  93.     TEST_DCT( sub8x8_dct, dct1, dct2, 16*2*4 );
  94.     TEST_DCT( sub16x16_dct, dct1, dct2, 16*2*16 );
  95.     report( "sub_dct4 :" );
  97.     ok = 1; used_asm = 0;
  98.     TEST_DCT( sub8x8_dct8, (void*)dct1[0], (void*)dct2[0], 64*2 );
  99.     TEST_DCT( sub16x16_dct8, (void*)dct1, (void*)dct2, 64*2*4 );
  100.     report( "sub_dct8 :" );
  101. #undef TEST_DCT
  103.     /* copy coefs because idct8 modifies them in place */
  104.     memcpy( buf5, dct1, 512 );
  106. #define TEST_IDCT( name ) 
  107.     if( dct_asm.name != dct_ref.name ) 
  108.     { 
  109.         used_asm = 1; 
  110.         memcpy( buf3, buf1, 32*32 ); 
  111.         memcpy( buf4, buf1, 32*32 ); 
  112.         memcpy( dct1, buf5, 512 ); 
  113.         memcpy( dct2, buf5, 512 ); 
  114.         dct_c.name( buf3, 32, (void*)dct1 ); 
  115.         dct_asm.name( buf4, 32, (void*)dct2 ); 
  116.         if( memcmp( buf3, buf4, 32*32 ) ) 
  117.         { 
  118.             ok = 0; 
  119.             fprintf( stderr, #name " [FAILED]n" ); 
  120.         } 
  121.     }
  122.     ok = 1; used_asm = 0;
  123.     TEST_IDCT( add4x4_idct );
  124.     TEST_IDCT( add8x8_idct );
  125.     TEST_IDCT( add16x16_idct );
  126.     report( "add_idct4 :" );
  128.     ok = 1; used_asm = 0;
  129.     TEST_IDCT( add8x8_idct8 );
  130.     TEST_IDCT( add16x16_idct8 );
  131.     report( "add_idct8 :" );
  132. #undef TEST_IDCT
  134.     ok = 1; used_asm = 0;
  135.     if( dct_asm.dct4x4dc != dct_ref.dct4x4dc )
  136.     {
  137.         int16_t dct1[4][4] __attribute((aligned(16))) = { {-12, 42, 23, 67},{2, 90, 89,56}, {67,43,-76,91},{56,-78,-54,1}};
  138.         int16_t dct2[4][4] __attribute((aligned(16))) = { {-12, 42, 23, 67},{2, 90, 89,56}, {67,43,-76,91},{56,-78,-54,1}};
  139.         used_asm = 1;
  140.         dct_c.dct4x4dc( dct1 );
  141.         dct_asm.dct4x4dc( dct2 );
  142.         if( memcmp( dct1, dct2, 32 ) )
  143.         {
  144.             ok = 0;
  145.             fprintf( stderr, " - dct4x4dc :        [FAILED]n" );
  146.         }
  147.     }
  148.     if( dct_asm.dct4x4dc != dct_ref.dct4x4dc )
  149.     {
  150.         int16_t dct1[4][4] __attribute((aligned(16))) = { {-12, 42, 23, 67},{2, 90, 89,56}, {67,43,-76,91},{56,-78,-54,1}};
  151.         int16_t dct2[4][4] __attribute((aligned(16))) = { {-12, 42, 23, 67},{2, 90, 89,56}, {67,43,-76,91},{56,-78,-54,1}};
  152.         used_asm = 1;
  153.         dct_c.idct4x4dc( dct1 );
  154.         dct_asm.idct4x4dc( dct2 );
  155.         if( memcmp( dct1, dct2, 32 ) )
  156.         {
  157.             ok = 0;
  158.             fprintf( stderr, " - idct4x4dc :        [FAILED]n" );
  159.         }
  160.     }
  161.     report( "(i)dct4x4dc :" );
  163.     ok = 1; used_asm = 0;
  164.     if( dct_asm.dct2x2dc != dct_ref.dct2x2dc )
  165.     {
  166.         int16_t dct1[2][2] __attribute((aligned(16))) = { {-12, 42},{2, 90}};
  167.         int16_t dct2[2][2] __attribute((aligned(16))) = { {-12, 42},{2, 90}};
  168.         used_asm = 1;
  169.         dct_c.dct2x2dc( dct1 );
  170.         dct_asm.dct2x2dc( dct2 );
  171.         if( memcmp( dct1, dct2, 4*2 ) )
  172.         {
  173.             ok = 0;
  174.             fprintf( stderr, " - dct2x2dc :        [FAILED]n" );
  175.         }
  176.     }
  177.     if( dct_asm.idct2x2dc != dct_ref.idct2x2dc )
  178.     {
  179.         int16_t dct1[2][2] __attribute((aligned(16))) = { {-12, 42},{2, 90}};
  180.         int16_t dct2[2][2] __attribute((aligned(16))) = { {-12, 42},{2, 90}};
  181.         used_asm = 1;
  182.         dct_c.idct2x2dc( dct1 );
  183.         dct_asm.idct2x2dc( dct2 );
  184.         if( memcmp( dct1, dct2, 4*2 ) )
  185.         {
  186.             ok = 0;
  187.             fprintf( stderr, " - idct2x2dc :       [FAILED]n" );
  188.         }
  189.     }
  190.     report( "(i)dct2x2dc :" );
  192.     return ret;
  193. }
  195. static int check_mc( int cpu_ref, int cpu_new )
  196. {
  197.     x264_mc_functions_t mc_c;
  198.     x264_mc_functions_t mc_ref;
  199.     x264_mc_functions_t mc_a;
  201.     uint8_t *src     = &buf1[2*32+2];
  202.     uint8_t *src2[4] = { &buf1[2*32+2],  &buf1[7*32+2],
  203.                          &buf1[12*32+2], &buf1[17*32+2] };
  204.     uint8_t *dst1    = &buf3[2*32+2];
  205.     uint8_t *dst2    = &buf4[2*32+2];
  207.     int dx, dy, i, w;
  208.     int ret = 0, ok, used_asm;
  210.     x264_mc_init( 0, &mc_c );
  211.     x264_mc_init( cpu_ref, &mc_ref );
  212.     x264_mc_init( cpu_new, &mc_a );
  214. #define MC_TEST_LUMA( w, h ) 
  215.         if( mc_a.mc_luma != mc_ref.mc_luma ) 
  216.         { 
  217.             used_asm = 1; 
  218.             memset(buf3, 0xCD, 1024); 
  219.             memset(buf4, 0xCD, 1024); 
  220.             mc_c.mc_luma( src2, 32, dst1, 16, dx, dy, w, h );     
  221.             mc_a.mc_luma( src2, 32, dst2, 16, dx, dy, w, h );   
  222.             if( memcmp( buf3, buf4, 1024 ) )               
  223.             { 
  224.                 fprintf( stderr, "mc_luma[mv(%d,%d) %2dx%-2d]     [FAILED]n", dx, dy, w, h );   
  225.                 ok = 0; 
  226.             } 
  227.         }
  229. #define MC_TEST_CHROMA( w, h ) 
  230.         if( mc_a.mc_chroma != mc_ref.mc_chroma ) 
  231.         { 
  232.             used_asm = 1; 
  233.             memset(buf3, 0xCD, 1024); 
  234.             memset(buf4, 0xCD, 1024); 
  235.             mc_c.mc_chroma( src, 32, dst1, 16, dx, dy, w, h );     
  236.             mc_a.mc_chroma( src, 32, dst2, 16, dx, dy, w, h );   
  237.             if( memcmp( buf3, buf4, 1024 ) )               
  238.             { 
  239.                 fprintf( stderr, "mc_chroma[mv(%d,%d) %2dx%-2d]     [FAILED]n", dx, dy, w, h );   
  240.                 ok = 0; 
  241.             } 
  242.         }
  243.     ok = 1; used_asm = 0;
  244.     for( dy = 0; dy < 4; dy++ )
  245.         for( dx = 0; dx < 4; dx++ )
  246.         {
  247.             MC_TEST_LUMA( 16, 16 );
  248.             MC_TEST_LUMA( 16, 8 );
  249.             MC_TEST_LUMA( 8, 16 );
  250.             MC_TEST_LUMA( 8, 8 );
  251.             MC_TEST_LUMA( 8, 4 );
  252.             MC_TEST_LUMA( 4, 8 );
  253.             MC_TEST_LUMA( 4, 4 );
  254.         }
  255.     report( "mc luma :" );
  257.     ok = 1; used_asm = 0;
  258.     for( dy = 0; dy < 9; dy++ )
  259.         for( dx = 0; dx < 9; dx++ )
  260.         {
  261.             MC_TEST_CHROMA( 8, 8 );
  262.             MC_TEST_CHROMA( 8, 4 );
  263.             MC_TEST_CHROMA( 4, 8 );
  264.             MC_TEST_CHROMA( 4, 4 );
  265.             MC_TEST_CHROMA( 4, 2 );
  266.             MC_TEST_CHROMA( 2, 4 );
  267.             MC_TEST_CHROMA( 2, 2 );
  268.         }
  269.     report( "mc chroma :" );
  270. #undef MC_TEST_LUMA
  271. #undef MC_TEST_CHROMA
  273. #define MC_TEST_AVG( name, ... ) 
  274.     for( i = 0, ok = 1, used_asm = 0; i < 10; i++ ) 
  275.     { 
  276.         memcpy( buf3, buf1, 1024 ); 
  277.         memcpy( buf4, buf1, 1024 ); 
  278.         if( mc_a.name[i] != mc_ref.name[i] ) 
  279.         { 
  280.             used_asm = 1; 
  281.             mc_c.name[i]( buf3, 32, buf2, 24, ##__VA_ARGS__ ); 
  282.             mc_a.name[i]( buf4, 32, buf2, 24, ##__VA_ARGS__ ); 
  283.             if( memcmp( buf3, buf4, 1024 ) )               
  284.             { 
  285.                 ok = 0; 
  286.                 fprintf( stderr, #name "[%d]: [FAILED]n", i ); 
  287.             } 
  288.         } 
  289.     }
  290.     MC_TEST_AVG( avg );
  291.     report( "mc avg :" );
  292.     for( w = -64; w <= 128 && ok; w++ )
  293.         MC_TEST_AVG( avg_weight, w );
  294.     report( "mc wpredb :" );
  296.     return ret;
  297. }
  299. static int check_deblock( int cpu_ref, int cpu_new )
  300. {
  301.     x264_deblock_function_t db_c;
  302.     x264_deblock_function_t db_ref;
  303.     x264_deblock_function_t db_a;
  304.     int ret = 0, ok = 1, used_asm = 0;
  305.     int alphas[36], betas[36];
  306.     int8_t tcs[36][4];
  307.     int a, c, i, j;
  309.     x264_deblock_init( 0, &db_c );
  310.     x264_deblock_init( cpu_ref, &db_ref );
  311.     x264_deblock_init( cpu_new, &db_a );
  313.     /* not exactly the real values of a,b,tc but close enough */
  314.     a = 255; c = 250;
  315.     for( i = 35; i >= 0; i-- )
  316.     {
  317.         alphas[i] = a;
  318.         betas[i] = (i+1)/2;
  319.         tcs[i][0] = tcs[i][2] = (c+6)/10;
  320.         tcs[i][1] = tcs[i][3] = (c+9)/20;
  321.         a = a*9/10;
  322.         c = c*9/10;
  323.     }
  325. #define TEST_DEBLOCK( name, ... ) 
  326.     for( i = 0; i < 36; i++ ) 
  327.     { 
  328.         for( j = 0; j < 1024; j++ ) 
  329.             /* two distributions of random to excersize different failure modes */
  330.             buf1[j] = rand() & (i&1 ? 0xf : 0xff ); 
  331.         memcpy( buf3, buf1, 1024 ); 
  332.         memcpy( buf4, buf1, 1024 ); 
  333.         if( db_a.name != db_ref.name ) 
  334.         { 
  335.             used_asm = 1; 
  336.             db_c.name( &buf3[8*32], 32, alphas[i], betas[i], ##__VA_ARGS__ ); 
  337.             db_a.name( &buf4[8*32], 32, alphas[i], betas[i], ##__VA_ARGS__ ); 
  338.             if( memcmp( buf3, buf4, 1024 ) )               
  339.             { 
  340.                 ok = 0; 
  341.                 fprintf( stderr, #name "(a=%d, b=%d): [FAILED]n", alphas[i], betas[i] ); 
  342.                 break; 
  343.             } 
  344.         } 
  345.     }
  347.     TEST_DEBLOCK( deblock_h_luma, tcs[i] );
  348.     TEST_DEBLOCK( deblock_v_luma, tcs[i] );
  349.     TEST_DEBLOCK( deblock_h_chroma, tcs[i] );
  350.     TEST_DEBLOCK( deblock_v_chroma, tcs[i] );
  351.     TEST_DEBLOCK( deblock_h_luma_intra );
  352.     TEST_DEBLOCK( deblock_v_luma_intra );
  353.     TEST_DEBLOCK( deblock_h_chroma_intra );
  354.     TEST_DEBLOCK( deblock_v_chroma_intra );
  356.     report( "deblock :" );
  358.     return ret;
  359. }
  361. static int check_quant( int cpu_ref, int cpu_new )
  362. {
  363.     x264_quant_function_t qf_c;
  364.     x264_quant_function_t qf_ref;
  365.     x264_quant_function_t qf_a;
  366.     int16_t dct1[64], dct2[64];
  367.     uint8_t cqm_buf[64];
  368.     int ret = 0, ok, used_asm;
  369.     int oks[2] = {1,1}, used_asms[2] = {0,0};
  370.     int i, i_cqm;
  371.     x264_t h_buf;
  372.     x264_t *h = &h_buf;
  373.     h->pps = h->pps_array;
  374.     x264_param_default( &h->param );
  376.     for( i_cqm = 0; i_cqm < 4; i_cqm++ )
  377.     {
  378.         if( i_cqm == 0 )
  379.             for( i = 0; i < 6; i++ )
  380.                 h->pps->scaling_list[i] = x264_cqm_flat16;
  381.         else if( i_cqm == 1 )
  382.             for( i = 0; i < 6; i++ )
  383.                 h->pps->scaling_list[i] = x264_cqm_jvt[i];
  384.         else
  385.         {
  386.             if( i_cqm == 2 )
  387.                 for( i = 0; i < 64; i++ )
  388.                     cqm_buf[i] = 10 + rand() % 246;
  389.             else
  390.                 for( i = 0; i < 64; i++ )
  391.                     cqm_buf[i] = 1;
  392.             for( i = 0; i < 6; i++ )
  393.                 h->pps->scaling_list[i] = cqm_buf;
  394.         }
  396.         x264_cqm_init( h );
  397.         x264_quant_init( h, 0, &qf_c );
  398.         x264_quant_init( h, cpu_ref, &qf_ref );
  399.         x264_quant_init( h, cpu_new, &qf_a );
  401. #define INIT_QUANT8() 
  402.         { 
  403.             static const int scale1d[8] = {32,31,24,31,32,31,24,31}; 
  404.             int x, y; 
  405.             for( y = 0; y < 8; y++ ) 
  406.                 for( x = 0; x < 8; x++ ) 
  407.                 { 
  408.                     unsigned int scale = (255*scale1d[y]*scale1d[x])/16; 
  409.                     dct1[y*8+x] = dct2[y*8+x] = (rand()%(2*scale+1))-scale; 
  410.                 } 
  411.         }
  413. #define INIT_QUANT4() 
  414.         { 
  415.             static const int scale1d[4] = {4,6,4,6}; 
  416.             int x, y; 
  417.             for( y = 0; y < 4; y++ ) 
  418.                 for( x = 0; x < 4; x++ ) 
  419.                 { 
  420.                     unsigned int scale = 255*scale1d[y]*scale1d[x]; 
  421.                     dct1[y*4+x] = dct2[y*4+x] = (rand()%(2*scale+1))-scale; 
  422.                 } 
  423.         }
  425. #define TEST_QUANT( name, cqm ) 
  426.         if( qf_a.name != qf_ref.name ) 
  427.         { 
  428.             used_asms[0] = 1; 
  429.             for( i = 0; i < 64; i++ ) 
  430.                 dct1[i] = dct2[i] = (rand() & 0x1fff) - 0xfff; 
  431.             qf_c.name( (void*)dct1, cqm, 20, (1<<20)/6 ); 
  432.             qf_a.name( (void*)dct2, cqm, 20, (1<<20)/6 ); 
  433.             if( memcmp( dct1, dct2, 64*2 ) )       
  434.             { 
  435.                 oks[0] = 0; 
  436.                 fprintf( stderr, #name "(cqm=%d): [FAILED]n", i_cqm ); 
  437.             } 
  438.         }
  440. #define TEST_QUANT8( qname, cqm, shift, divider ) 
  441.         if( qf_a.qname != qf_ref.qname ) 
  442.         { 
  443.             int qp; 
  444.             used_asms[0] = 1; 
  445.             for( qp = 51; qp > 0; qp-- ) 
  446.             { 
  447.                 INIT_QUANT8() 
  448.                 qf_c.qname( (void*)dct1, cqm[qp%6], shift+qp/6, (1<<(shift+qp/6))/divider ); 
  449.                 qf_a.qname( (void*)dct2, cqm[qp%6], shift+qp/6, (1<<(shift+qp/6))/divider ); 
  450.                 if( memcmp( dct1, dct2, 64*2 ) ) 
  451.                 { 
  452.                     oks[0] = 0; 
  453.                     fprintf( stderr, #qname "(qp=%d, cqm=%d, intra=%d): [FAILED]n", qp, i_cqm, divider==3 ); 
  454.                     break; 
  455.                 } 
  456.             } 
  457.         }
  459. #define TEST_QUANT4( qname, cqm, shift, divider ) 
  460.         if( qf_a.qname != qf_ref.qname ) 
  461.         { 
  462.             int qp; 
  463.             used_asms[0] = 1; 
  464.             for( qp = 51; qp > 0; qp-- ) 
  465.             { 
  466.                 INIT_QUANT4() 
  467.                 qf_c.qname( (void*)dct1, cqm[qp%6], shift+qp/6, (1<<(shift+qp/6))/divider ); 
  468.                 qf_a.qname( (void*)dct2, cqm[qp%6], shift+qp/6, (1<<(shift+qp/6))/divider ); 
  469.                 if( memcmp( dct1, dct2, 16*2 ) ) 
  470.                 { 
  471.                     oks[0] = 0; 
  472.                     fprintf( stderr, #qname "(qp=%d, cqm=%d, intra=%d): [FAILED]n", qp, i_cqm, divider==3 ); 
  473.                     break; 
  474.                 } 
  475.             } 
  476.         }
  478.         TEST_QUANT8( quant_8x8_core, h->quant8_mf[CQM_8IY], 16, 3 );
  479.         TEST_QUANT8( quant_8x8_core, h->quant8_mf[CQM_8PY], 16, 6 );
  480.         TEST_QUANT4( quant_4x4_core, h->quant4_mf[CQM_4IY], 15, 3 );
  481.         TEST_QUANT4( quant_4x4_core, h->quant4_mf[CQM_4PY], 15, 6 );
  482.         TEST_QUANT( quant_4x4_dc_core, ***h->quant4_mf[CQM_4IY] );
  483.         TEST_QUANT( quant_2x2_dc_core, ***h->quant4_mf[CQM_4IC] );
  485. #define TEST_DEQUANT8( qname, dqname, cqm, dqm, shift, divider ) 
  486.         if( qf_a.dqname != qf_ref.dqname ) 
  487.         { 
  488.             int qp; 
  489.             used_asms[1] = 1; 
  490.             for( qp = 51; qp > 0; qp-- ) 
  491.             { 
  492.                 INIT_QUANT8() 
  493.                 qf_c.qname( (void*)dct1, cqm[qp%6], shift+qp/6, (1<<(shift+qp/6))/divider ); 
  494.                 memcpy( dct2, dct1, 64*2 ); 
  495.                 qf_c.dqname( (void*)dct1, dqm, qp ); 
  496.                 qf_a.dqname( (void*)dct2, dqm, qp ); 
  497.                 if( memcmp( dct1, dct2, 64*2 ) ) 
  498.                 { 
  499.                     oks[1] = 0; 
  500.                     fprintf( stderr, #dqname "(qp=%d, cqm=%d, intra=%d): [FAILED]n", qp, i_cqm, divider==3 ); 
  501.                     break; 
  502.                 } 
  503.             } 
  504.         }
  506. #define TEST_DEQUANT4( qname, dqname, cqm, dqm, shift, divider ) 
  507.         if( qf_a.dqname != qf_ref.dqname ) 
  508.         { 
  509.             int qp; 
  510.             used_asms[1] = 1; 
  511.             for( qp = 51; qp > 0; qp-- ) 
  512.             { 
  513.                 INIT_QUANT4() 
  514.                 qf_c.qname( (void*)dct1, cqm[qp%6], shift+qp/6, (1<<(shift+qp/6))/divider ); 
  515.                 memcpy( dct2, dct1, 16*2 ); 
  516.                 qf_c.dqname( (void*)dct1, dqm, qp ); 
  517.                 qf_a.dqname( (void*)dct2, dqm, qp ); 
  518.                 if( memcmp( dct1, dct2, 16*2 ) ) 
  519.                 { 
  520.                     oks[1] = 0; 
  521.                     fprintf( stderr, #dqname "(qp=%d, cqm=%d, intra=%d): [FAILED]n", qp, i_cqm, divider==3 ); 
  522.                     break; 
  523.                 } 
  524.             } 
  525.         }
  527.         TEST_DEQUANT8( quant_8x8_core, dequant_8x8, h->quant8_mf[CQM_8IY], h->dequant8_mf[CQM_8IY], 16, 3 );
  528.         TEST_DEQUANT8( quant_8x8_core, dequant_8x8, h->quant8_mf[CQM_8PY], h->dequant8_mf[CQM_8PY], 16, 6 );
  529.         TEST_DEQUANT4( quant_4x4_core, dequant_4x4, h->quant4_mf[CQM_4IY], h->dequant4_mf[CQM_4IY], 15, 3 );
  530.         TEST_DEQUANT4( quant_4x4_core, dequant_4x4, h->quant4_mf[CQM_4PY], h->dequant4_mf[CQM_4PY], 15, 6 );
  531.     }
  533.     ok = oks[0]; used_asm = used_asms[0];
  534.     report( "quant :" );
  536.     ok = oks[1]; used_asm = used_asms[1];
  537.     report( "dequant :" );
  539.     return ret;
  540. }
  542. static int check_intra( int cpu_ref, int cpu_new )
  543. {
  544.     int ret = 0, ok = 1, used_asm = 0;
  545.     int i;
  546.     struct
  547.     {
  548.         x264_predict_t      predict_16x16[4+3];
  549.         x264_predict_t      predict_8x8c[4+3];
  550.         x264_predict8x8_t   predict_8x8[9+3];
  551.         x264_predict_t      predict_4x4[9+3];
  552.     } ip_c, ip_ref, ip_a;
  554.     x264_predict_16x16_init( 0, ip_c.predict_16x16 );
  555.     x264_predict_8x8c_init( 0, ip_c.predict_8x8c );
  556.     x264_predict_8x8_init( 0, ip_c.predict_8x8 );
  557.     x264_predict_4x4_init( 0, ip_c.predict_4x4 );
  559.     x264_predict_16x16_init( cpu_ref, ip_ref.predict_16x16 );
  560.     x264_predict_8x8c_init( cpu_ref, ip_ref.predict_8x8c );
  561.     x264_predict_8x8_init( cpu_ref, ip_ref.predict_8x8 );
  562.     x264_predict_4x4_init( cpu_ref, ip_ref.predict_4x4 );
  564.     x264_predict_16x16_init( cpu_new, ip_a.predict_16x16 );
  565.     x264_predict_8x8c_init( cpu_new, ip_a.predict_8x8c );
  566.     x264_predict_8x8_init( cpu_new, ip_a.predict_8x8 );
  567.     x264_predict_4x4_init( cpu_new, ip_a.predict_4x4 );
  569. #define INTRA_TEST( name, dir, ... ) 
  570.     if( ip_a.name[dir] != ip_ref.name[dir] )
  571.     { 
  572.         used_asm = 1; 
  573.         memcpy( buf3, buf1, 32*20 );
  574.         memcpy( buf4, buf1, 32*20 );
  575.         ip_c.name[dir]( buf3+48, ##__VA_ARGS__ );
  576.         ip_a.name[dir]( buf4+48, ##__VA_ARGS__ );
  577.         if( memcmp( buf3, buf4, 32*20 ) )
  578.         {
  579.             fprintf( stderr, #name "[%d] :  [FAILED]n", dir );
  580.             ok = 0;
  581.         }
  582.     }
  584.     for( i = 0; i < 12; i++ )
  585.         INTRA_TEST( predict_4x4, i );
  586.     for( i = 0; i < 7; i++ )
  587.         INTRA_TEST( predict_8x8c, i );
  588.     for( i = 0; i < 7; i++ )
  589.         INTRA_TEST( predict_16x16, i );
  590.     for( i = 0; i < 12; i++ )
  591.         INTRA_TEST( predict_8x8, i, 0xf );
  592.     for( i = 0; i < 12; i++ )
  593.         INTRA_TEST( predict_8x8, i, MB_LEFT|MB_TOP|MB_TOPLEFT );
  594.     INTRA_TEST( predict_8x8, I_PRED_8x8_V,  MB_LEFT|MB_TOP );
  595.     INTRA_TEST( predict_8x8, I_PRED_8x8_DC, MB_LEFT|MB_TOP );
  596.     INTRA_TEST( predict_8x8, I_PRED_8x8_DDL,MB_LEFT|MB_TOP );
  597.     INTRA_TEST( predict_8x8, I_PRED_8x8_V,  MB_LEFT|MB_TOP|MB_TOPRIGHT );
  598.     INTRA_TEST( predict_8x8, I_PRED_8x8_DC, MB_LEFT|MB_TOP|MB_TOPRIGHT );
  599.     INTRA_TEST( predict_8x8, I_PRED_8x8_DDL,MB_LEFT|MB_TOP|MB_TOPRIGHT );
  601.     report( "intra pred :" );
  602.     return ret;
  603. }
  605. int check_all( int cpu_ref, int cpu_new )
  606. {
  607.     return check_pixel( cpu_ref, cpu_new )
  608.          + check_dct( cpu_ref, cpu_new )
  609.          + check_mc( cpu_ref, cpu_new )
  610.          + check_intra( cpu_ref, cpu_new )
  611.          + check_deblock( cpu_ref, cpu_new )
  612.          + check_quant( cpu_ref, cpu_new );
  613. }
  615. int main(int argc, char *argv[])
  616. {
  617.     int ret = 0;
  618.     int i;
  620.     buf1 = x264_malloc( 1024 ); /* 32 x 32 */
  621.     buf2 = x264_malloc( 1024 );
  622.     buf3 = x264_malloc( 1024 );
  623.     buf4 = x264_malloc( 1024 );
  624.     buf5 = x264_malloc( 1024 );
  626.     i = ( argc > 1 ) ? atoi(argv[1]) : x264_mdate();
  627.     fprintf( stderr, "x264: using random seed %un", i );
  628.     srand( i );
  630.     for( i = 0; i < 1024; i++ )
  631.     {
  632.         buf1[i] = rand() & 0xFF;
  633.         buf2[i] = rand() & 0xFF;
  634.         buf3[i] = buf4[i] = 0;
  635.     }
  637. #ifdef HAVE_MMXEXT
  638.     fprintf( stderr, "x264: MMXEXT against Cn" );
  639.     ret = check_all( 0, X264_CPU_MMX | X264_CPU_MMXEXT );
  640. #ifdef HAVE_SSE2
  641.     if( x264_cpu_detect() & X264_CPU_SSE2 )
  642.     {
  643.         fprintf( stderr, "nx264: SSE2 against Cn" );
  644.         ret |= check_all( X264_CPU_MMX | X264_CPU_MMXEXT,
  645.                           X264_CPU_MMX | X264_CPU_MMXEXT | X264_CPU_SSE | X264_CPU_SSE2 );
  646.     }
  647. #endif
  648. #elif ARCH_PPC
  649.     fprintf( stderr, "x264: ALTIVEC against Cn" );
  650.     ret = check_all( 0, X264_CPU_ALTIVEC );
  651. #endif
  653.     if( ret == 0 )
  654.     {
  655.         fprintf( stderr, "x264: All tests passed Yeah :)n" );
  656.         return 0;
  657.     }
  658.     fprintf( stderr, "x264: at least one test has failed. Go and fix that Right Now!n" );
  659.     return -1;
  660. }