Bumble-Bee: libhtc_acoustic.c

File libhtc_acoustic.c, 63.8 KB (added by admin, 13 years ago)
Line 
1/* This file has been generated by the Hex-Rays decompiler.
2   Copyright (c) 2007-2011 Hex-Rays <info@hex-rays.com>
3
4   Detected compiler: GNU C++
5*/
6
7#include <defs.h>
8
9
10//-------------------------------------------------------------------------
11// Data declarations
12
13extern char aIntAndroidSupp[37]; // weak
14extern char aIntAndroidSu_0[32]; // weak
15extern char aIntAndroidSu_1[32]; // weak
16extern char aIntAndroidSu_2[30]; // weak
17extern char aHtcAcoustic[13]; // weak
18extern char aUpdate3254Info[50]; // weak
19extern char aDevHtcAcoustic[18]; // weak
20extern char aCanTOpenDevHtc[32]; // weak
21extern char aUpdate3254In_0[36]; // weak
22extern char aUpdate3254In_1[32]; // weak
23extern char aUpdateVoiceAcd[52]; // weak
24extern char aUpdateVoiceA_0[40]; // weak
25extern char aUpdateVoiceA_1[38]; // weak
26extern char aUpdateAcdbIdTx[62]; // weak
27extern char aUpdateAcdbIdFa[25]; // weak
28extern char aReadAcoustic_g[34]; // weak
29extern char aReadEngineerId[27]; // weak
30extern char aSSupport_aic32[24]; // weak
31extern char aReadBackMicSta[29]; // weak
32extern char aSSupport_back_[25]; // weak
33extern char aSSupport_a1026[22]; // weak
34extern char aSS[5]; // weak
35extern char aSystemEtc[13]; // weak
36extern char aTpa2028CsvFile[30]; // weak
37extern char aFailedToOpenTp[37]; // weak
38extern char aOpenSSuccess_[17]; // weak
39extern char aFailedToStatSS[28]; // weak
40extern char aFailedToMmapPa[40]; // weak
41extern char aDevTpa2028[13]; // weak
42extern char aSystemEtcTpa20[28]; // weak
43extern char aTpa2026CsvFile[30]; // weak
44extern char aFailedToOpen_0[37]; // weak
45extern char aDevTpa2026[13]; // weak
46extern char aSystemEtcTpa_0[28]; // weak
47extern char aTpa2051CsvFile[30]; // weak
48extern char aFailedToOpenA2[35]; // weak
49extern char aDevTpa2051d3[15]; // weak
50extern char aCannotOpenAudi[39]; // weak
51extern char aSystemEtcTpa_1[28]; // weak
52extern char aSystemEtcA1026[26]; // weak
53extern char aFailedToOpenA1[35]; // weak
54extern char aDevAudience_a1[20]; // weak
55extern char aCannotOpenSD_T[48]; // weak
56extern char aDevAudience__0[20]; // weak
57extern char aCannotOpenSD[21]; // weak
58extern char aUpdateA1026Par[34]; // weak
59extern char aUpdateA1026P_0[28]; // weak
60extern char asc_3D91[3]; // weak
61extern char aSystemEtcAudio[26]; // weak
62extern char aFailToOpenSD_[20]; // weak
63extern char aHeader[7]; // weak
64extern char aHeader_0[7]; // weak
65extern char aBtIdTableVersi[24]; // weak
66extern char aFailedToOpenFi[33]; // weak
67extern char aAic3254TableVe[26]; // weak
68extern char aFailedToParseA[45]; // weak
69extern char aDevCodec_aic32[19]; // weak
70extern char aCannotOpenCode[36]; // weak
71extern char aSet_audio_effe[21]; // weak
72extern char aSet_audio_ef_0[42]; // weak
73extern char aFoundEnabledDs[42]; // weak
74extern char aDisabledSoundE[23]; // weak
75extern char aCannotFoundInd[35]; // weak
76extern char aRo_ril_enable_[27]; // weak
77extern _UNKNOWN unk_3F45; // weak
78extern char aRo_carrier[11]; // weak
79extern char aS_S[6]; // weak
80extern char aSystemEtcCodec[30]; // weak
81extern char aAmr_wbNotSuppo[43]; // weak
82extern char aAcoustic_set_w[37]; // weak
83extern char aSSupport_amr_w[23]; // weak
84extern char aSystemEtcCod_0[31]; // weak
85extern char aSystemEtcCod_1[27]; // weak
86extern char asc_4016[2]; // weak
87extern char asc_4018[2]; // weak
88extern char aCodecDspMappin[36]; // weak
89extern char aHtc_audio_acou[30]; // weak
90extern char aSystemEtcAic32[28]; // weak
91extern char a_[2]; // weak
92extern char aS_S_S[9]; // weak
93extern char aS_dualmic_S[14]; // weak
94extern char aSystemEtcAic_0[32]; // weak
95extern char aLoadingMfgCsvF[25]; // weak
96extern char a_txt[5]; // weak
97extern char a_txt_0[5]; // weak
98extern char aSystemEtcAic_1[36]; // weak
99extern char aReadAic3254Par[38]; // weak
100extern char aFailedToUpdate[32]; // weak
101extern char aFailedToUpda_0[34]; // weak
102extern char aCannotMappingC[30]; // weak
103extern char aAchieveMaximum[34]; // weak
104extern char aSSWithIndexD[22]; // weak
105extern char aHtc_effect_mas[24]; // weak
106extern char aFailedToUpda_1[31]; // weak
107extern char aDDev_nameS[19]; // weak
108extern char aVoice[6]; // weak
109extern char a__0[2]; // weak
110extern char aParseFreqS[14]; // weak
111extern char aAct_sizeDFreqD[21]; // weak
112extern char aS[3]; // weak
113extern char aSystemEtcAdieh[31]; // weak
114extern char aSystemEtcAdi_0[28]; // weak
115extern char aFailToOpenS[16]; // weak
116extern char aOpenSSuccess_0[17]; // weak
117extern char aFailedToStat_0[27]; // weak
118extern char aFailedOnMmapD[18]; // weak
119extern char aIoctlAcousti_0[37]; // weak
120extern char aIoctlAcoustic_[35]; // weak
121extern char aSuccessOnUpdat[33]; // weak
122extern char aLibhtc_acousti[50]; // weak
123extern char aReadAdieParaFr[35]; // weak
124extern char aReadBtHeadsetI[39]; // weak
125extern char *off_5018; // weak
126extern _UNKNOWN _data_start; // weak
127extern _UNKNOWN unk_51F4; // weak
128extern _UNKNOWN unk_51F8; // weak
129extern _DWORD dword_51FC; // idb
130extern _UNKNOWN unk_5200; // weak
131extern _UNKNOWN unk_5210; // weak
132extern _UNKNOWN unk_5214; // weak
133extern _UNKNOWN unk_5218; // weak
134extern _UNKNOWN unk_521C; // weak
135extern _UNKNOWN unk_5220; // weak
136extern _UNKNOWN unk_5224; // weak
137extern _UNKNOWN unk_5228; // weak
138extern _BYTE byte_34DA8[193536]; // idb
139extern _UNKNOWN unk_64940; // weak
140extern _UNKNOWN unk_65228; // weak
141extern _UNKNOWN unk_6522C; // weak
142extern _DWORD dword_65230[393220]; // idb
143extern _UNKNOWN _dso_handle; // weak
144// extern _UNKNOWN _stack_chk_guard; weak
145// extern _UNKNOWN _page_size; weak
146
147//-------------------------------------------------------------------------
148// Function declarations
149
150// int pthread_mutex_destroy(pthread_mutex_t *mutex);
151// int _android_log_print(_DWORD, _DWORD, const char *, ...); weak
152// int open(const char *file, int oflag, ...);
153// int ioctl(int fd, unsigned __int32 request, ...);
154// int close(int fd);
155// char *strcpy(char *dest, const char *src);
156// int sprintf(char *s, const char *format, ...);
157// int fstat(int fd, struct stat *buf);
158// int __fastcall _errno(_DWORD); weak
159// char *strerror(int errnum);
160// void *mmap(void *addr, size_t len, int prot, int flags, int fd, __off_t offset);
161// char *strchr(const char *s, int c);
162// void *malloc(size_t size);
163// void *memset(void *s, int c, size_t n);
164// __int32 strtol(const char *nptr, char **endptr, int base);
165// void free(void *ptr);
166// int __fastcall _stack_chk_fail(_DWORD); weak
167// void *memcpy(void *dest, const void *src, size_t n);
168// char *strtok(char *s, const char *delim);
169// ssize_t read(int fd, void *buf, size_t nbytes);
170// int __fastcall operator new__(_DWORD); weak
171// int strcmp(const char *s1, const char *s2);
172// int munmap(void *addr, size_t len);
173// int pthread_mutex_lock(pthread_mutex_t *mutex);
174// int pthread_mutex_unlock(pthread_mutex_t *mutex);
175// int strcasecmp(const char *s1, const char *s2);
176// int __fastcall property_get(_DWORD, _DWORD, _DWORD); weak
177// int atoi(const char *nptr);
178// char *strstr(const char *haystack, const char *needle);
179// char *strncpy(char *dest, const char *src, size_t n);
180// int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
181// int __fastcall _aeabi_atexit(_DWORD, _DWORD, _DWORD); weak
182int __fastcall get_soundeffect_mask();
183int __fastcall snd_get_num();
184pthread_mutex_t *__fastcall sub_105C(pthread_mutex_t *a1);
185int __fastcall update_3254_info(int a1, int a2, int a3, int a4);
186int __fastcall update_voice_acdb(int a1, int a2, int a3, int a4);
187int __fastcall update_acdb_id(int a1, int a2, int a3, int a4);
188int __fastcall android::get_acoust_tables(int a1);
189int __fastcall android::support_codec_aic3254(int a1);
190int __fastcall support_back_mic();
191int __fastcall support_audience(int a1);
192int __fastcall snd_get_bt_endpoint(int a1);
193int __fastcall set_tpa2028_parameters();
194int __fastcall set_tpa2026_parameters();
195int __fastcall set_tpa2051_parameters();
196signed int __fastcall set_a1026_parameters(int a1);
197char *__fastcall sub_1E10(const char *a1);
198int __fastcall sub_2038(const char *a1);
199int __fastcall sub_223C(const char *a1);
200int __fastcall android::read_bt_endpoints();
201int __fastcall sub_2728(int (__fastcall *a1)(_DWORD), const char *a2);
202int __fastcall set_aic3254_ioctl(unsigned __int32 a1, int a2);
203int __fastcall set_sound_effect(const char *a1);
204bool __fastcall support_amr_wb();
205int __fastcall android::read_codec_effect_endpoints();
206signed int __fastcall set_aic3254_parameters();
207int __fastcall reinit_codec_effect();
208bool __fastcall android::parse_adie_para(char *a1, int a2);
209signed int __fastcall sub_3544(int a1);
210int __fastcall set_acoustic_parameters();
211int __fastcall sub_37E0();
212int __fastcall sub_3818();
213
214
215//----- (00001044) --------------------------------------------------------
216int __fastcall get_soundeffect_mask()
217{
218  return unk_5210;
219}
220
221//----- (00001050) --------------------------------------------------------
222int __fastcall snd_get_num()
223{
224  return unk_5214;
225}
226
227//----- (0000105C) --------------------------------------------------------
228pthread_mutex_t *__fastcall sub_105C(pthread_mutex_t *a1)
229{
230  pthread_mutex_t *v1; // r4@1
231
232  v1 = a1;
233  pthread_mutex_destroy(a1);
234  return v1;
235}
236
237//----- (00001068) --------------------------------------------------------
238int __fastcall update_3254_info(int a1, int a2, int a3, int a4)
239{
240  int v4; // r8@1
241  int v5; // r7@1
242  int v6; // r4@1
243  int v7; // r0@2
244  int v8; // r6@4
245  signed int v9; // r0@5
246  int v10; // r2@5
247  int v12; // [sp+8h] [bp-20h]@1
248  int v13; // [sp+Ch] [bp-1Ch]@1
249
250  v12 = a3;
251  v13 = a4;
252  v4 = a1;
253  v5 = a2;
254  v6 = -1;
255  ((void (__fastcall *)(signed int, _DWORD, _DWORD, int))_android_log_print)(
256    4,
257    "HTC Acoustic",
258    "update 3254 info id: (dev_id, 3254_id) = (%d, %d)",
259    a1);
260  if ( v5 )
261  {
262    v7 = open("/dev/htc-acoustic", 4098);
263    v6 = v7;
264    if ( v7 >= 0 )
265    {
266      v12 = v4;
267      v13 = v5;
268      v8 = ioctl(v7, 0x40047024u, &v12);
269      if ( v8 >= 0 )
270      {
271        v9 = 4;
272        v10 = (int)"update 3254 info (%d, %d) ok %d";
273      }
274      else
275      {
276        v9 = 6;
277        v10 = (int)"update 3254 info (%d, %d) failed %d";
278      }
279      ((void (__fastcall *)(signed int, _DWORD, int, int))_android_log_print)(v9, "HTC Acoustic", v10, v4);
280      close(v6);
281      v6 = v8;
282    }
283    else
284    {
285      _android_log_print(6, "HTC Acoustic", "can't open /dev/htc-acoustic %d", v7);
286    }
287  }
288  return v6;
289}
290// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
291
292//----- (0000110C) --------------------------------------------------------
293int __fastcall update_voice_acdb(int a1, int a2, int a3, int a4)
294{
295  int v4; // r6@1
296  int v5; // r7@1
297  int v6; // r0@1
298  int v7; // r4@1
299  int v8; // r0@3
300  int v9; // r8@3
301  signed int v10; // r0@4
302  const char *v11; // r2@4
303  int v13; // [sp+0h] [bp-28h]@4
304  int v14; // [sp+4h] [bp-24h]@1
305  int v15; // [sp+8h] [bp-20h]@1
306  int v16; // [sp+Ch] [bp-1Ch]@1
307
308  v15 = a3;
309  v16 = a4;
310  v4 = a1;
311  v5 = a2;
312  _android_log_print(4, "HTC Acoustic", "update voice ACDB id: (tx_acdb, rx_acdb) = (%d, %d)", a1, a2, a2, a3, a4);
313  v6 = open("/dev/htc-acoustic", 4098);
314  v7 = v6;
315  if ( v6 >= 0 )
316  {
317    v15 = v4;
318    v16 = v5;
319    v8 = ioctl(v6, 0x4004701Au, &v15);
320    v9 = v8;
321    if ( v8 >= 0 )
322    {
323      v10 = 4;
324      v13 = v5;
325      v11 = "update voice ACDB id (%d, %d) success";
326    }
327    else
328    {
329      v14 = v8;
330      v10 = 6;
331      v11 = "update voice ACDB id (%d, %d) failed %d";
332      v13 = v5;
333    }
334    _android_log_print(v10, "HTC Acoustic", v11, v4, v13, v14, v15, v16);
335    close(v7);
336    v7 = v9;
337  }
338  else
339  {
340    _android_log_print(6, "HTC Acoustic", "can't open /dev/htc-acoustic %d", v6);
341  }
342  return v7;
343}
344// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
345
346//----- (000011A4) --------------------------------------------------------
347int __fastcall update_acdb_id(int a1, int a2, int a3, int a4)
348{
349  int v4; // r8@1
350  int v5; // r7@1
351  int v6; // r6@1
352  int v7; // r9@1
353  int v8; // r0@1
354  int v9; // r4@1
355  int v10; // r6@3
356  int v11; // r0@5
357  int v13; // [sp+10h] [bp-30h]@3
358  int v14; // [sp+14h] [bp-2Ch]@3
359  int v15; // [sp+18h] [bp-28h]@3
360  int v16; // [sp+1Ch] [bp-24h]@3
361
362  v4 = a3;
363  v5 = a1;
364  v6 = a2;
365  v7 = a4;
366  _android_log_print(4, "HTC Acoustic", "update ACDB id: (tx, rx, tx_acdb, rx_acdb) = (%d, %d, %d, %d)", a1, a2, a3, a4);
367  v8 = open("/dev/htc-acoustic", 4098);
368  v9 = v8;
369  if ( v8 >= 0 )
370  {
371    v15 = v6;
372    v13 = v5;
373    v14 = v4;
374    v16 = v7;
375    v10 = ioctl(v8, 0x40047019u, &v13);
376    if ( v10 < 0 )
377      _android_log_print(6, "HTC Acoustic", "update ACDB id failed %d", v10);
378    v11 = v9;
379    v9 = v10;
380    close(v11);
381  }
382  else
383  {
384    _android_log_print(6, "HTC Acoustic", "can't open /dev/htc-acoustic %d", v8);
385  }
386  return v9;
387}
388// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
389
390//----- (00001240) --------------------------------------------------------
391int __fastcall android::get_acoust_tables(int a1)
392{
393  int v1; // r5@1
394  int v2; // r0@1
395  int v3; // r4@1
396  int v4; // r5@3
397
398  v1 = a1;
399  v2 = open("/dev/htc-acoustic", 4098);
400  v3 = v2;
401  if ( v2 >= 0 )
402  {
403    v4 = ioctl(v2, 0x40047021u, v1);
404    if ( v4 >= 0 )
405      close(v3);
406    else
407      _android_log_print(6, "HTC Acoustic", "read ACOUSTIC_GET_TABLES fail. %d", v4);
408    v3 = v4;
409  }
410  else
411  {
412    _android_log_print(6, "HTC Acoustic", "can't open /dev/htc-acoustic %d", v2);
413  }
414  return v3;
415}
416// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
417
418//----- (000012AC) --------------------------------------------------------
419int __fastcall android::support_codec_aic3254(int a1)
420{
421  int v1; // r0@2
422  int v2; // r4@2
423  int v3; // r0@4
424  int v4; // r5@4
425  int v6; // [sp+0h] [bp-18h]@1
426
427  v6 = a1;
428  if ( _data_start >= 0 )
429    goto LABEL_7;
430  v1 = open("/dev/htc-acoustic", 4098);
431  v2 = v1;
432  if ( v1 >= 0 )
433  {
434    v3 = ioctl(v1, 0x4004701Cu, &_data_start);
435    v4 = v3;
436    if ( v3 < 0 )
437    {
438      _android_log_print(6, "HTC Acoustic", "read engineer ID failed %d", v3, v6);
439      close(v2);
440      return v4;
441    }
442    close(v2);
443LABEL_7:
444    _android_log_print(
445      3,
446      "HTC Acoustic",
447      "%s, support_aic3254: %d",
448      "int android::support_codec_aic3254()",
449      _data_start);
450    return _data_start;
451  }
452  _android_log_print(6, "HTC Acoustic", "can't open /dev/htc-acoustic %d", v1, v6);
453  return v2;
454}
455// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
456
457//----- (00001358) --------------------------------------------------------
458int __fastcall support_back_mic()
459{
460  int v0; // r0@1
461  int v1; // r4@1
462  int v2; // r0@3
463  int v3; // r5@3
464  int v5; // [sp+Ch] [bp-14h]@1
465
466  v5 = 0;
467  v0 = open("/dev/htc-acoustic", 4098);
468  v1 = v0;
469  if ( v0 >= 0 )
470  {
471    v2 = ioctl(v0, 0x4004701Fu, &v5);
472    v3 = v2;
473    if ( v2 >= 0 )
474    {
475      close(v1);
476      _android_log_print(3, "HTC Acoustic", "%s, support_back_mic: %d", "int android::support_back_mic()", v5);
477      v1 = v5;
478    }
479    else
480    {
481      _android_log_print(6, "HTC Acoustic", "read back mic state fail. %d", v2);
482      close(v1);
483      v1 = v3;
484    }
485  }
486  else
487  {
488    _android_log_print(6, "HTC Acoustic", "can't open /dev/htc-acoustic %d", v0);
489  }
490  return v1;
491}
492// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
493
494//----- (000013F8) --------------------------------------------------------
495int __fastcall support_audience(int a1)
496{
497  int v1; // r0@2
498  int v2; // r4@2
499  int v3; // r0@4
500  int v4; // r5@4
501  int v6; // [sp+0h] [bp-18h]@1
502
503  v6 = a1;
504  if ( unk_51F4 >= 0 )
505    goto LABEL_7;
506  v1 = open("/dev/htc-acoustic", 4098);
507  v2 = v1;
508  if ( v1 >= 0 )
509  {
510    v3 = ioctl(v1, 0x4004701Bu, &unk_51F4);
511    v4 = v3;
512    if ( v3 < 0 )
513    {
514      _android_log_print(6, "HTC Acoustic", "read engineer ID failed %d", v3, v6);
515      close(v2);
516      return v4;
517    }
518    close(v2);
519LABEL_7:
520    _android_log_print(3, "HTC Acoustic", "%s, support_a1026: %d", "int android::support_audience()", unk_51F4);
521    return unk_51F4;
522  }
523  _android_log_print(6, "HTC Acoustic", "can't open /dev/htc-acoustic %d", v1, v6);
524  return v2;
525}
526// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
527
528//----- (000014A4) --------------------------------------------------------
529int __fastcall snd_get_bt_endpoint(int a1)
530{
531  int v1; // r4@1
532  int v2; // r7@1
533  int v3; // r6@1
534  int v4; // r8@2
535  int v5; // r2@2
536
537  v1 = 0;
538  v2 = a1;
539  v3 = 0;
540  while ( v3 < unk_5214 )
541  {
542    v4 = v2 + v1;
543    ++v3;
544    strcpy((char *)(v2 + v1 + 8), (const char *)(unk_5218 + v1 + 8));
545    v5 = unk_5218 + v1;
546    *(_DWORD *)(v2 + v1) = *(_DWORD *)(unk_5218 + v1);
547    v1 += 72;
548    *(_DWORD *)(v4 + 4) = *(_DWORD *)(v5 + 4);
549  }
550  return 0;
551}
552
553//----- (000014EC) --------------------------------------------------------
554int __fastcall set_tpa2028_parameters()
555{
556  int v0; // r4@4
557  int v1; // r0@6
558  int *v2; // r0@7
559  char *v3; // r0@7
560  int v4; // r8@9
561  int v5; // r7@10
562  void *v6; // r0@10
563  const char *i; // r5@11
564  char *v8; // r0@13
565  int v9; // r6@17
566  int v10; // r10@17
567  size_t v11; // r7@17
568  void *v12; // r5@17
569  char *v13; // r0@19
570  int v14; // r4@20
571  signed int v15; // r9@21
572  char *v16; // r0@21
573  char *v17; // r8@22
574  int v18; // r0@24
575  int v19; // r6@24
576  int result; // r0@27
577  char v21; // [sp+10h] [bp-388h]@6
578  size_t v22; // [sp+40h] [bp-358h]@10
579  size_t v23; // [sp+7Ch] [bp-31Ch]@25
580  signed int v24; // [sp+80h] [bp-318h]@25
581  void *v25; // [sp+84h] [bp-314h]@25
582  char v26; // [sp+88h] [bp-310h]@21
583  char v27; // [sp+8Ch] [bp-30Ch]@1
584  char v28; // [sp+2B4h] [bp-E4h]@2
585  char dest; // [sp+310h] [bp-88h]@3
586  int v30; // [sp+36Ch] [bp-2Ch]@1
587
588  v30 = _stack_chk_guard;
589  if ( android::get_acoust_tables((int)&v27) || !v28 )
590    strcpy(&dest, "/system/etc/TPA2028_CFG.csv");
591  else
592    sprintf(&dest, "%s%s", "/system/etc/", &v28);
593  _android_log_print(4, "HTC Acoustic", "TPA2028 CSV File Open From %s", &dest);
594  v0 = open(&dest, 0);
595  if ( v0 < 0 )
596  {
597    _android_log_print(6, "HTC Acoustic", "failed to open tpa2028 CSV files %s.", &dest);
598LABEL_9:
599    v4 = -1;
600    goto LABEL_27;
601  }
602  _android_log_print(4, "HTC Acoustic", "open %s success.", &dest);
603  v1 = fstat(v0, (struct stat *)&v21);
604  if ( v1 < 0 )
605  {
606    v2 = (int *)_errno(v1);
607    v3 = strerror(*v2);
608    _android_log_print(6, "HTC Acoustic", "failed to stat %s: %s (%d).", &dest, v3, 0);
609LABEL_8:
610    close(v0);
611    goto LABEL_9;
612  }
613  v5 = 0;
614  v6 = mmap(0, v22, 3, 2, v0, 0);
615  v4 = (int)v6;
616  if ( v6 == (void *)-1 )
617  {
618    _android_log_print(6, "HTC Acoustic", "failed to mmap parameters file: %s (%d)", &dest, 0);
619  }
620  else
621  {
622    for ( i = (const char *)v6; ; i = v8 + 1 )
623    {
624      v8 = strchr(i, 10);
625      if ( !v8 )
626        break;
627      if ( (unsigned __int8)*i != 35 )
628        ++v5;
629    }
630    v9 = 0;
631    v10 = v0;
632    v11 = 9 * v5;
633    v12 = malloc(v11);
634    memset(v12, 0, v11);
635    while ( 1 )
636    {
637      v13 = strchr((const char *)v4, 10);
638      if ( !v13 )
639        break;
640      *v13 = 0;
641      v14 = (int)(v13 + 1);
642      if ( *(_BYTE *)v4 != 35 )
643      {
644        v15 = 1;
645        *((_BYTE *)v12 + v9) = strtol((const char *)v4, (char **)&v26, 10);
646        v16 = (char *)(v4 + 1);
647        do
648        {
649          v17 = strchr(v16, 44) + 1;
650          *((_BYTE *)v12 + v9 + v15++) = strtol(v17, (char **)&v26, 16);
651          v16 = strchr(v17 + 1, 44);
652        }
653        while ( v15 != 9 );
654        v9 += 9;
655      }
656      v4 = v14;
657    }
658    v0 = v10;
659    v18 = open("/dev/tpa2028", 2050, 0);
660    v19 = v18;
661    if ( v18 < 0 )
662      goto LABEL_8;
663    v23 = v11;
664    v25 = v12;
665    v24 = 8;
666    v4 = ioctl(v18, 0x40046104u);
667    close(v19);
668    free(v12);
669  }
670  close(v0);
671LABEL_27:
672  result = v4;
673  if ( v30 != _stack_chk_guard )
674    _stack_chk_fail(v4);
675  return result;
676}
677// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
678// F08: using guessed type int __fastcall _errno(_DWORD);
679// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
680
681//----- (00001714) --------------------------------------------------------
682int __fastcall set_tpa2026_parameters()
683{
684  int v0; // r4@4
685  int v1; // r0@6
686  int *v2; // r0@7
687  char *v3; // r0@7
688  int v4; // r8@9
689  int v5; // r7@10
690  void *v6; // r0@10
691  const char *i; // r5@11
692  char *v8; // r0@13
693  int v9; // r6@17
694  int v10; // r10@17
695  size_t v11; // r7@17
696  void *v12; // r5@17
697  char *v13; // r0@19
698  int v14; // r4@20
699  signed int v15; // r9@21
700  char *v16; // r0@21
701  char *v17; // r8@22
702  int v18; // r0@24
703  int v19; // r6@24
704  int result; // r0@27
705  char v21; // [sp+10h] [bp-388h]@6
706  size_t v22; // [sp+40h] [bp-358h]@10
707  size_t v23; // [sp+7Ch] [bp-31Ch]@25
708  signed int v24; // [sp+80h] [bp-318h]@25
709  void *v25; // [sp+84h] [bp-314h]@25
710  char v26; // [sp+88h] [bp-310h]@21
711  char v27; // [sp+8Ch] [bp-30Ch]@1
712  char v28; // [sp+258h] [bp-140h]@2
713  char dest; // [sp+310h] [bp-88h]@3
714  int v30; // [sp+36Ch] [bp-2Ch]@1
715
716  v30 = _stack_chk_guard;
717  if ( android::get_acoust_tables((int)&v27) || !v28 )
718    strcpy(&dest, "/system/etc/TPA2026_CFG.csv");
719  else
720    sprintf(&dest, "%s%s", "/system/etc/", &v28);
721  _android_log_print(4, "HTC Acoustic", "TPA2026 CSV File Open From %s", &dest);
722  v0 = open(&dest, 0);
723  if ( v0 < 0 )
724  {
725    _android_log_print(6, "HTC Acoustic", "failed to open TPA2026 CSV files %s.", &dest);
726LABEL_9:
727    v4 = -1;
728    goto LABEL_27;
729  }
730  _android_log_print(4, "HTC Acoustic", "open %s success.", &dest);
731  v1 = fstat(v0, (struct stat *)&v21);
732  if ( v1 < 0 )
733  {
734    v2 = (int *)_errno(v1);
735    v3 = strerror(*v2);
736    _android_log_print(6, "HTC Acoustic", "failed to stat %s: %s (%d).", &dest, v3, 0);
737LABEL_8:
738    close(v0);
739    goto LABEL_9;
740  }
741  v5 = 0;
742  v6 = mmap(0, v22, 3, 2, v0, 0);
743  v4 = (int)v6;
744  if ( v6 == (void *)-1 )
745  {
746    _android_log_print(6, "HTC Acoustic", "failed to mmap parameters file: %s (%d)", &dest, 0);
747  }
748  else
749  {
750    for ( i = (const char *)v6; ; i = v8 + 1 )
751    {
752      v8 = strchr(i, 10);
753      if ( !v8 )
754        break;
755      if ( (unsigned __int8)*i != 35 )
756        ++v5;
757    }
758    v9 = 0;
759    v10 = v0;
760    v11 = 9 * v5;
761    v12 = malloc(v11);
762    memset(v12, 0, v11);
763    while ( 1 )
764    {
765      v13 = strchr((const char *)v4, 10);
766      if ( !v13 )
767        break;
768      *v13 = 0;
769      v14 = (int)(v13 + 1);
770      if ( *(_BYTE *)v4 != 35 )
771      {
772        v15 = 1;
773        *((_BYTE *)v12 + v9) = strtol((const char *)v4, (char **)&v26, 10);
774        v16 = (char *)(v4 + 1);
775        do
776        {
777          v17 = strchr(v16, 44) + 1;
778          *((_BYTE *)v12 + v9 + v15++) = strtol(v17, (char **)&v26, 16);
779          v16 = strchr(v17 + 1, 44);
780        }
781        while ( v15 != 9 );
782        v9 += 9;
783      }
784      v4 = v14;
785    }
786    v0 = v10;
787    v18 = open("/dev/tpa2026", 2050, 0);
788    v19 = v18;
789    if ( v18 < 0 )
790      goto LABEL_8;
791    v23 = v11;
792    v25 = v12;
793    v24 = 8;
794    v4 = ioctl(v18, 0x40046104u);
795    close(v19);
796    free(v12);
797  }
798  close(v0);
799LABEL_27:
800  result = v4;
801  if ( v30 != _stack_chk_guard )
802    _stack_chk_fail(v4);
803  return result;
804}
805// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
806// F08: using guessed type int __fastcall _errno(_DWORD);
807// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
808
809//----- (0000193C) --------------------------------------------------------
810int __fastcall set_tpa2051_parameters()
811{
812  int v0; // r4@4
813  int v1; // r0@6
814  int *v2; // r0@7
815  char *v3; // r0@7
816  int v4; // r8@9
817  int v5; // r7@10
818  void *v6; // r0@10
819  const char *i; // r5@11
820  char *v8; // r0@13
821  int v9; // r6@17
822  int v10; // r10@17
823  size_t v11; // r7@17
824  void *v12; // r5@17
825  char *v13; // r0@19
826  int v14; // r4@20
827  signed int v15; // r9@21
828  char *v16; // r0@21
829  char *v17; // r8@22
830  int v18; // r0@24
831  int v19; // r6@24
832  int result; // r0@28
833  char v21; // [sp+10h] [bp-388h]@6
834  size_t v22; // [sp+40h] [bp-358h]@10
835  size_t v23; // [sp+7Ch] [bp-31Ch]@26
836  signed int v24; // [sp+80h] [bp-318h]@26
837  void *v25; // [sp+84h] [bp-314h]@26
838  char v26; // [sp+88h] [bp-310h]@21
839  char v27; // [sp+8Ch] [bp-30Ch]@1
840  char v28; // [sp+1FCh] [bp-19Ch]@2
841  char dest; // [sp+310h] [bp-88h]@3
842  int v30; // [sp+36Ch] [bp-2Ch]@1
843
844  v30 = _stack_chk_guard;
845  if ( android::get_acoust_tables((int)&v27) || !v28 )
846    strcpy(&dest, "/system/etc/TPA2051_CFG.csv");
847  else
848    sprintf(&dest, "%s%s", "/system/etc/", &v28);
849  _android_log_print(4, "HTC Acoustic", "TPA2051 CSV File Open From %s", &dest);
850  v0 = open(&dest, 0);
851  if ( v0 < 0 )
852  {
853    _android_log_print(3, "HTC Acoustic", "failed to open A2051 CSV files %s.", &dest);
854LABEL_9:
855    v4 = -1;
856    goto LABEL_28;
857  }
858  _android_log_print(4, "HTC Acoustic", "open %s success.", &dest);
859  v1 = fstat(v0, (struct stat *)&v21);
860  if ( v1 < 0 )
861  {
862    v2 = (int *)_errno(v1);
863    v3 = strerror(*v2);
864    _android_log_print(6, "HTC Acoustic", "failed to stat %s: %s (%d).", &dest, v3, 0);
865LABEL_8:
866    close(v0);
867    goto LABEL_9;
868  }
869  v5 = 0;
870  v6 = mmap(0, v22, 3, 2, v0, 0);
871  v4 = (int)v6;
872  if ( v6 == (void *)-1 )
873  {
874    _android_log_print(6, "HTC Acoustic", "failed to mmap parameters file: %s (%d)", &dest, 0);
875  }
876  else
877  {
878    for ( i = (const char *)v6; ; i = v8 + 1 )
879    {
880      v8 = strchr(i, 10);
881      if ( !v8 )
882        break;
883      if ( (unsigned __int8)*i != 35 )
884        ++v5;
885    }
886    v9 = 0;
887    v10 = v0;
888    v11 = 9 * v5;
889    v12 = malloc(v11);
890    memset(v12, 0, v11);
891    while ( 1 )
892    {
893      v13 = strchr((const char *)v4, 10);
894      if ( !v13 )
895        break;
896      *v13 = 0;
897      v14 = (int)(v13 + 1);
898      if ( *(_BYTE *)v4 != 35 )
899      {
900        v15 = 1;
901        *((_BYTE *)v12 + v9) = strtol((const char *)v4, (char **)&v26, 10);
902        v16 = (char *)(v4 + 1);
903        do
904        {
905          v17 = strchr(v16, 44) + 1;
906          *((_BYTE *)v12 + v9 + v15++) = strtol(v17, (char **)&v26, 16);
907          v16 = strchr(v17 + 1, 44);
908        }
909        while ( v15 != 9 );
910        v9 += 9;
911      }
912      v4 = v14;
913    }
914    v0 = v10;
915    v18 = open("/dev/tpa2051d3", 2050, 0);
916    v19 = v18;
917    if ( v18 < 0 )
918    {
919      _android_log_print(6, "HTC Acoustic", "Cannot open audience_2051 device (%d)\n", v18);
920      goto LABEL_8;
921    }
922    v23 = v11;
923    v25 = v12;
924    v24 = 9;
925    v4 = ioctl(v18, 0x40046104u);
926    close(v19);
927    free(v12);
928  }
929  close(v0);
930LABEL_28:
931  result = v4;
932  if ( v30 != _stack_chk_guard )
933    _stack_chk_fail(v4);
934  return result;
935}
936// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
937// F08: using guessed type int __fastcall _errno(_DWORD);
938// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
939
940//----- (00001B7C) --------------------------------------------------------
941signed int __fastcall set_a1026_parameters(int a1)
942{
943  int v1; // r4@2
944  int v2; // r6@4
945  int v3; // r0@5
946  int *v4; // r0@6
947  char *v5; // r0@6
948  int v6; // r1@6
949  const char *v7; // r2@6
950  int v8; // r3@6
951  signed int v9; // r0@6
952  int v10; // r7@7
953  void *v11; // r0@7
954  void *v12; // r8@7
955  const char *i; // r5@8
956  char *v14; // r6@10
957  int v15; // r9@14
958  int v16; // r10@14
959  void *v17; // r5@14
960  char *v18; // r0@16
961  char *v19; // r7@16
962  int v20; // r7@17
963  int v21; // r9@18
964  char *v22; // r8@18
965  char *v23; // r8@18
966  char *v24; // r8@18
967  char *v25; // r8@18
968  char *v26; // r0@18
969  int v27; // r0@19
970  int v28; // r9@19
971  int v29; // r0@20
972  signed int v30; // r0@24
973  int v31; // r1@24
974  const char *v32; // r2@24
975  char *fd; // [sp+0h] [bp-A8h]@6
976  int offset; // [sp+4h] [bp-A4h]@6
977  struct stat buf; // [sp+8h] [bp-A0h]@5
978  int v37; // [sp+70h] [bp-38h]@23
979  void *v38; // [sp+78h] [bp-30h]@23
980  char v39; // [sp+7Ch] [bp-2Ch]@18
981
982  if ( !support_audience(a1) )
983    return -1;
984  v1 = open("/system/etc/A1026_CFG.csv", 0);
985  if ( v1 < 0 )
986  {
987    _android_log_print(6, "HTC Acoustic", "failed to open A1026 CSV files %s.", "/system/etc/A1026_CFG.csv");
988    return -1;
989  }
990  _android_log_print(4, "HTC Acoustic", "open %s success.", "/system/etc/A1026_CFG.csv");
991  v3 = fstat(v1, &buf);
992  if ( v3 < 0 )
993  {
994    v4 = (int *)_errno(v3);
995    v5 = strerror(*v4);
996    v6 = (int)"HTC Acoustic";
997    offset = 0;
998    v7 = "failed to stat %s: %s (%d).";
999    v8 = (int)"/system/etc/A1026_CFG.csv";
1000    fd = v5;
1001    v9 = 6;
1002LABEL_22:
1003    _android_log_print(v9, v6, v7, v8, fd, offset);
1004    close(v1);
1005    return -1;
1006  }
1007  v10 = 0;
1008  v11 = mmap(0, buf.st_blksize, 3, 2, v1, 0);
1009  v12 = v11;
1010  if ( v11 == (void *)-1 )
1011  {
1012    _android_log_print(6, "HTC Acoustic", "failed to mmap parameters file: %s (%d)", "/system/etc/A1026_CFG.csv", 0);
1013    close(v1);
1014    return (signed int)v12;
1015  }
1016  for ( i = (const char *)v11; ; i = v14 + 1 )
1017  {
1018    v14 = strchr(i, 10);
1019    if ( !v14 )
1020      break;
1021    if ( (unsigned __int8)*i != 35 )
1022      ++v10;
1023  }
1024  v15 = 0;
1025  v16 = 6 * v10;
1026  v17 = malloc(6 * v10);
1027  memset(v17, 0, 6 * v10);
1028  while ( 1 )
1029  {
1030    v18 = strchr((const char *)v12, 10);
1031    v19 = v18;
1032    if ( !v18 )
1033      break;
1034    *v18 = 0;
1035    v20 = (int)(v18 + 1);
1036    if ( *(_BYTE *)v12 != 35 )
1037    {
1038      *((_BYTE *)v17 + v15) = strtol((const char *)v12, (char **)&v39, 10);
1039      v21 = v15 + 1;
1040      v22 = strchr((const char *)v12 + 1, 44) + 1;
1041      *((_BYTE *)v17 + v21++) = strtol(v22, (char **)&v39, 16);
1042      v23 = strchr(v22 + 1, 44) + 1;
1043      *((_BYTE *)v17 + v21++) = strtol(v23, (char **)&v39, 16);
1044      v24 = strchr(v23 + 1, 44) + 1;
1045      *((_BYTE *)v17 + v21++) = strtol(v24, (char **)&v39, 16);
1046      v25 = strchr(v24 + 1, 44) + 1;
1047      *((_BYTE *)v17 + v21) = strtol(v25, (char **)&v39, 16);
1048      v26 = strchr(v25 + 1, 44);
1049      ++v21;
1050      *((_BYTE *)v17 + v21) = strtol(v26 + 1, (char **)&v39, 16);
1051      v15 = v21 + 1;
1052    }
1053    v12 = (void *)v20;
1054  }
1055  v27 = open("/dev/audience_a1026", 2050, 0);
1056  v28 = v27;
1057  if ( v27 < 0 )
1058  {
1059    _android_log_print(
1060      6,
1061      "HTC Acoustic",
1062      "Cannot open %s (%d). try next audience driver.\n",
1063      "/dev/audience_a1026",
1064      v27);
1065    v29 = open("/dev/audience_a1028", 2050, v19);
1066    v28 = v29;
1067    if ( v29 < 0 )
1068    {
1069      v6 = (int)"HTC Acoustic";
1070      fd = (char *)v29;
1071      v8 = (int)"/dev/audience_a1028";
1072      v7 = "Cannot open %s (%d)\n";
1073      v9 = 6;
1074      goto LABEL_22;
1075    }
1076  }
1077  v37 = v16;
1078  v38 = v17;
1079  v2 = ioctl(v28, 0x40047504u, &v37);
1080  close(v28);
1081  if ( v2 )
1082  {
1083    v30 = 6;
1084    v31 = (int)"HTC Acoustic";
1085    v32 = "Update a1026 parameter fail";
1086  }
1087  else
1088  {
1089    v30 = 4;
1090    v31 = (int)"HTC Acoustic";
1091    v32 = "Update a1026 parameter successful";
1092  }
1093  _android_log_print(v30, v31, v32);
1094  free(v17);
1095  close(v1);
1096  return v2;
1097}
1098// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
1099// F08: using guessed type int __fastcall _errno(_DWORD);
1100
1101//----- (00001E10) --------------------------------------------------------
1102char *__fastcall sub_1E10(const char *a1)
1103{
1104  const char *v1; // r4@1
1105  char *result; // r0@3
1106  int v3; // r3@4
1107  bool v4; // r5@5
1108  char *v5; // r0@10
1109  int v6; // r9@11
1110  char *v7; // r0@11
1111  _UNKNOWN *v8; // r3@12
1112  bool v9; // r7@14
1113  char *v10; // r0@19
1114  int v11; // r10@20
1115  char *v12; // r0@20
1116  bool v13; // r12@23
1117  int v14; // r0@26
1118  char *v15; // r0@29
1119  int v16; // r4@30
1120  int v17; // [sp+0h] [bp-428h]@1
1121  int v18; // [sp+4h] [bp-424h]@3
1122  int v19; // [sp+404h] [bp-24h]@1
1123
1124  v1 = a1;
1125  v19 = _stack_chk_guard;
1126  memcpy(&v17, " ,", 3u);
1127  if ( unk_5200 != unk_521C )
1128  {
1129    unk_5200 = unk_521C;
1130    unk_51F8 = 1;
1131  }
1132  strcpy((char *)&v18, v1);
1133  result = strtok((char *)&v18, (const char *)&v17);
1134  if ( result )
1135  {
1136    v3 = (unsigned __int8)*result;
1137    v4 = v3 == 119;
1138    if ( v3 == 87 )
1139      v4 |= 1u;
1140    if ( v4 )
1141    {
1142      strtok(0, (const char *)&v17);
1143      v5 = strtok(0, (const char *)&v17);
1144      if ( (unsigned __int8)(*v5 - 48) <= 9u )
1145      {
1146        v6 = unk_521C + 3 * unk_51F8;
1147        *(_BYTE *)(unk_521C + 3 * unk_51F8) = 119;
1148        *(_BYTE *)(v6 + 1) = strtol(v5, 0, 16);
1149        v7 = strtok(0, (const char *)&v17);
1150        *(_BYTE *)(unk_521C + 3 * unk_51F8 + 2) = strtol(v7, 0, 16);
1151      }
1152      v8 = &_data_start;
1153    }
1154    else
1155    {
1156      v9 = v3 == 114;
1157      if ( v3 == 82 )
1158        v9 |= 1u;
1159      if ( v9 )
1160      {
1161        strtok(0, (const char *)&v17);
1162        v10 = strtok(0, (const char *)&v17);
1163        if ( (unsigned int)(unsigned __int8)*v10 - 48 <= 9 )
1164        {
1165          v11 = unk_521C + 3 * unk_51F8;
1166          *(_BYTE *)(unk_521C + 3 * unk_51F8) = 114;
1167          *(_BYTE *)(v11 + 1) = strtol(v10, 0, 16);
1168          v12 = strtok(0, (const char *)&v17);
1169          *(_BYTE *)(unk_521C + 3 * unk_51F8 + 2) = strtol(v12, 0, 16);
1170        }
1171        v8 = &_data_start;
1172      }
1173      else
1174      {
1175        v13 = v3 == 100;
1176        if ( v3 == 68 )
1177          v14 = v13 | 1;
1178        else
1179          v14 = v13;
1180        if ( !v14 )
1181          goto LABEL_33;
1182        v15 = strtok(0, (const char *)&v17);
1183        if ( (unsigned __int8)(*v15 - 48) <= 9u )
1184        {
1185          v16 = unk_521C + 3 * unk_51F8;
1186          *(_BYTE *)(unk_521C + 3 * unk_51F8) = 100;
1187          *(_BYTE *)(v16 + 2) = strtol(v15, 0, 10);
1188        }
1189        v8 = &_data_start;
1190      }
1191    }
1192    ++*((_DWORD *)v8 + 2);
1193LABEL_33:
1194    result = (char *)unk_51F8;
1195  }
1196  if ( v19 != _stack_chk_guard )
1197    _stack_chk_fail(result);
1198  return result;
1199}
1200// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
1201
1202//----- (00002038) --------------------------------------------------------
1203int __fastcall sub_2038(const char *a1)
1204{
1205  const char *v1; // r6@1
1206  char *v2; // r0@1
1207  char *v3; // r4@1
1208  int v4; // r8@2
1209  bool v5; // r3@3
1210  int v6; // r2@6
1211  int v7; // r2@16
1212  char *v8; // r0@21
1213  char *v9; // r11@22
1214  char *v10; // r0@22
1215  char *v11; // r10@24
1216  char *v12; // r0@24
1217  int result; // r0@26
1218  char *endptr; // [sp+4h] [bp-Ch]@16
1219  char dest; // [sp+8h] [bp-8h]@1
1220  char v16; // [sp+Ch] [bp-4h]@1
1221  char v17; // [sp+10h] [bp+0h]@21
1222  int v18; // [sp+40Ch] [bp+3FCh]@1
1223
1224  v1 = a1;
1225  v18 = _stack_chk_guard;
1226  memcpy(&dest, " ,", 3u);
1227  strcpy(&v16, v1);
1228  v2 = strtok(&v16, &dest);
1229  v3 = v2;
1230  if ( !v2 )
1231    goto LABEL_26;
1232  v4 = (unsigned __int8)*v2;
1233  v5 = (unsigned int)(v4 - 65) <= 1;
1234  if ( v4 == 119 )
1235    v6 = v5 | 1;
1236  else
1237    v6 = v5;
1238  if ( !v6 )
1239  {
1240    if ( v4 != 87 && v4 != 114 && v4 != 82 && v4 != 100 && v4 != 68 )
1241      goto LABEL_26;
1242    goto LABEL_21;
1243  }
1244  if ( !v5 )
1245  {
1246LABEL_21:
1247    strtok(0, &dest);
1248    v8 = strtok(0, &v17);
1249    if ( unk_5224 )
1250    {
1251      if ( unk_5224 == 1 )
1252      {
1253        v11 = &byte_34DA8[3 * (dword_51FC + (unk_5220 << 10))];
1254        v11[1152] = v4;
1255        v11[1153] = strtol(v8, &endptr, 16);
1256        v12 = strtok(0, &v17);
1257        byte_34DA8[3 * (signed int)&v17 + 1154] = strtol(v12, &endptr, 16);
1258        byte_34DA8[3072 * unk_5220 + 1154] = dword_51FC + 1;
1259      }
1260    }
1261    else
1262    {
1263      v9 = (char *)&unk_5210 + 3 * (dword_51FC + (unk_5220 << 10)) + 24;
1264      *v9 = v4;
1265      v9[1] = strtol(v8, &endptr, 16);
1266      v10 = strtok(0, &v17);
1267      *((_BYTE *)&unk_5210 + 3 * (_DWORD)&v17 + 26) = strtol(v10, &endptr, 16);
1268      *((_BYTE *)&unk_5210 + 3072 * unk_5220 + 26) = dword_51FC + 1;
1269    }
1270    ++dword_51FC;
1271    goto LABEL_26;
1272  }
1273  unk_5220 = strtol(v2 + 1, &endptr, 10);
1274  dword_51FC = 1;
1275  v7 = (unsigned __int8)*v3;
1276  if ( v7 == 65 )
1277  {
1278    unk_5224 = 0;
1279  }
1280  else
1281  {
1282    if ( v7 == 66 )
1283      unk_5224 = 1;
1284  }
1285LABEL_26:
1286  result = 0;
1287  if ( v18 != _stack_chk_guard )
1288    _stack_chk_fail(0);
1289  return result;
1290}
1291// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
1292
1293//----- (0000223C) --------------------------------------------------------
1294int __fastcall sub_223C(const char *a1)
1295{
1296  char *v1; // r0@1
1297  int v2; // r3@2
1298  signed int v3; // r4@3
1299  char *i; // r0@3
1300  int v5; // r3@4
1301  _UNKNOWN *v6; // r3@6
1302  char *j; // r0@8
1303  int v8; // lr@9
1304  signed int k; // r5@14
1305  char *v10; // r0@15
1306  signed int l; // r5@24
1307  char *v12; // r0@25
1308  int result; // r0@34
1309  int v14; // [sp+Ch] [bp-4h]@3
1310  char *v15[2]; // [sp+10h] [bp+0h]@1
1311  int v16; // [sp+14h] [bp+4h]@1
1312  int v17; // [sp+414h] [bp+404h]@1
1313
1314  v17 = _stack_chk_guard;
1315  LOWORD(v15[0]) = 44;
1316  strcpy((char *)&v16, a1);
1317  v1 = strtok((char *)&v16, (const char *)v15);
1318  if ( !v1 )
1319    goto LABEL_34;
1320  v2 = (unsigned __int8)*v1;
1321  if ( v2 == 65 )
1322  {
1323    v3 = 1;
1324    unk_65228 = strtol(v1 + 1, (char **)&v14, 10);
1325    strtok(0, (const char *)v15);
1326    strtok(0, (const char *)v15);
1327    for ( i = strtok(0, (const char *)v15); i; i = strtok(0, (const char *)v15) )
1328    {
1329      v5 = v3++ + (unk_65228 << 10);
1330      *((_BYTE *)&unk_5210 + 3 * v5 + 24) = *i;
1331    }
1332    v6 = &unk_64940;
1333    unk_6522C = 0;
1334LABEL_12:
1335    *((_DWORD *)v6 + 572) = v3;
1336    goto LABEL_34;
1337  }
1338  if ( v2 == 66 )
1339  {
1340    v3 = 1;
1341    unk_65228 = strtol(v1 + 1, (char **)&v14, 10);
1342    strtok(0, (const char *)v15);
1343    strtok(0, (const char *)v15);
1344    for ( j = strtok(0, (const char *)v15); j; j = strtok(0, (const char *)v15) )
1345    {
1346      v8 = v3++ + (unk_65228 << 10);
1347      byte_34DA8[3 * v8 + 1152] = *j;
1348    }
1349    v6 = &unk_64940;
1350    unk_6522C = 1;
1351    goto LABEL_12;
1352  }
1353  if ( v2 == 82 )
1354  {
1355    for ( k = 1; (unsigned int)k < dword_65230[0]; ++k )
1356    {
1357      v10 = strtok(0, (const char *)v15);
1358      if ( v10 )
1359      {
1360        if ( unk_6522C )
1361          byte_34DA8[3 * (k + (unk_65228 << 10)) + 1153] = strtol(v10, v15, 16);
1362        else
1363          *((_BYTE *)&unk_5210 + 3 * (k + (unk_65228 << 10)) + 25) = strtol(v10, v15, 16);
1364      }
1365      else
1366      {
1367        *((_BYTE *)&unk_5210 + 3 * (k + (unk_65228 << 10)) + 25) = 0;
1368      }
1369    }
1370  }
1371  else
1372  {
1373    if ( v2 == 86 )
1374    {
1375      for ( l = 1; (unsigned int)l < dword_65230[0]; ++l )
1376      {
1377        v12 = strtok(0, (const char *)v15);
1378        if ( unk_6522C )
1379          byte_34DA8[3 * (l + (unk_65228 << 10)) + 1154] = strtol(v12, v15, 16);
1380        else
1381          *((_BYTE *)&unk_5210 + 3 * (l + (unk_65228 << 10)) + 26) = strtol(v12, v15, 16);
1382      }
1383      if ( unk_6522C )
1384        byte_34DA8[3072 * unk_65228 + 1154] = LOBYTE(dword_65230[0]);
1385      else
1386        *((_BYTE *)&unk_5210 + 3072 * unk_65228 + 26) = LOBYTE(dword_65230[0]);
1387      dword_65230[0] = 0;
1388    }
1389  }
1390LABEL_34:
1391  result = 0;
1392  if ( v17 != _stack_chk_guard )
1393    _stack_chk_fail(0);
1394  return result;
1395}
1396// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
1397// 2F76: using guessed type int();
1398
1399//----- (000024FC) --------------------------------------------------------
1400int __fastcall android::read_bt_endpoints()
1401{
1402  int v0; // r0@1
1403  int v1; // r4@1
1404  const char *v2; // r8@3
1405  char *v3; // r0@5
1406  int v4; // r10@6
1407  unsigned __int64 v5; // r0@6
1408  void *v6; // r0@12
1409  size_t v7; // r2@12
1410  char *v8; // r0@14
1411  const char *v9; // r8@14
1412  char *v10; // r0@17
1413  char *v11; // r0@18
1414  char *v12; // r0@20
1415  int result; // r0@24
1416  void *s; // [sp+Ch] [bp-1434h]@3
1417  char v15; // [sp+18h] [bp-1428h]@3
1418  size_t v16; // [sp+48h] [bp-13F8h]@3
1419  int v17; // [sp+84h] [bp-13BCh]@19
1420  signed __int16 v18; // [sp+88h] [bp-13B8h]@1
1421  int v19; // [sp+8Ch] [bp-13B4h]@6
1422  int v20; // [sp+1414h] [bp-2Ch]@1
1423
1424  v20 = _stack_chk_guard;
1425  v18 = 44;
1426  v0 = open("/system/etc/AudioBTID.csv", 4096);
1427  v1 = v0;
1428  if ( v0 >= 0 )
1429  {
1430    _android_log_print(4, "HTC Acoustic", "open %s success.", "/system/etc/AudioBTID.csv");
1431    fstat(v1, (struct stat *)&v15);
1432    s = malloc(v16);
1433    read(v1, s, v16);
1434    v2 = (const char *)s;
1435    unk_5218 = operator new__(7200);
1436    while ( 1 )
1437    {
1438      v3 = strchr(v2, 10);
1439      if ( !v3 )
1440        break;
1441      v4 = (int)(v3 + 1);
1442      memset(&v19, 0, 0x1388u);
1443      LODWORD(v5) = strchr(v2, 13);
1444      BYTE4(v5) = v5;
1445      if ( (_DWORD)v5 )
1446        BYTE4(v5) = 1;
1447      if ( (unsigned int)v2 < (unsigned int)v5 )
1448        HIDWORD(v5) = BYTE4(v5) & 1;
1449      else
1450        HIDWORD(v5) = 0;
1451      if ( v5 >= (unsigned int)v4 )
1452      {
1453        v6 = &v19;
1454        v7 = v4 - (_DWORD)v2 - 1;
1455      }
1456      else
1457      {
1458        v6 = &v19;
1459        v7 = v4 - (_DWORD)v2 - 2;
1460      }
1461      memcpy(v6, v2, v7);
1462      v8 = strtok((char *)&v19, (const char *)&v18);
1463      v9 = v8;
1464      if ( !v8 || strcmp(v8, "Header") && strcmp(v9, "HEADER") )
1465      {
1466        strcpy((char *)(unk_5218 + 72 * unk_5214 + 8), v9);
1467        v11 = strtok(0, (const char *)&v18);
1468        if ( v11 )
1469          *(_DWORD *)(unk_5218 + 72 * unk_5214) = strtol(v11, (char **)&v17, 10);
1470        v12 = strtok(0, (const char *)&v18);
1471        if ( v12 )
1472          *(_DWORD *)(unk_5218 + 72 * unk_5214 + 4) = strtol(v12, (char **)&v17, 10);
1473        ++unk_5214;
1474      }
1475      else
1476      {
1477        v10 = strtok(0, (const char *)&v18);
1478        _android_log_print(4, 14504, "BT ID table version: %s", v10);
1479      }
1480      v2 = (const char *)v4;
1481    }
1482    free(s);
1483    close(v1);
1484    v1 = 0;
1485  }
1486  else
1487  {
1488    _android_log_print(6, "HTC Acoustic", "Fail to open %s %d.", "/system/etc/AudioBTID.csv", v0);
1489  }
1490  result = v1;
1491  if ( v20 != _stack_chk_guard )
1492    _stack_chk_fail(v1);
1493  return result;
1494}
1495// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
1496// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
1497// F98: using guessed type int __fastcall operator new__(_DWORD);
1498
1499//----- (00002728) --------------------------------------------------------
1500int __fastcall sub_2728(int (__fastcall *a1)(_DWORD), const char *a2)
1501{
1502  const char *v2; // r6@1
1503  int v3; // r0@1
1504  int v4; // r4@1
1505  int *v5; // r0@2
1506  char *v6; // r0@2
1507  char *v7; // r4@2
1508  int v8; // r0@2
1509  int v9; // r0@3
1510  int *v10; // r0@4
1511  char *v11; // r0@4
1512  char *v12; // r8@4
1513  int v13; // r0@4
1514  int v14; // r8@6
1515  void *v15; // r0@7
1516  void *v16; // r6@7
1517  const char *v17; // r7@8
1518  int v18; // r10@8
1519  int v19; // r9@8
1520  int *v20; // r0@9
1521  char *v21; // r0@9
1522  char *v22; // r8@9
1523  int v23; // r0@9
1524  char *v24; // r0@11
1525  int v25; // r3@12
1526  char *v26; // r4@15
1527  char *v27; // r0@17
1528  int result; // r0@21
1529  int v29; // [sp+20h] [bp-4A0h]@12
1530  int (__fastcall *v30)(_DWORD); // [sp+24h] [bp-49Ch]@1
1531  char v31; // [sp+28h] [bp-498h]@3
1532  size_t v32; // [sp+58h] [bp-468h]@7
1533  __int16 delim; // [sp+90h] [bp-430h]@15
1534  int v34; // [sp+94h] [bp-42Ch]@12
1535  int v35; // [sp+494h] [bp-2Ch]@1
1536
1537  v2 = a2;
1538  v30 = a1;
1539  v35 = _stack_chk_guard;
1540  v3 = open(a2, 0);
1541  v4 = v3;
1542  if ( v3 < 0 )
1543  {
1544    v5 = (int *)_errno(v3);
1545    v6 = strerror(*v5);
1546    v7 = v6;
1547    v8 = _errno(v6);
1548    _android_log_print(3, "HTC Acoustic", "failed to open file %s: %s (%d).", v2, v7, *(_DWORD *)v8);
1549LABEL_6:
1550    v14 = -1;
1551    goto LABEL_21;
1552  }
1553  _android_log_print(4, "HTC Acoustic", "open %s success.", v2);
1554  v9 = fstat(v4, (struct stat *)&v31);
1555  if ( v9 < 0 )
1556  {
1557    v10 = (int *)_errno(v9);
1558    v11 = strerror(*v10);
1559    v12 = v11;
1560    v13 = _errno(v11);
1561    _android_log_print(6, "HTC Acoustic", "failed to stat %s: %s (%d).", v2, v12, *(_DWORD *)v13);
1562LABEL_5:
1563    close(v4);
1564    goto LABEL_6;
1565  }
1566  v14 = 0;
1567  v15 = mmap(0, v32, 3, 2, v4, 0);
1568  v16 = v15;
1569  if ( v15 == (void *)-1 )
1570  {
1571    v20 = (int *)_errno(-1);
1572    v21 = strerror(*v20);
1573    v22 = v21;
1574    v23 = _errno(v21);
1575    _android_log_print(6, "HTC Acoustic", "failed to mmap parameters file: %s (%d)", v22, *(_DWORD *)v23);
1576    close(v4);
1577    v14 = (int)v16;
1578  }
1579  else
1580  {
1581    v17 = (const char *)v15;
1582    v18 = 0;
1583    v19 = v4;
1584    while ( 1 )
1585    {
1586      v24 = strchr(v17, 10);
1587      if ( !v24 )
1588        break;
1589      v29 = (int)(v24 + 1);
1590      memset(&v34, 0, 0x400u);
1591      memcpy(&v34, v17, v29 - (_DWORD)v17 - 1);
1592      v25 = v29 - (_DWORD)v17 - 2;
1593      if ( *((_BYTE *)&v34 + v25) == 13 )
1594        *((_BYTE *)&v34 + v25) = 0;
1595      if ( v18
1596        || (delim = 44, v26 = strtok((char *)&v34, (const char *)&delim), strcmp(v26, "Header"))
1597        && strcmp(v26, "HEADER") )
1598      {
1599        v14 = v30(&v34);
1600        if ( v14 < 0 )
1601        {
1602          v4 = v19;
1603          _android_log_print(4, "HTC Acoustic", "failed to parse aic3254 parameters, exiting.");
1604          munmap(v16, v32);
1605          goto LABEL_5;
1606        }
1607      }
1608      else
1609      {
1610        v27 = strtok(0, (const char *)&delim);
1611        _android_log_print(4, "HTC Acoustic", "AIC3254 table version: %s", v27);
1612      }
1613      v17 = (const char *)v29;
1614      ++v18;
1615    }
1616    munmap(v16, v32);
1617    close(v19);
1618  }
1619LABEL_21:
1620  result = v14;
1621  if ( v35 != _stack_chk_guard )
1622    _stack_chk_fail(v14);
1623  return result;
1624}
1625// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
1626// F08: using guessed type int __fastcall _errno(_DWORD);
1627// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
1628
1629//----- (00002968) --------------------------------------------------------
1630int __fastcall set_aic3254_ioctl(unsigned __int32 a1, int a2)
1631{
1632  int v2; // r5@1
1633  unsigned __int32 v3; // r6@1
1634  int v4; // r0@1
1635  int v5; // r4@1
1636  int v6; // r5@2
1637
1638  v2 = a2;
1639  v3 = a1;
1640  pthread_mutex_lock((pthread_mutex_t *)&dword_65230[1]);
1641  v4 = open("/dev/codec_aic3254", 2050, 0);
1642  v5 = v4;
1643  if ( v4 >= 0 )
1644  {
1645    v6 = ioctl(v4, v3, v2);
1646    close(v5);
1647  }
1648  else
1649  {
1650    v6 = -14;
1651    _android_log_print(6, "HTC Acoustic", "cannot open codec aic3254 device %d", v4);
1652  }
1653  pthread_mutex_unlock((pthread_mutex_t *)&dword_65230[1]);
1654  return v6;
1655}
1656// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
1657
1658//----- (000029E0) --------------------------------------------------------
1659int __fastcall set_sound_effect(const char *a1)
1660{
1661  const char *v1; // r5@1
1662  int v2; // r4@1
1663  int v3; // r6@1
1664  int v4; // r9@2
1665  int v5; // r8@2
1666  int v6; // r4@3
1667  int v7; // r4@4
1668
1669  v1 = a1;
1670  _android_log_print(4, "HTC Acoustic", "set_audio_effect: %s", a1, a1);
1671  v2 = 0;
1672  v3 = 0;
1673  while ( 1 )
1674  {
1675    v4 = dword_65230[2] + v2;
1676    v5 = *(_DWORD *)(dword_65230[2] + v2);
1677    if ( !strcasecmp(v1, *(const char **)(dword_65230[2] + v2)) )
1678      break;
1679    v2 += 72;
1680    ++v3;
1681    if ( v2 == 1512 )
1682    {
1683      v7 = 0;
1684      goto LABEL_8;
1685    }
1686  }
1687  _android_log_print(4, "HTC Acoustic", "set_audio_effect: match with name %s (%d)", v5, *(_DWORD *)(v4 + 68));
1688  v6 = dword_65230[2] + v2;
1689  if ( *(_DWORD *)(v6 + 68) < 0 )
1690  {
1691    v7 = -22;
1692    _android_log_print(4, "HTC Acoustic", "disabled sound effect\n");
1693  }
1694  else
1695  {
1696    v7 = set_aic3254_ioctl(0x40047321u, v6 + 68);
1697    _android_log_print(4, "HTC Acoustic", "found enabled DSP firmwares and return %d", v7);
1698  }
1699LABEL_8:
1700  if ( v3 == 21 )
1701  {
1702    v7 = -22;
1703    _android_log_print(6, "HTC Acoustic", "cannot found indicated effect mode");
1704  }
1705  return v7;
1706}
1707// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
1708
1709//----- (00002AB8) --------------------------------------------------------
1710bool __fastcall support_amr_wb()
1711{
1712  bool v0; // r4@3
1713  int v1; // r0@8
1714  int v2; // r6@10
1715  int v3; // r0@12
1716  bool result; // r0@14
1717  char v5; // [sp+Ch] [bp-D4h]@2
1718  char s; // [sp+68h] [bp-78h]@1
1719  int v7; // [sp+C4h] [bp-1Ch]@1
1720
1721  v7 = _stack_chk_guard;
1722  memset(&s, 0, 0x5Cu);
1723  property_get("ro.ril.enable.amr.wideband", &s, &unk_3F45);
1724  v0 = atoi(&s) == 1
1725    || (memset(&s, 0, 0x5Cu),
1726        property_get("ro.carrier", &s, &unk_3F45),
1727        sprintf(&v5, "%s.%s", "ro.ril.enable.amr.wideband", &s),
1728        memset(&s, 0, 0x5Cu),
1729        property_get(&v5, &s, &unk_3F45),
1730        atoi(&s) == 1);
1731  if ( open("/system/etc/CodecDSPID_WB.txt", 4096) >= 0 )
1732  {
1733    if ( v0 )
1734    {
1735      v1 = open("/dev/htc-acoustic", 4098);
1736      v0 = v1;
1737      if ( v1 < 0 )
1738      {
1739        _android_log_print(6, "HTC Acoustic", "can't open /dev/htc-acoustic %d", v1);
1740        goto LABEL_14;
1741      }
1742      v2 = ioctl(v1, 0x40047026u, v1);
1743      if ( v2 < 0 )
1744      {
1745        v0 = v2;
1746        _android_log_print(6, "HTC Acoustic", "ACOUSTIC_SET_WB_SAMPLE_RATE fail. %d", v2);
1747        goto LABEL_14;
1748      }
1749      v3 = v0;
1750      v0 = 1;
1751      close(v3);
1752    }
1753  }
1754  else
1755  {
1756    v0 = 0;
1757    _android_log_print(6, "HTC Acoustic", "AMR_WB not supported. %s cannot be opened.", "/system/etc/CodecDSPID_WB.txt");
1758  }
1759  _android_log_print(3, "HTC Acoustic", "%s, support_amr_wb: %d", "int android::support_amr_wb()", v0);
1760LABEL_14:
1761  result = v0;
1762  if ( v7 != _stack_chk_guard )
1763    _stack_chk_fail(v0);
1764  return result;
1765}
1766// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
1767// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
1768// FE0: using guessed type int __fastcall property_get(_DWORD, _DWORD, _DWORD);
1769
1770//----- (00002C30) --------------------------------------------------------
1771int __fastcall android::read_codec_effect_endpoints()
1772{
1773  const char *v0; // r6@1
1774  int v1; // r4@1
1775  int v2; // r0@5
1776  int v3; // r1@7
1777  const char *v4; // r2@7
1778  int v5; // r0@9
1779  int v6; // r3@9
1780  char *v7; // r6@10
1781  int v8; // r8@11
1782  const char *v9; // r9@11
1783  char *v10; // r0@13
1784  char *v11; // r0@14
1785  const char *v12; // r9@14
1786  char *v13; // r0@18
1787  int v14; // r4@19
1788  char *v15; // r0@22
1789  int v16; // r3@22
1790  char *v17; // r0@27
1791  int result; // r0@30
1792  int v19; // [sp+Ch] [bp-142Ch]@11
1793  void *s; // [sp+10h] [bp-1428h]@9
1794  int v21; // [sp+14h] [bp-1424h]@14
1795  int v22; // [sp+18h] [bp-1420h]@9
1796  size_t v23; // [sp+48h] [bp-13F0h]@9
1797  int v24; // [sp+84h] [bp-13B4h]@14
1798  int v25; // [sp+140Ch] [bp-2Ch]@1
1799
1800  v0 = "/system/etc/CodecDSPID_MFG.txt";
1801  v25 = _stack_chk_guard;
1802  v1 = open("/system/etc/CodecDSPID_MFG.txt", 4096);
1803  if ( v1 >= 0 )
1804  {
1805    v3 = (int)"HTC Acoustic";
1806    v4 = "open %s success.";
1807  }
1808  else
1809  {
1810    if ( support_amr_wb() )
1811      v0 = "/system/etc/CodecDSPID_WB.txt";
1812    else
1813      v0 = "/system/etc/CodecDSPID.txt";
1814    v2 = open(v0, 4096);
1815    v1 = v2;
1816    if ( v2 < 0 )
1817    {
1818      _android_log_print(6, "HTC Acoustic", "Fail to open %s %d.", v0, v2);
1819      goto LABEL_30;
1820    }
1821    v3 = (int)"HTC Acoustic";
1822    v4 = "open %s success.";
1823  }
1824  _android_log_print(4, v3, v4, v0);
1825  fstat(v1, (struct stat *)&v22);
1826  s = malloc(v23);
1827  read(v1, s, v23);
1828  v5 = operator new__(1512);
1829  v6 = 0;
1830  dword_65230[2] = v5;
1831  do
1832  {
1833    v7 = (&off_5018)[v6];
1834    v6 += 4;
1835    *(_DWORD *)(v5 + 68) = -1;
1836    *(_DWORD *)v5 = v7;
1837    v5 += 72;
1838  }
1839  while ( v6 != 84 );
1840  v8 = v1;
1841  v9 = (const char *)s;
1842  v19 = 0;
1843  while ( 1 )
1844  {
1845    v10 = strchr(v9, 10);
1846    if ( !v10 )
1847      break;
1848    v21 = (int)(v10 + 1);
1849    memset(&v24, 0, 0x1388u);
1850    memcpy(&v24, v9, v21 - (_DWORD)v9 - 1);
1851    v11 = strtok((char *)&v24, ",");
1852    v12 = v11;
1853    if ( v11 && (unsigned __int8)*v11 != 35 )
1854    {
1855      if ( strcmp(v11, "Header") && strcmp(v12, "HEADER") )
1856      {
1857        ++v19;
1858        v14 = 0;
1859        do
1860        {
1861          if ( !strcmp(v12, (&off_5018)[4 * v14]) )
1862            break;
1863          ++v14;
1864        }
1865        while ( v14 != 21 );
1866        v15 = strtok(0, "\n");
1867        v16 = 1 - (_DWORD)v15;
1868        if ( (unsigned int)v15 > 1 )
1869          v16 = 0;
1870        if ( v14 == 21 )
1871          v16 |= 1u;
1872        if ( !v16 )
1873        {
1874          strcpy((char *)(dword_65230[2] + 72 * v14 + 4), v15);
1875          v17 = strchr((const char *)(72 * v14 + dword_65230[2] + 4), 13);
1876          if ( v17 )
1877            *v17 = 0;
1878        }
1879      }
1880      else
1881      {
1882        v13 = strtok(0, "\n");
1883        _android_log_print(4, "HTC Acoustic", "Codec dsp mapping table version: %s", v13);
1884      }
1885    }
1886    v9 = (const char *)v21;
1887  }
1888  free(s);
1889  close(v8);
1890  v1 = v19;
1891LABEL_30:
1892  result = v1;
1893  if ( v25 != _stack_chk_guard )
1894    _stack_chk_fail(v1);
1895  return result;
1896}
1897// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
1898// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
1899// F98: using guessed type int __fastcall operator new__(_DWORD);
1900// 5018: using guessed type char *off_5018;
1901
1902//----- (00002E94) --------------------------------------------------------
1903signed int __fastcall set_aic3254_parameters()
1904{
1905  signed int result; // r0@2
1906  int v1; // r8@3
1907  char *v2; // r4@5
1908  int v3; // r5@6
1909  char *v4; // r7@7
1910  char *v5; // r0@7
1911  char *v6; // r4@9
1912  char *v7; // r0@9
1913  char *v8; // r1@17
1914  int (__fastcall *v9)(const char *); // r0@17
1915  const char *v10; // r1@21
1916  int v11; // r3@23
1917  signed int v12; // r0@30
1918  int v13; // r1@30
1919  const char *v14; // r2@30
1920  int v15; // r4@31
1921  int v16; // r10@31
1922  signed int v17; // r6@31
1923  int v18; // r9@31
1924  int v19; // r1@32
1925  int v20; // r8@36
1926  signed int v21; // [sp+1Ch] [bp-42Ch]@25
1927  int v22; // [sp+20h] [bp-428h]@25
1928  _BYTE *v23; // [sp+24h] [bp-424h]@25
1929  char v24; // [sp+28h] [bp-420h]@10
1930  char dest; // [sp+2ACh] [bp-19Ch]@7
1931  char v26; // [sp+308h] [bp-140h]@6
1932  char v27; // [sp+364h] [bp-E4h]@6
1933  char s; // [sp+3C0h] [bp-88h]@5
1934  int v29; // [sp+41Ch] [bp-2Ch]@1
1935
1936  v29 = _stack_chk_guard;
1937  if ( !android::support_codec_aic3254((int)&_stack_chk_guard) )
1938  {
1939    result = -1;
1940    goto LABEL_44;
1941  }
1942  v1 = open("/dev/codec_aic3254", 2050, 0);
1943  if ( v1 < 0 )
1944  {
1945    _android_log_print(6, "HTC Acoustic", "cannot open codec aic3254 device %d", v1);
1946    result = -14;
1947    goto LABEL_44;
1948  }
1949  v2 = &s;
1950  memset(&s, 0, 0x5Cu);
1951  if ( property_get("htc.audio.acoustic.parameters", &s, &unk_3F45) <= 0 )
1952  {
1953    memset(&v27, 0, 0x5Cu);
1954    v2 = &v26;
1955    v3 = property_get("ro.carrier", &v27, &unk_3F45);
1956    strcpy(&v26, "/system/etc/AIC3254_REG.csv");
1957    if ( v3 > 0 )
1958    {
1959      v4 = strtok(&v26, ".");
1960      v5 = strtok(0, ".");
1961      sprintf(&dest, "%s_%s.%s", v4, &v27, v5);
1962      memset(&v26, 0, 0x5Cu);
1963      strcpy(&v26, &dest);
1964    }
1965  }
1966  if ( support_back_mic() )
1967  {
1968    v6 = strtok(v2, ".");
1969    v7 = strtok(0, ".");
1970    sprintf(&dest, "%s_DualMic.%s", v6, v7);
1971  }
1972  if ( !android::get_acoust_tables((int)&v24) && v24 )
1973    sprintf(&dest, "%s%s", "/system/etc/", &v24);
1974  if ( sub_2728((int (__fastcall *)(_DWORD))sub_223C, "/system/etc/AIC3254_REG_MFG.csv") < 0 )
1975  {
1976    if ( strstr(&dest, ".txt") || strstr(&dest, ".TXT") )
1977    {
1978      v8 = &dest;
1979      v9 = sub_2038;
1980    }
1981    else
1982    {
1983      v9 = sub_223C;
1984      v8 = &dest;
1985    }
1986    if ( sub_2728((int (__fastcall *)(_DWORD))v9, v8) < 0 )
1987    {
1988      v10 = support_back_mic() ? "/system/etc/AIC3254_REG_DualMic.csv" : "/system/etc/AIC3254_REG.csv";
1989      strcpy(&dest, v10);
1990      v11 = sub_2728((int (__fastcall *)(_DWORD))sub_223C, &dest);
1991      if ( v11 < 0 )
1992      {
1993        _android_log_print(6, "HTC Acoustic", "read AIC3254 para from file failed %d", v11);
1994        goto LABEL_29;
1995      }
1996    }
1997  }
1998  else
1999  {
2000    _android_log_print(4, "HTC Acoustic", "loading MFG CSV file: %s", "/system/etc/AIC3254_REG_MFG.csv");
2001  }
2002  v21 = 64;
2003  v22 = 1024;
2004  v23 = &unk_5228;
2005  if ( ioctl(v1, 0x40047310u) < 0 )
2006    _android_log_print(6, "HTC Acoustic", "failed to update uplink setting");
2007  v21 = 64;
2008  v22 = 1024;
2009  v23 = &byte_34DA8[1152];
2010  if ( ioctl(v1, 0x40047311u) < 0 )
2011    _android_log_print(6, "HTC Acoustic", "failed to update downlink setting");
2012LABEL_29:
2013  if ( android::read_codec_effect_endpoints() >= 0 )
2014  {
2015    v15 = 0;
2016    v16 = 0;
2017    unk_5210 = 0;
2018    v17 = 0;
2019    v18 = v1;
2020    do
2021    {
2022      v19 = dword_65230[2] + v15;
2023      if ( *(_BYTE *)(dword_65230[2] + v15 + 4) )
2024      {
2025        if ( v17 <= 31 )
2026        {
2027          unk_521C = &dword_65230[12288 * v17 + 3];
2028          v20 = sub_2728((int (__fastcall *)(_DWORD))sub_1E10, (const char *)(v19 + 4));
2029          if ( v20 >= 0 )
2030          {
2031            unk_5210 |= 1 << v16;
2032            *(_DWORD *)(dword_65230[2] + v15 + 68) = v17++;
2033            _android_log_print(
2034              4,
2035              "HTC Acoustic",
2036              "(%s,%s) with index %d",
2037              *(_DWORD *)(dword_65230[2] + v15),
2038              dword_65230[2] + v15 + 4,
2039              *(_DWORD *)(dword_65230[2] + v15 + 68));
2040            *(_BYTE *)(unk_521C + 1) = BYTE1(v20);
2041            *(_BYTE *)(unk_521C + 2) = v20;
2042          }
2043          else
2044          {
2045            _android_log_print(6, "HTC Acoustic", "read AIC3254 para from file failed %d", v20);
2046          }
2047        }
2048        else
2049        {
2050          _android_log_print(6, "HTC Acoustic", "achieve maximum limitation of DSP");
2051        }
2052      }
2053      else
2054      {
2055        *(_DWORD *)(v19 + 68) = *(_BYTE *)(dword_65230[2] + v15 + 4) - 1;
2056      }
2057      ++v16;
2058      v15 += 72;
2059    }
2060    while ( v16 != 21 );
2061    v1 = v18;
2062    _android_log_print(4, "HTC Acoustic", "htc_effect_mask = 0x%lx", unk_5210);
2063    v21 = v17;
2064    v22 = 16384;
2065    v23 = &dword_65230[3];
2066    if ( ioctl(v18, 0x40047320u) >= 0 )
2067      goto LABEL_43;
2068    v12 = 6;
2069    v13 = (int)"HTC Acoustic";
2070    v14 = "failed to update minidsp paras";
2071  }
2072  else
2073  {
2074    v12 = 6;
2075    v13 = (int)"HTC Acoustic";
2076    v14 = "cannot mapping codec endpoint";
2077  }
2078  _android_log_print(v12, v13, v14);
2079LABEL_43:
2080  close(v1);
2081  result = 0;
2082LABEL_44:
2083  if ( v29 != _stack_chk_guard )
2084    _stack_chk_fail(result);
2085  return result;
2086}
2087// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
2088// F68: using guessed type int __fastcall _stack_chk_fail(_DWORD);
2089// FE0: using guessed type int __fastcall property_get(_DWORD, _DWORD, _DWORD);
2090// 104A: using guessed type int();
2091
2092//----- (000032D4) --------------------------------------------------------
2093int __fastcall reinit_codec_effect()
2094{
2095  int v0; // r4@3
2096  int v1; // r2@3
2097  int v2; // r3@4
2098  int v3; // r1@4
2099  int v4; // r8@6
2100
2101  if ( android::read_codec_effect_endpoints() >= 0 )
2102  {
2103    v0 = 0;
2104    v1 = 0;
2105    do
2106    {
2107      v2 = dword_65230[2];
2108      v3 = dword_65230[2] + v0;
2109      if ( *(_BYTE *)(dword_65230[2] + v0 + 4) )
2110      {
2111        *(_DWORD *)(v3 + 68) = v1;
2112        v4 = v1 + 1;
2113        _android_log_print(4, "HTC Acoustic", "(%s,%s) with index %d", *(_DWORD *)(v2 + v0), v3 + 4, v1);
2114        v1 = v4;
2115      }
2116      else
2117      {
2118        *(_DWORD *)(v3 + 68) = -1;
2119      }
2120      v0 += 72;
2121    }
2122    while ( v0 != 1512 );
2123  }
2124  else
2125  {
2126    _android_log_print(6, "HTC Acoustic", "cannot mapping codec endpoint");
2127  }
2128  return 0;
2129}
2130// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
2131
2132//----- (00003350) --------------------------------------------------------
2133bool __fastcall android::parse_adie_para(char *a1, int a2)
2134{
2135  int v2; // r10@1
2136  char *v3; // r0@1
2137  int v4; // r3@1
2138  __int32 v5; // r7@2
2139  char *v6; // r6@2
2140  void *v7; // r4@2
2141  bool v8; // r5@2
2142  int v9; // r7@5
2143  int v10; // r8@5
2144  char *v11; // r0@5
2145  __int32 v12; // r0@7
2146  __int32 v13; // r9@7
2147  char *v14; // r0@7
2148  char v15; // zf@7
2149  int v16; // r9@7
2150  __int32 v17; // r11@9
2151  char *v18; // r0@9
2152  __int32 v19; // ST08_4@9
2153  char *v20; // r0@9
2154  __int32 v21; // r11@9
2155  __int32 v22; // r11@8
2156  char *v23; // r0@12
2157  char *i; // r6@12
2158  char *v25; // r0@24
2159  char *s; // [sp+Ch] [bp-34h]@5
2160  __int16 delim; // [sp+14h] [bp-2Ch]@1
2161
2162  v2 = a2;
2163  delim = 44;
2164  v3 = strtok(a1, (const char *)&delim);
2165  v4 = (unsigned __int8)*v3;
2166  if ( (unsigned __int8)(v4 - 48) > 9u )
2167  {
2168    v8 = v4 == 72;
2169    if ( v4 == 104 )
2170      v8 |= 1u;
2171    if ( v8 )
2172    {
2173      v25 = strtok(0, (const char *)&delim);
2174      v8 = 0;
2175      _android_log_print(3, "HTC Acoustic", "%s", v25);
2176    }
2177  }
2178  else
2179  {
2180    v5 = strtol(v3, 0, 10);
2181    v6 = strtok(0, (const char *)&delim);
2182    v7 = malloc(0x4Cu);
2183    v8 = (bool)v7;
2184    strncpy((char *)v7 + 4, v6, 0x40u);
2185    _android_log_print(3, "HTC Acoustic", "[%d] dev_name = %s", v5, v6);
2186    if ( strstr(v6, "voice") )
2187      *((_DWORD *)v7 + 18) = 1;
2188    else
2189      *((_DWORD *)v7 + 18) = 0;
2190    v9 = 0;
2191    v10 = 0;
2192    s = strtok(0, (const char *)&delim);
2193    v11 = strtok(0, (const char *)&delim);
2194    while ( v11 && (unsigned int)(unsigned __int8)*v11 - 48 <= 9 )
2195    {
2196      v12 = strtol(v11, 0, 16);
2197      v13 = v12;
2198      *(_DWORD *)(v2 + v9) = v12;
2199      v14 = strtok(0, (const char *)&delim);
2200      v15 = v13 == 1;
2201      v16 = v2 + v9;
2202      if ( v15 )
2203      {
2204        v17 = strtol(v14, 0, 16);
2205        v18 = strtok(0, (const char *)&delim);
2206        v19 = (strtol(v18, 0, 16) << 8) | (v17 << 16);
2207        v20 = strtok(0, (const char *)&delim);
2208        v21 = strtol(v20, 0, 16);
2209        v11 = strtok(0, (const char *)&delim);
2210        *(_DWORD *)(v16 + 4) = v19 | v21;
2211      }
2212      else
2213      {
2214        v22 = strtol(v14, 0, 16);
2215        v11 = strtok(0, (const char *)&delim);
2216        *(_DWORD *)(v16 + 4) = v22;
2217      }
2218      ++v10;
2219      v9 += 8;
2220    }
2221    *(_DWORD *)v7 = v10;
2222    v23 = strtok(s, "_");
2223    *((_DWORD *)v7 + 17) = 0;
2224    for ( i = v23; i; i = strtok(0, "_") )
2225    {
2226      if ( (unsigned int)(unsigned __int8)*i - 48 <= 9 )
2227      {
2228        _android_log_print(4, "HTC Acoustic", "parse freq %s", i);
2229        *((_DWORD *)v7 + 17) = strtol(i, 0, 10);
2230        break;
2231      }
2232    }
2233    _android_log_print(4, "HTC Acoustic", "act_size=%d, freq=%d", *(_DWORD *)v7, *((_DWORD *)v7 + 17));
2234  }
2235  return v8;
2236}
2237// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
2238
2239//----- (00003544) --------------------------------------------------------
2240signed int __fastcall sub_3544(int a1)
2241{
2242  const char *v1; // r7@2
2243  int v2; // r4@4
2244  int v3; // r0@5
2245  int *v4; // r0@7
2246  char *v5; // r5@7
2247  int v6; // r0@7
2248  int v7; // r1@7
2249  const char *v8; // r2@7
2250  int v9; // r3@7
2251  signed int v10; // r0@7
2252  void *v11; // r3@7
2253  signed int result; // r0@9
2254  int *v13; // r0@11
2255  char *v14; // r5@11
2256  int v15; // r0@11
2257  char *v16; // r1@11
2258  int v17; // r0@13
2259  int v18; // r7@14
2260  const char *v19; // r4@14
2261  int v20; // r6@14
2262  int v21; // r7@15
2263  void *v22; // r4@15
2264  int v23; // r3@16
2265  char *v24; // r0@21
2266  char *v25; // r7@21
2267  char *v26; // [sp+0h] [bp-A8h]@7
2268  int offset; // [sp+4h] [bp-A4h]@7
2269  int v28; // [sp+8h] [bp-A0h]@14
2270  void *s; // [sp+Ch] [bp-9Ch]@10
2271  void *addr; // [sp+10h] [bp-98h]@12
2272  int fd; // [sp+14h] [bp-94h]@1
2273  char v32; // [sp+18h] [bp-90h]@6
2274  size_t len; // [sp+48h] [bp-60h]@10
2275
2276  fd = a1;
2277  if ( support_audience(a1) )
2278    v1 = "/system/etc/AdieHWCodec_WA.csv";
2279  else
2280    v1 = "/system/etc/AdieHWCodec.csv";
2281  v2 = open(v1, 0);
2282  if ( v2 < 0 )
2283  {
2284    v3 = _android_log_print(6, "HTC Acoustic", "Fail to open %s", v1);
2285    return *(_DWORD *)_errno(v3);
2286  }
2287  _android_log_print(4, "HTC Acoustic", "Open %s success.", v1);
2288  if ( fstat(v2, (struct stat *)&v32) < 0 )
2289  {
2290    v4 = (int *)((int (*)(void))_errno)();
2291    v5 = strerror(*v4);
2292    v6 = ((int (*)(void))_errno)();
2293    v7 = (int)"HTC Acoustic";
2294    v8 = "Failed to stat %s: %s (%d)";
2295    v9 = *(_DWORD *)v6;
2296    v10 = 6;
2297    v26 = v5;
2298    offset = v9;
2299    v11 = (void *)v1;
2300LABEL_8:
2301    _android_log_print(v10, v7, v8, v11, v26, offset);
2302    v3 = close(v2);
2303    return *(_DWORD *)_errno(v3);
2304  }
2305  ioctl(fd, 0x4004700Fu, &len);
2306  s = mmap(0, len, 3, 2, v2, 0);
2307  if ( s == (void *)-1 )
2308  {
2309    v13 = (int *)((int (*)(void))_errno)();
2310    v14 = strerror(*v13);
2311    v15 = ((int (*)(void))_errno)();
2312    v11 = v14;
2313    v8 = "failed to mmap parameters file: %s (%d)";
2314    v16 = *(char **)v15;
2315    v10 = 6;
2316    v26 = v16;
2317    v7 = (int)"HTC Acoustic";
2318    goto LABEL_8;
2319  }
2320  addr = mmap(0, 4 * _page_size, 3, 1, fd, 0);
2321  if ( addr == (void *)-1 )
2322  {
2323    v17 = ((int (*)(void))_errno)();
2324    _android_log_print(6, "HTC Acoustic", "Failed on mmap %d", *(_DWORD *)v17);
2325    close(v2);
2326    result = -14;
2327  }
2328  else
2329  {
2330    v18 = v2;
2331    v19 = (const char *)s;
2332    v28 = (int)addr;
2333    v20 = v18;
2334    while ( 1 )
2335    {
2336      v24 = strchr(v19, 10);
2337      v25 = v24;
2338      if ( !v24 )
2339        break;
2340      *v24 = 0;
2341      v21 = (int)(v24 + 1);
2342      v22 = (void *)android::parse_adie_para((char *)v19, v28);
2343      if ( v22 )
2344      {
2345        v23 = ioctl(fd, 0x40047018u, v22);
2346        if ( v23 >= 0 )
2347          _android_log_print(3, "HTC Acoustic", "ioctl ACOUSTIC_UPDATE_ADIE success", v23);
2348        else
2349          _android_log_print(3, "HTC Acoustic", "ioctl ACOUSTIC_UPDATE_ADIE failed %d", v23);
2350        v28 += 8 * *(_DWORD *)v22;
2351        free(v22);
2352      }
2353      v19 = (const char *)v21;
2354    }
2355    _android_log_print(4, "HTC Acoustic", "Success on updating adie setting");
2356    munmap(addr, 4 * _page_size);
2357    munmap(s, len);
2358    close(v20);
2359    result = (signed int)v25;
2360  }
2361  return result;
2362}
2363// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
2364// F08: using guessed type int __fastcall _errno(_DWORD);
2365
2366//----- (00003760) --------------------------------------------------------
2367int __fastcall set_acoustic_parameters()
2368{
2369  int v0; // r0@1
2370  int v1; // r4@1
2371  signed int v2; // r5@3
2372  const char *v3; // r2@4
2373  int v4; // r0@8
2374
2375  _android_log_print(4, "HTC Acoustic", "libhtc_acoustic.so(8x60 platform) version 1.0.0.5");
2376  v0 = open("/dev/htc-acoustic", 4098);
2377  v1 = v0;
2378  if ( v0 >= 0 )
2379  {
2380    v2 = sub_3544(v0);
2381    if ( v2 >= 0 )
2382    {
2383      v2 = android::read_bt_endpoints();
2384      if ( v2 >= 0 )
2385      {
2386LABEL_8:
2387        v4 = v1;
2388        v1 = v2;
2389        close(v4);
2390        return v1;
2391      }
2392      v3 = "read BT headset ID from file failed %d";
2393    }
2394    else
2395    {
2396      v3 = "read ADIE para from file failed %d";
2397    }
2398    _android_log_print(6, "HTC Acoustic", v3, v2);
2399    goto LABEL_8;
2400  }
2401  _android_log_print(6, "HTC Acoustic", "can't open /dev/htc-acoustic %d", v0);
2402  return v1;
2403}
2404// EB4: using guessed type int _android_log_print(_DWORD, _DWORD, const char *, ...);
2405
2406//----- (000037E0) --------------------------------------------------------
2407int __fastcall sub_37E0()
2408{
2409  pthread_mutex_init((pthread_mutex_t *)&dword_65230[1], 0);
2410  return _aeabi_atexit(&dword_65230[1], sub_105C, &_dso_handle);
2411}
2412// 101C: using guessed type int __fastcall _aeabi_atexit(_DWORD, _DWORD, _DWORD);
2413
2414//----- (00003818) --------------------------------------------------------
2415int __fastcall sub_3818()
2416{
2417  return sub_37E0();
2418}
2419
2420// ALL OK, 31 function(s) have been successfully decompiled