求解，请版主急看，需要H264的全志编码库libh264enc.a的代码

zhang007z

由于本人正在做H264相关的程序，因为用查了相关的A10资料，知道A10提供H264的硬编码方式，之前测试用x264软方式在cubieboard上编码，cpu占用率98%，太高了，无法承受，所以需要用A10的硬编码方式，首先现在H264是主流的编码方式，经过我的寻找论坛上没有一个人用硬编码方式，这个让我很奇怪，首先主流的编码方式不用的话，这块会有技术瓶颈，根据全志A10的官方git，只提供了android和armel平台的这个libh264enc.a文件，但是由于cubieboard发现的保准版linux系统为linaro 1.1 是armhf平台的，所以无法使用这个库，而且因为android的视频方面的很多能力不支持，所以首先放弃android平台的的视频开发，那么因为官方的cubiebaord给的这个linaro 1.1还是非常稳定和强大的，所以还是喜欢在这个上边开发，但是苦于没有这个全志提供的H264的硬编码库很是郁闷，所以请各方搞视频的人注意了，首先希望版主联系官方全志获取这个库的代码，或者是armhf平带的这个库和头文件，否则很耽误视频开放方面的研究和进展！相关全志的代码请看：https://github.com/linux-sunxi/cedarx-libs/tree/master/libcedarv    没有对armhf平台很好的支持！

qiaoge

晚看了，顶啊啊啊啊啊

cubieplayer

LZ，等你贡献了，移植一下吧，让大家都用上

matson

nand和cedarx都是allwinner较为封闭的2个东西，支持很有限的。

wsgtrsys

1. int __fastcall H264EncOpen(struct_v10 **a1)
   
