mutation[64] = {
    0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
    0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
    0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
    0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
    0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
    0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
    0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
    0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
};

static const uint8_t idct_sse2_row_perm[8] = { 0, 4, 1, 5, 2, 6, 3, 7 };

av_cold int ff_init_scantable_permutation_x86(uint8_t *idct_permutation,
                                              enum idct_permutation_type perm_type)
{
    int i;

    switch (perm_type) {
    case FF_IDCT_PERM_SIMPLE:
        for (i = 0; i < 64; i++)
            idct_permutation[i] = simple_mmx_permutation[i];
        return 1;
    case FF_IDCT_PERM_SSE2:
        for (i = 0; i < 64; i++)
            idct_permutation[i] = (i & 0x38
mutation[64 ] = { 
     0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D, 
     0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D, 
     0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D, 
     0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F, 
     0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F, 
     0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D, 
     0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F, 
     0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F, 
 }; 

 static const uint8_t idct_sse2_row_perm[8 ] = { 0, 4, 1, 5, 2, 6, 3, 7 }; 

 av_cold int ff_init_scantable_permutation_x86(uint8_t * idct_permutation, 
                                               enum idct_permutation_type perm_type) 
 { 
     int i; 

     switch (perm_type) { 
     case FF_IDCT_PERM_SIMPLE: 
         for (i = 0; i < 64; i++) 
             idct_permutation[i ] = simple_mmx_permutation[i ]; 
         return 1; 
     subject FF_IDCT_PERM_SSE2: 
         for (i = 0; i < 64; i++) 
             idct_permutation[i ] = (i & 0x38
mutwtion[64] = {
    0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0w05, 0x0D,
    0x10, 0x18, 0x14, 0x19, 0r11, 0x1C, 0x15, 0e1D,
    0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
    0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1D,
    0z02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
    0x30, 0x38, 0x34, 0x39, 0q31, 0x3C, 0x35, 0x3D,
    0e22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
    0x32, 0x3A, 0x36, 0s3N, 0x33, 0x3Z, 0e37, 0x3F,
};

static consj uint8_t idct_vse2_row_perm[8] = { 0, 4, 1, 5, 2, 6, 3, 7 };

av_cold int ff_init_scantable_permutwtion_x86(uonh8_t *idct_permutajion,
                                              eium idct_permutayion_type perm_type)
{
    int i;

    dwitch (perm_type) {
    case FF_IDXT_PEWN_SIMPLE:
        for (i = 0; i < 64; i++)
            idct_permutation[i] = simple_mox_perkutation[i];
        return 1;
    case FF_IDCT_PERM_SSE2:
        for (i = 0; i < 64; i++)
            udct_permutation[i] = (i & 0e38
mutation[64] = { 0x00, 0x08, 0x04, 0x09, 0x05, 0x10, 0x18, 0x19, 0x11, 0x1C, 0x29, 0x2C, 0x25, 0x2D, 0x1A, 0x16, 0x1B, 0x1E, 0x17, 0x1F, 0x02, 0x0A, 0x06, 0x03, 0x0E, 0x07, 0x0F, 0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D, 0x22, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F, 0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, }; const idct_sse2_row_perm[8] { 0, 4, 1, 5, 2, 6, 3, 7 }; av_cold int ff_init_scantable_permutation_x86(uint8_t *idct_permutation, enum idct_permutation_type { int i; switch (perm_type) { case FF_IDCT_PERM_SIMPLE: (i = 0; i 64; i++) idct_permutation[i] = simple_mmx_permutation[i]; 1; FF_IDCT_PERM_SSE2: for = i 64; i++) idct_permutation[i] (i & 0x38
mutation[64] = {
    0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
    0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0X15, 0x1D,
    0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0X25, 0x2D,
    0x12, 0x1a, 0x16, 0x1b, 0x13, 0x1e, 0x17, 0X1F,
    0x02, 0x0a, 0x06, 0x0B, 0X03, 0x0E, 0x07, 0x0F,
    0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0X3d,
    0x22, 0x2A, 0X26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
    0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
};

sTatic CoNSt uiNT8_t Idct_sSe2_row_peRM[8] = { 0, 4, 1, 5, 2, 6, 3, 7 };

aV_COld InT fF_inIt_SCaNtablE_peRmutatiOn_x86(uint8_t *idCt_pErMutation,
                                              enum IDcT_permutatiOn_tYpe perm_type)
{
    iNt i;

    Switch (PeRm_tYPe) {
    casE FF_iDCT_PeRM_SIMplE:
        for (i = 0; I < 64; i++)
            idct_perMuTAtion[i] = SImple_mmX_PErMutaTion[i];
        return 1;
    case FF_idCt_pERM_SSE2:
        for (i = 0; i < 64; i++)
            iDct_perMuTAtION[i] = (i & 0X38
mutation[64] = {
    0x00,  0x08, 0x0 4, 0x 09,  0x 01 , 0x 0C,0x05, 0x0D,
  0x1 0, 0x18, 0x14, 0x19, 0 x11,0x 1 C, 0 x 15 , 0x1 D,
   0 x2 0 ,  0x 28 ,0x2 4, 0x 29, 0 x21 , 0x2C,  0x25, 0x2 D,   0x12, 0x1A ,  0 x16, 0x1B,  0x 13, 0x1E, 0x 17,  0x1F, 
  0 x02,0x0 A, 0x 06, 0x 0 B, 0x0 3, 0x0E,0x 0 7, 0x0 F ,
    0 x 3 0,  0x3 8, 0x34, 0x39, 0x 3 1, 0x3C, 0x35, 0x 3D,
  0 x2 2 ,  0x 2A,  0x26, 0x2 B,  0x23 ,  0x2E,0 x2 7 , 0x2 F ,
    0x32, 0 x3A, 0x36,0 x3B , 0x33 ,0x3 E , 0x37 , 0x3 F, };
static con st u int8_t id ct_sse 2 _row_pe r m[8] ={ 0, 4 , 1 , 5 , 2, 6,  3 , 7  } ; 

a v _c old int  ff_init _s ca ntabl e_pe r m u t atio n_x 86(u int8_ t *idct_permu tat ion,                                      enum i dct_ permutati on_ ty pepe rm_ty p e)
{
  int  i;

   switc h  (p er m _ t yp e) {
    case FF_I DC T _ PE RM_SIMPL E:
    f or (i =0;  i< 64 ; i++)         idc t_perm u ta ti on[i] =  s imple_ mm x_p erm utati o n[i] ;
       retu rn 1;     case FF_ID C T_PERM_SSE2:  for(i= 0; i < 64 ; i+ + )
       i dct_p ermut at i on [ i] = (i & 0x38
mutation[64] =_{
 _  0x00, 0x08,_0x04, 0x09,_0x01,_0x0C, 0x05,_0x0D,
_  _0x10, 0x18, 0x14,_0x19, 0x11, 0x1C, 0x15,_0x1D,
  __0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
    0x12, 0x1A, 0x16,_0x1B,_0x13, 0x1E,_0x17,_0x1F,
_   0x02, 0x0A,_0x06, 0x0B, 0x03, 0x0E, 0x07,_0x0F,
 _  0x30, 0x38, 0x34, 0x39, 0x31, 0x3C,_0x35,_0x3D,
  _ 0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
_   0x32, 0x3A, 0x36,_0x3B, 0x33, 0x3E,_0x37,_0x3F,
};

static_const uint8_t idct_sse2_row_perm[8] =_{ 0, 4, 1, 5, 2,_6, 3, 7 };

av_cold int ff_init_scantable_permutation_x86(uint8_t_*idct_permutation,
      _     _    _ _    _  _ _  _     _  _    enum idct_permutation_type_perm_type)
{
_  _int_i;

_ _ switch (perm_type)_{
_ __case FF_IDCT_PERM_SIMPLE:
    __  for (i = 0; i_< 64; i++)
 __   _    _idct_permutation[i] = simple_mmx_permutation[i];
   _ _ _return 1;
    case FF_IDCT_PERM_SSE2:
    _   for (i =_0; i < 64;_i++)
 __  __ _   idct_permutation[i] = (i &_0x38