2. {
   
3.   signed __int16 v2; // [sp+10Ch] [bp-30h]@2
   
4.   unsigned int v3; // [sp+110h] [bp-2Ch]@5
   
5.   struct_v10 **v4; // [sp+114h] [bp-28h]@1
   
6.   unsigned int v5; // [sp+11Ch] [bp-20h]@7
   
7.   signed int v6; // [sp+11Ch] [bp-20h]@13
   
8.   signed int v7; // [sp+120h] [bp-1Ch]@7
   
9.   signed int i; // [sp+124h] [bp-18h]@7
   
10.   signed int j; // [sp+124h] [bp-18h]@13
    
11.   struct_v10 *v10; // [sp+128h] [bp-14h]@1
    
12. 
    
13.   v4 = a1;
    
14.   v10 = *a1;
    
15.   if ( *a1 )
    
16.   {
    
17.     v10->dword120 = cedar_sys_phymalloc_map(0x800000, 1024);
    
18.     if ( v10->dword120 )
    
19.     {
    
20.       v10->dword124 = cedarv_address_vir2phy(v10->dword120);
    
21.       v10->dword128 = v10->dword124 + 0x7FFFFF;
    
22.       v10->dword130 = 0;
    
23.       v10->dword12C = 0;
    
24.       v10->wordB8 = 2;
    
25.       v10->wordBA = 2;
    
26.       v3 = v10->dword80;
    
27.       if ( v3 <= 0x14 && (1 << v3) & 0x160000 )
    
28.       {
    
29.         v10->word2 = v10->word7C;
    
30.         v10->word0 = v10->word7E;
    
31.         v10->byte4 &= 0xFCu;
    
32.         v10->byte4 &= 0xF3u;
    
33.         v10->byte4 &= 0x8Fu;
    
34.         v10->byte4 &= 0x7Fu;
    
35.         v10->byte5 = v10->byte1CD5 & 1 | v10->byte5 & 0xFE;
    
36.         v10->byte5 &= 0xFDu;
    
37.         v10->byte5 = 4 * (v10->byte1CD6 & 3) | v10->byte5 & 0xF3;
    
38.         v10->byte5 = 16 * (v10->byte1CD8 & 3) | v10->byte5 & 0xCF;
    
39.         v10->byte5 &= 0x3Fu;
    
40.         v10->byte6 = v10->dword1CDC & 0xF | v10->byte6 & 0xF0;
    
41.         v10->byte6 = 16 * (v10->dword1CE0 & 0xF) | v10->byte6 & 0xF;
    
42.         v10->byte7 &= 0x80u;
    
43.         v10->byte7 |= 0x80u;
    
44.         v10->byte8 = v10->dwordB0 & 0x3F | v10->byte8 & 0xC0;
    
45.         v10->byte8 &= 0x3Fu;
    
46.         v10->byte9 = v10->dwordB0 & 0x3F | v10->byte9 & 0xC0;
    
47.         v10->byte9 &= 0x3Fu;
    
48.         v10->byteA = v10->byte1CE4 & 7 | v10->byteA & 0xF8;
    
49.         *(_WORD *)&v10->byteA &= 7u;
    
50.         v10->byteC &= 0xFEu;
    
51.         v10->byteC = v10->byteC & 0xFD | 4;
    
52.         v10->byteC &= 0xF7u;
    
53.         v10->byteC &= 0xEFu;
    
54.         v10->byteC &= 0xDFu;
    
55.         v10->byteC &= 0x3Fu;
    
56.         v10->byteD |= 1u;
    
57.         *(_DWORD *)&v10->byteC &= 0x1FFu;
    
58.         v10->byte14 &= 0xF0u;
    
59.         v10->byte14 &= 0xFu;
    
60.         v10->byte15 &= 0xC0u;
    
61.         v10->byte15 &= 0x3Fu;
    
62.         v10->byte16 &= 0xFCu;
    
63.         *(_WORD *)&v10->byte16 &= 3u;
    
64.         v10->dword20 = 0;
    
65.         v5 = ((v10->dword74 + 31) & 0xFFFFFFE0) * ((v10->dword78 + 31) & 0xFFFFFFE0);
    
66.         v7 = (signed int)(((v10->dword74 + 31) & 0xFFFFFFE0) * ((v10->dword78 + 63) & 0xFFFFFFC0)) >> 1;
    
67.         for ( i = 0; v10->wordB8 > i; ++i )
    
68.         {
    
69.           *((_DWORD *)&v10->byte4 + i + 46) = cedar_sys_phymalloc_map(v5 + v7, 1024);
    
70.           if ( !*((_DWORD *)&v10->byte4 + i + 46) )
    
71.             return -3;
    
72.           *((_DWORD *)&v10->word0 + i + 52) = cedarv_address_vir2phy(*((_DWORD *)&v10->byte4 + i + 46));
    
73.           *((_DWORD *)&v10->byte4 + i + 56) = *((_DWORD *)&v10->word0 + i + 52) + v5;
    
74.         }
    
75.         v6 = (signed int)(((v10->dword74 + 63) & 0xFFFFFFC0) * ((v10->dword78 + 63) & 0xFFFFFFC0)) >> 2;
    
76.         for ( j = 0; v10->wordBA > j; ++j )
    
77.         {
    
78.           *((_DWORD *)&v10->word0 + j + 62) = cedar_sys_phymalloc_map(v6, 1024);
    
79.           if ( !*((_DWORD *)&v10->word0 + j + 62) )
    
80.             return -3;
    
81.           *((_DWORD *)&v10->byte4 + j + 66) = cedarv_address_vir2phy(*((_DWORD *)&v10->word0 + j + 62));
    
82.         }
    
83.         v10->dword134 = cedar_sys_phymalloc_map(2 * v10->dword74, 1024);
    
84.         if ( v10->dword134 )
    
85.         {
    
86.           v10->dword60 = cedarv_address_vir2phy(v10->dword134);
    
87.           v10->word64 = 1;
    
88.           v10->word66 = 1;
    
89.           rcInitSequence(v10);
    
90.           initPoc(v10);
    
91.           (*(void (__fastcall **)(struct_v10 *))&v4[1]->byte4)(v4[1]);
    
92.           v2 = 0;
    
93.         }
    
94.         else
    
95.         {
    
96.           v2 = -3;
    
97.         }
    
98.       }
    
99.       else
    
100.       {
     
101.         v2 = -1;
     
102.       }
     
103.     }
     
104.     else
     
105.     {
     
106.       v2 = -1;
     
107.     }
     
108.   }
     
109.   else
     
110.   {
     
111.     v2 = -1;
     
112.   }
     
113.   return v2;
     
114. }

复制代码

wsgtrsys

1. int __fastcall H264EncIoCtrl(int a1, int a2, struct_a3 *a3)
   
2. {
   
3.   signed __int16 v4; // [sp+4h] [bp-28h]@2
   
4.   struct_v5_1 *v5; // [sp+1Ch] [bp-10h]@1
   
5. 
   
6.   v5 = *(struct_v5_1 **)a1;
   
7.   if ( *(_DWORD *)a1 )
   
8.   {
   
9.     switch ( a2 )
   
10.     {
    
11.       case 3:
    
12.         if ( a3->dword0 )
    
13.         {
    
14.           if ( a3->dword0 == 1 )
    
15.             *(_DWORD *)(a1 + 36) = a3->dword4;
    
16.         }
    
17.         else
    
18.         {
    
19.           *(_DWORD *)(a1 + 32) = a3->dword4;
    
20.         }
    
21.         break;
    
22.       case 4:
    
23.         v5->word64 = 1;
    
24.         v5->word66 = 1;
    
25.         v5->dword68 = 0;
    
26.         v5->dwordB4 = 18;
    
27.         rcInitSequence(v5);
    
28.         initPoc(v5);
    
29.         break;
    
30.       case 2:
    
31.         v5->dword94 = a3->dwordC;
    
32.         v5->dword80 = a3->dword10;
    
33.         v5->dword84 = a3->dword14;
    
34.         v5->dwordA4 = a3->word1A;
    
35.         v5->dwordA0 = a3->word18;
    
36.         v5->dword90 = a3->dword1C;
    
37.         v5->dword6C = a3->dword4;
    
38.         v5->dword70 = a3->dword8;
    
39.         v5->dword74 = (v5->dword6C + 15) & 0xFFFFFFF0;
    
40.         v5->dword78 = (v5->dword70 + 15) & 0xFFFFFFF0;
    
41.         v5->word7C = v5->dword74 >> 4;
    
42.         v5->word7E = v5->dword78 >> 4;
    
43.         v5->dword88 = a3->dword20;
    
44.         break;
    
45.     }
    
46.     v4 = 0;
    
47.   }
    
48.   else
    
49.   {
    
50.     v4 = -1;
    
51.   }
    
52.   return v4;
    
53. }

复制代码

wsgtrsys

1. void *__fastcall H264EncInit(int a1)
   
2. {
   
3.   void *v2; // [sp+0h] [bp-1Ch]@2
   
4.   struct_s *s; // [sp+Ch] [bp-10h]@3
   
5.   struct_v5_2 *v5; // [sp+10h] [bp-Ch]@5
   
6.   int v6; // [sp+14h] [bp-8h]@7
   
7. 
   
8.   MACC_REGS_BASE = cedarv_get_macc_base_address();
   
9.   if ( MACC_REGS_BASE )
   
10.   {
    
11.     cedarv_reset_ve_core();
    
12.     *(_DWORD *)a1 = 0;
    
13.     s = (struct_s *)malloc(0x28u);
    
14.     if ( s )
    
15.     {
    
16.       memset(s, 0, 0x28u);
    
17.       v5 = (struct_v5_2 *)malloc(0x22E8u);
    
18.       if ( v5 )
    
19.       {
    
20.         memset(v5, 0, 0x22E8u);
    
21.         s->pvoid0 = v5;
    
22.         v6 = H264IspInit(a1);
    
23.         if ( v6 && *(_DWORD *)a1 != -1 )
    
24.         {
    
25.           s->dword4 = v6;
    
26.           s->dword8 = H264EncOpen;
    
27.           s->dwordC = H264EncClose;
    
28.           s->dword10 = H264EncEncode;
    
29.           s->dword14 = H264EncIoCtrl;
    
30.           s->dword18 = H264EncGetBsInfo;
    
31.           s->dword1C = H264EncReleaseBsInfo;
    
32.           v5->dword68 = 0;
    
33.           v5->dwordB4 = 18;
    
34.           v5->dword90 = 0x400000;
    
35.           v5->dword94 = 25;
    
36.           v5->dword88 = 25;
    
37.           v5->dword8C = 0;
    
38.           v5->byte1CE9 = 1;
    
39.           v5->dword9C = 1;
    
40.           v5->dwordA0 = 45;
    
41.           v5->dwordA4 = 10;
    
42.           v5->dwordA8 = 2;
    
43.           v5->dwordAC = 30;
    
44.           v5->dwordB0 = 30;
    
45.           v5->byte1CCC = 77;
    
46.           v5->byte1CCD = 41;
    
47.           v5->byte1CCE = 4;
    
48.           v5->byte1CCF = 8;
    
49.           v5->byte1CD4 = 0;
    
50.           v5->byte1CE7 = 1;
    
51.           v5->byte1CE8 = 1;
    
52.           v5->byte1CD5 = 1;
    
53.           v5->byte1CD6 = 1;
    
54.           v5->byte1CD7 = 0;
    
55.           v5->byte1CD8 = 0;
    
56.           v5->dword1CDC = 0;
    
57.           v5->dword1CE0 = 0;
    
58.           v5->byte1CE4 = 4;
    
59.           v5->byte1CE5 = 0;
    
60.           v2 = s;
    
61.         }
    
62.         else
    
63.         {
    
64.           free(s->pvoid0);
    
65.           free(s);
    
66.           v2 = 0;
    
67.         }
    
68.       }
    
69.       else
    
70.       {
    
71.         free(s);
    
72.         v2 = 0;
    
73.       }
    
74.     }
    
75.     else
    
76.     {
    
77.       v2 = 0;
    
78.     }
    
79.   }
    
80.   else
    
81.   {
    
82.     v2 = 0;
    
83.   }
    
84.   return v2;
    
85. }

复制代码

wsgtrsys

1. int __fastcall H264EncEncode(struct_a1 *a1)
   
2. {
   
3.   struct_v1 *v1; // ST5C_4@14
   
4.   __int16 v2; // ST4A_2@14
   
5.   struct_v3 *v3; // ST5C_4@15
   
6.   int v4; // r1@29
   
7.   int v5; // r2@44
   
8.   char *v6; // r3@44
   
9.   char *v7; // r2@45
   
10.   struct_v1 *v8; // ST5C_4@54
    
11.   int v9; // r1@68
    
12.   int v10; // r2@83
    
13.   char *v11; // r3@83
    
14.   char *v12; // r2@84
    
15.   signed __int16 v14; // [sp+2Ch] [bp-48h]@2
    
16.   int v15; // [sp+30h] [bp-44h]@10
    
17.   unsigned int v17; // [sp+40h] [bp-34h]@36
    
18.   int v18; // [sp+40h] [bp-34h]@37
    
19.   unsigned int v19; // [sp+40h] [bp-34h]@75
    
20.   int v20; // [sp+40h] [bp-34h]@76
    
21.   signed int i; // [sp+44h] [bp-30h]@15
    
22.   signed int j; // [sp+44h] [bp-30h]@20
    
23.   signed int k; // [sp+44h] [bp-30h]@54
    
24.   signed int l; // [sp+44h] [bp-30h]@59
    
25.   struct_v25 *v25; // [sp+54h] [bp-20h]@1
    
26.   int v26; // [sp+58h] [bp-1Ch]@1
    
27. 
    
28.   v25 = a1->pstruct_v250;
    
29.   v26 = *(_DWORD *)a1->pstruct_v14;
    
30.   MACC_REGS_BASE->dword0 = 11;
    
31.   if ( v25 )
    
32.   {
    
33.     pthread_mutex_lock((pthread_mutex_t *)&mutex_lock);
    
34.     if ( (unsigned int)v25->byte98A <= 0x7C && v25->dword12C <= 0x600000u )
    
35.     {
    
36.       pthread_mutex_unlock((pthread_mutex_t *)&mutex_lock);
    
37.       if ( !a1->pfunc20(0, &v25->gap134[4]) )
    
38.       {
    
39.         if ( v25->dword14C )
    
40.         {
    
41.           v25->dword68 = 0;
    
42.           v25->dwordB4 = 18;
    
43.         }
    
44.         v25->dword22E0 = 0;
    
45.         v15 = v25->dword22E0;
    
46.         if ( v15 == 1 )
    
47.         {
    
48.           *(_BYTE *)(v26 + 4) |= 0x20u;
    
49.           v1 = a1->pstruct_v14;
    
50.           v1->pfuncC(a1->pstruct_v14, 2, v25);
    
51.           v1->pfuncC(v1, 8, (struct_v25 *)&v25->gap134[4]);
    
52.           v1->pfuncC(v1, 3, (struct_v25 *)&v25->gap134[4]);
    
53.           v1->pfuncC(v1, 5, (struct_v25 *)&v25->gap134[4]);
    
54.           v2 = v1->pfunc10((int)v1);
    
55.         }
    
56.         else if ( v15 == 2 )
    
57.         {
    
58.           *(_BYTE *)(v26 + 4) |= 0x20u;
    
59.           v3 = (struct_v3 *)a1->pstruct_v14;
    
60.           v3->pfuncC((int)a1->pstruct_v14, 8, (struct_v25 *)&v25->gap134[4]);
    
61.           v3->pfuncC((int)v3, 2, v25);
    
62.           v3->pfuncC((int)v3, 3, (struct_v25 *)&v25->gap134[4]);
    
63.           v3->pfuncC((int)v3, 5, (struct_v25 *)&v25->gap134[4]);
    
64.           for ( i = 0; v25->wordB8 > i; ++i )
    
65.           {
    
66.             if ( !v25->gap15C[i + 28] )
    
67.             {
    
68.               v25->byte17E = i;
    
69.               break;
    
70.             }
    
71.           }
    
72.           for ( j = 0; v25->wordBA > j; ++j )
    
73.           {
    
74.             if ( !v25->gap17F[j] )
    
75.             {
    
76.               v25->byte185 = j;
    
77.               break;
    
78.             }
    
79.           }
    
80.           MACC_REGS_BASE->dwordB88 = 8 * v25->dword130;
    
81.           MACC_REGS_BASE->dwordB80 = v25->dword124;
    
82.           MACC_REGS_BASE->dwordB84 = v25->dword128;
    
83.           MACC_REGS_BASE->dwordB8C = 8 * (v25->dword130 - v25->dword12C + 0x800000);
    
84.           MACC_REGS_BASE->dwordBA0 = *(_DWORD *)&v25->gap0[4 * (v25->byte17D + 52)];
    
85.           MACC_REGS_BASE->dwordBA4 = *(&v25->dword4 + v25->byte17D + 56);
    
86.           MACC_REGS_BASE->dwordBB0 = *(_DWORD *)&v25->gap0[4 * (v25->byte17E + 52)];
    
87.           MACC_REGS_BASE->dwordBB4 = *(&v25->dword4 + v25->byte17E + 56);
    
88.           MACC_REGS_BASE->dwordBB8 = *(&v25->dword4 + v25->byte184 + 66);
    
89.           MACC_REGS_BASE->dwordBBC = *(&v25->dword4 + v25->byte185 + 66);
    
90.           if ( v25->dwordB4 == 18 )
    
91.             v25->byte1CEA = 2;
    
92.           else
    
93.             v25->byte1CEA = LOBYTE(v25->dwordB4);
    
94.           if ( v25->dwordB4 == 18 )
    
95.           {
    
96.             v4 = v25->dword1D00;
    
97.             if ( v4 < *(_DWORD *)((char *)&loc_1CF8 + (_DWORD)v25) )
    
98.               v4 = *(_DWORD *)((char *)&loc_1CF8 + (_DWORD)v25);
    
99.             v25->dword1D00 = v4;
    
100.             *(_DWORD *)((char *)&loc_1CFC + (_DWORD)v25) = *(_DWORD *)((char *)&loc_1CF8 + (_DWORD)v25);
     
101.           }
     
102.           getPoc(v25);
     
103.           rcInitPic(v25);
     
104.           if ( v25->word64 )
     
105.           {
     
106.             BYTE3(v25->dword4) |= 0x80u;
     
107.             MACC_REGS_BASE->dwordB04 = v25->dword4;
     
108.             v25->dword990 = InitSPS(a1);
     
109.             v25->dword994 = InitPPS(a1);
     
110.             v25->word64 = 0;
     
111.           }
     
112.           MACC_REGS_BASE->dwordB14 |= 0xFu;
     
113.           StartSlice(a1);
     
114.           if ( a1->pfunc24(0, 0) )
     
115.             return -2;
     
116.           g_ve_status = MACC_REGS_BASE->dwordB1C;
     
117.           MACC_REGS_BASE->dwordB1C = g_ve_status;
     
118.           v25->dword24 = MACC_REGS_BASE->dwordB50;
     
119.           v25->dword28 = MACC_REGS_BASE->dwordB54;
     
120.           v25->dword2C = MACC_REGS_BASE->dwordB58;
     
121.           v25->dword30 = MACC_REGS_BASE->dwordB5C;
     
122.           v17 = MACC_REGS_BASE->dwordB90 >> 3;
     
123.           if ( v25->dword130 > v17 )

复制代码

wsgtrsys

1. 
   
2.             v18 = v25->dword130 - v17;
   
3.           else
   
4.             v18 = v17 - v25->dword130;
   
5.           *(_DWORD *)((char *)&loc_1D14 + (_DWORD)v25) = v18;
   
6.           if ( v25->word66 == 1 )
   
7.             *(_DWORD *)((char *)&loc_1D14 + (_DWORD)v25) -= v25->dword990 + v25->dword994;
   
8.           *(_DWORD *)((char *)&loc_1D14 + (_DWORD)v25) *= 8;
   
9.           rcUpdatePic(v25);
   
10.           pthread_mutex_lock((pthread_mutex_t *)&mutex_lock);
    
11.           *(_DWORD *)&v25->gap0[4 * (v25->byte989 + 98)] = v25->dword130;
    
12.           *(_DWORD *)&v25->gap0[4 * (v25->byte989 + 226)] = v18;
    
13.           if ( v18 & 0x1F )
    
14.             v18 = v18 - (v18 & 0x1F) + 32;
    
15.           if ( v25->dword158 )
    
16.           {
    
17.             v5 = v25->dword154;
    
18.             v6 = &v25->gap0[8 * (v25->byte989 + 177)];
    
19.             *(_DWORD *)v6 = v25->dword150;
    
20.             *((_DWORD *)v6 + 1) = v5;
    
21.           }
    
22.           else
    
23.           {
    
24.             v7 = &v25->gap0[8 * (v25->byte989 + 177)];
    
25.             *(_DWORD *)v7 = -1;
    
26.             *((_DWORD *)v7 + 1) = -1;
    
27.           }
    
28.           v25->dword12C += v18;
    
29.           v25->dword130 += v18;
    
30.           if ( v25->dword130 > 0x7FFFFFu )
    
31.             v25->dword130 -= 0x800000;
    
32.           ++v25->byte989;
    
33.           if ( v25->byte989 == 128 )
    
34.             v25->byte989 = 0;
    
35.           ++v25->byte98A;
    
36.           ++v25->byte98B;
    
37.           pthread_mutex_unlock((pthread_mutex_t *)&mutex_lock);
    
38.           v25->gap15C[v25->byte17D + 28] = 0;
    
39.           v25->byte17D = v25->byte17E;
    
40.           v25->gap15C[v25->byte17D + 28] = 1;
    
41.           v25->gap17F[v25->byte184] = 0;
    
42.           v25->byte184 = v25->byte185;
    
43.           v25->gap17F[v25->byte184] = 1;
    
44.           ++v25->dword68;
    
45.           if ( v25->dword68 == v25->dword88 )
    
46.           {
    
47.             v25->dword68 = 0;
    
48.             v25->dwordB4 = 18;
    
49.           }
    
50.           else
    
51.           {
    
52.             v25->dwordB4 = 0;
    
53.           }
    
54.           ++*(_DWORD *)((char *)&loc_1D10 + (_DWORD)v25);
    
55.           *(_DWORD *)((char *)&loc_1D10 + (_DWORD)v25) &= (1 << v25->byte1CCE) - 1;
    
56.           ++*(_DWORD *)((char *)&loc_1CF8 + (_DWORD)v25);
    
57.         }
    
58.         else if ( !v15 )
    
59.         {
    
60.           *(_BYTE *)(v26 + 4) &= 0xDFu;
    
61.           v8 = a1->pstruct_v14;
    
62.           v8->pfuncC(a1->pstruct_v14, 8, (struct_v25 *)&v25->gap134[4]);
    
63.           v8->pfuncC(v8, 2, v25);
    
64.           v8->pfuncC(v8, 3, (struct_v25 *)&v25->gap134[4]);
    
65.           v8->pfuncC(v8, 5, (struct_v25 *)&v25->gap134[4]);
    
66.           for ( k = 0; v25->wordB8 > k; ++k )
    
67.           {
    
68.             if ( !v25->gap15C[k + 28] )
    
69.             {
    
70.               v25->byte17E = k;
    
71.               break;
    
72.             }
    
73.           }
    
74.           for ( l = 0; v25->wordBA > l; ++l )
    
75.           {
    
76.             if ( !v25->gap17F[l] )
    
77.             {
    
78.               v25->byte185 = l;
    
79.               break;
    
80.             }
    
81.           }
    
82.           MACC_REGS_BASE->dwordB88 = 8 * v25->dword130;
    
83.           MACC_REGS_BASE->dwordB80 = v25->dword124;
    
84.           MACC_REGS_BASE->dwordB84 = v25->dword128;
    
85.           MACC_REGS_BASE->dwordB8C = 8 * (v25->dword130 - v25->dword12C + 0x800000);
    
86.           MACC_REGS_BASE->dwordBA0 = *(_DWORD *)&v25->gap0[4 * (v25->byte17D + 52)];
    
87.           MACC_REGS_BASE->dwordBA4 = *(&v25->dword4 + v25->byte17D + 56);
    
88.           MACC_REGS_BASE->dwordBB0 = *(_DWORD *)&v25->gap0[4 * (v25->byte17E + 52)];
    
89.           MACC_REGS_BASE->dwordBB4 = *(&v25->dword4 + v25->byte17E + 56);
    
90.           MACC_REGS_BASE->dwordBB8 = *(&v25->dword4 + v25->byte184 + 66);
    
91.           MACC_REGS_BASE->dwordBBC = *(&v25->dword4 + v25->byte185 + 66);
    
92.           if ( v25->dwordB4 == 18 )
    
93.             v25->byte1CEA = 2;
    
94.           else
    
95.             v25->byte1CEA = LOBYTE(v25->dwordB4);
    
96.           if ( v25->dwordB4 == 18 )
    
97.           {
    
98.             v9 = v25->dword1D00;
    
99.             if ( v9 < *(_DWORD *)((char *)&loc_1CF8 + (_DWORD)v25) )
    
100.               v9 = *(_DWORD *)((char *)&loc_1CF8 + (_DWORD)v25);
     
101.             v25->dword1D00 = v9;
     
102.             *(_DWORD *)((char *)&loc_1CFC + (_DWORD)v25) = *(_DWORD *)((char *)&loc_1CF8 + (_DWORD)v25);
     
103.           }
     
104.           getPoc(v25);
     
105.           rcInitPic(v25);
     
106.           if ( v25->word64 )
     
107.           {
     
108.             BYTE3(v25->dword4) |= 0x80u;
     
109.             MACC_REGS_BASE->dwordB04 = v25->dword4;
     
110.             v25->dword990 = InitSPS(a1);
     
111.             v25->dword994 = InitPPS(a1);
     
112.             v25->word64 = 0;
     
113.           }
     
114.           MACC_REGS_BASE->dwordB14 |= 0xFu;
     
115.           StartSlice(a1);
     
116.           if ( a1->pfunc24(0, 0) )
     
117.             return -2;
     
118.           g_ve_status = MACC_REGS_BASE->dwordB1C;
     
119.           MACC_REGS_BASE->dwordB1C = g_ve_status;
     
120.           v25->dword24 = MACC_REGS_BASE->dwordB50;
     
121.           v25->dword28 = MACC_REGS_BASE->dwordB54;
     
122.           v25->dword2C = MACC_REGS_BASE->dwordB58;
     
123.           v25->dword30 = MACC_REGS_BASE->dwordB5C;
     
124.           v19 = MACC_REGS_BASE->dwordB90 >> 3;
     
125.           if ( v25->dword130 > v19 )
     
126.             v20 = v25->dword130 - v19;
     
127.           else
     
128.             v20 = v19 - v25->dword130;
     
129.           *(_DWORD *)((char *)&loc_1D14 + (_DWORD)v25) = v20;
     
130.           if ( v25->word66 == 1 )
     
131.             *(_DWORD *)((char *)&loc_1D14 + (_DWORD)v25) -= v25->dword990 + v25->dword994;
     
132.           *(_DWORD *)((char *)&loc_1D14 + (_DWORD)v25) *= 8;
     
133.           rcUpdatePic(v25);
     
134.           pthread_mutex_lock((pthread_mutex_t *)&mutex_lock);
     
135.           *(_DWORD *)&v25->gap0[4 * (v25->byte989 + 98)] = v25->dword130;
     
136.           *(_DWORD *)&v25->gap0[4 * (v25->byte989 + 226)] = v20;
     
137.           if ( v20 & 0x1F )
     
138.             v20 = v20 - (v20 & 0x1F) + 32;
     
139.           if ( v25->dword158 )
     
140.           {
     
141.             v10 = v25->dword154;
     
142.             v11 = &v25->gap0[8 * (v25->byte989 + 177)];
     
143.             *(_DWORD *)v11 = v25->dword150;
     
144.             *((_DWORD *)v11 + 1) = v10;
     
145.           }
     
146.           else
     
147.           {
     
148.             v12 = &v25->gap0[8 * (v25->byte989 + 177)];
     
149.             *(_DWORD *)v12 = -1;
     
150.             *((_DWORD *)v12 + 1) = -1;
     
151.           }
     
152.           v25->dword12C += v20;
     
153.           v25->dword130 += v20;
     
154.           if ( v25->dword130 > 0x7FFFFFu )
     
155.             v25->dword130 -= 0x800000;
     
156.           ++v25->byte989;
     
157.           if ( v25->byte989 == 128 )
     
158.             v25->byte989 = 0;
     
159.           ++v25->byte98A;
     
160.           ++v25->byte98B;
     
161.           pthread_mutex_unlock((pthread_mutex_t *)&mutex_lock);
     
162.           v25->gap15C[v25->byte17D + 28] = 0;
     
163.           v25->byte17D = v25->byte17E;
     
164.           v25->gap15C[v25->byte17D + 28] = 1;
     
165.           v25->gap17F[v25->byte184] = 0;
     
166.           v25->byte184 = v25->byte185;
     
167.           v25->gap17F[v25->byte184] = 1;
     
168.           ++v25->dword68;
     
169.           if ( v25->dword68 == v25->dword88 )
     
170.           {
     
171.             v25->dword68 = 0;
     
172.             v25->dwordB4 = 18;
     
173.           }
     
174.           else
     
175.           {
     
176.             v25->dwordB4 = 0;
     
177.           }
     
178.           ++*(_DWORD *)((char *)&loc_1D10 + (_DWORD)v25);
     
179.           *(_DWORD *)((char *)&loc_1D10 + (_DWORD)v25) &= (1 << v25->byte1CCE) - 1;
     
180.           ++*(_DWORD *)((char *)&loc_1CF8 + (_DWORD)v25);
     
181.         }
     
182.         return 0;
     
183.       }
     
184.       v14 = -1;
     
185.     }
     
186.     else
     
187.     {
     
188.       pthread_mutex_unlock((pthread_mutex_t *)&mutex_lock);
     
189.       v14 = -3;
     
190.     }
     
191.   }
     
192.   else
     
193.   {
     
194.     v14 = -1;
     
195.   }
     
196.   return v14;
     
197. }

复制代码

sunbeyond

wsgtrsys 发表于 2014-2-23 21:22

请问一下是  支持armhf 平台的吗？