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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
trans_16.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：18k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

trans_16.c：源码内容
  1. /*
  2.  *  linux/drivers/sound/dmasound/trans_16.c
  3.  *
  4.  *  16 bit translation routines.  Only used by Power mac at present.
  5.  *
  6.  *  See linux/drivers/sound/dmasound/dmasound_core.c for copyright and
  7.  *  history prior to 08/02/2001.
  8.  *
  9.  *  08/02/2001 Iain Sandoe
  10.  * split from dmasound_awacs.c
  11.  */
  13. #include <linux/soundcard.h>
  14. #include <asm/uaccess.h>
  15. #include "dmasound.h"
  17. static short dmasound_alaw2dma16[] ;
  18. static short dmasound_ulaw2dma16[] ;
  20. static ssize_t pmac_ct_law(const u_char *userPtr, size_t userCount,
  21.    u_char frame[], ssize_t *frameUsed,
  22.    ssize_t frameLeft);
  23. static ssize_t pmac_ct_s8(const u_char *userPtr, size_t userCount,
  24.   u_char frame[], ssize_t *frameUsed,
  25.   ssize_t frameLeft);
  26. static ssize_t pmac_ct_u8(const u_char *userPtr, size_t userCount,
  27.   u_char frame[], ssize_t *frameUsed,
  28.   ssize_t frameLeft);
  29. static ssize_t pmac_ct_s16(const u_char *userPtr, size_t userCount,
  30.    u_char frame[], ssize_t *frameUsed,
  31.    ssize_t frameLeft);
  32. static ssize_t pmac_ct_u16(const u_char *userPtr, size_t userCount,
  33.    u_char frame[], ssize_t *frameUsed,
  34.    ssize_t frameLeft);
  36. static ssize_t pmac_ctx_law(const u_char *userPtr, size_t userCount,
  37.     u_char frame[], ssize_t *frameUsed,
  38.     ssize_t frameLeft);
  39. static ssize_t pmac_ctx_s8(const u_char *userPtr, size_t userCount,
  40.    u_char frame[], ssize_t *frameUsed,
  41.    ssize_t frameLeft);
  42. static ssize_t pmac_ctx_u8(const u_char *userPtr, size_t userCount,
  43.    u_char frame[], ssize_t *frameUsed,
  44.    ssize_t frameLeft);
  45. static ssize_t pmac_ctx_s16(const u_char *userPtr, size_t userCount,
  46.     u_char frame[], ssize_t *frameUsed,
  47.     ssize_t frameLeft);
  48. static ssize_t pmac_ctx_u16(const u_char *userPtr, size_t userCount,
  49.     u_char frame[], ssize_t *frameUsed,
  50.     ssize_t frameLeft);
  52. static ssize_t pmac_ct_s16_read(const u_char *userPtr, size_t userCount,
  53.    u_char frame[], ssize_t *frameUsed,
  54.    ssize_t frameLeft);
  55. static ssize_t pmac_ct_u16_read(const u_char *userPtr, size_t userCount,
  56.    u_char frame[], ssize_t *frameUsed,
  57.    ssize_t frameLeft);
  59. /*** Translations ************************************************************/
  61. extern int expand_bal; /* Balance factor for expanding (not volume!) */
  62. static int expand_data; /* Data for expanding */
  64. static ssize_t pmac_ct_law(const u_char *userPtr, size_t userCount,
  65.    u_char frame[], ssize_t *frameUsed,
  66.    ssize_t frameLeft)
  67. {
  68. short *table = dmasound.soft.format == AFMT_MU_LAW
  69. ? dmasound_ulaw2dma16 : dmasound_alaw2dma16;
  70. ssize_t count, used;
  71. short *p = (short *) &frame[*frameUsed];
  72. int val, stereo = dmasound.soft.stereo;
  74. frameLeft >>= 2;
  75. if (stereo)
  76. userCount >>= 1;
  77. used = count = min_t(unsigned long, userCount, frameLeft);
  78. while (count > 0) {
  79. u_char data;
  80. if (get_user(data, userPtr++))
  81. return -EFAULT;
  82. val = table[data];
  83. *p++ = val;
  84. if (stereo) {
  85. if (get_user(data, userPtr++))
  86. return -EFAULT;
  87. val = table[data];
  88. }
  89. *p++ = val;
  90. count--;
  91. }
  92. *frameUsed += used * 4;
  93. return stereo? used * 2: used;
  94. }
  97. static ssize_t pmac_ct_s8(const u_char *userPtr, size_t userCount,
  98.   u_char frame[], ssize_t *frameUsed,
  99.   ssize_t frameLeft)
  100. {
  101. ssize_t count, used;
  102. short *p = (short *) &frame[*frameUsed];
  103. int val, stereo = dmasound.soft.stereo;
  105. frameLeft >>= 2;
  106. if (stereo)
  107. userCount >>= 1;
  108. used = count = min_t(unsigned long, userCount, frameLeft);
  109. while (count > 0) {
  110. u_char data;
  111. if (get_user(data, userPtr++))
  112. return -EFAULT;
  113. val = data << 8;
  114. *p++ = val;
  115. if (stereo) {
  116. if (get_user(data, userPtr++))
  117. return -EFAULT;
  118. val = data << 8;
  119. }
  120. *p++ = val;
  121. count--;
  122. }
  123. *frameUsed += used * 4;
  124. return stereo? used * 2: used;
  125. }
  128. static ssize_t pmac_ct_u8(const u_char *userPtr, size_t userCount,
  129.   u_char frame[], ssize_t *frameUsed,
  130.   ssize_t frameLeft)
  131. {
  132. ssize_t count, used;
  133. short *p = (short *) &frame[*frameUsed];
  134. int val, stereo = dmasound.soft.stereo;
  136. frameLeft >>= 2;
  137. if (stereo)
  138. userCount >>= 1;
  139. used = count = min_t(unsigned long, userCount, frameLeft);
  140. while (count > 0) {
  141. u_char data;
  142. if (get_user(data, userPtr++))
  143. return -EFAULT;
  144. val = (data ^ 0x80) << 8;
  145. *p++ = val;
  146. if (stereo) {
  147. if (get_user(data, userPtr++))
  148. return -EFAULT;
  149. val = (data ^ 0x80) << 8;
  150. }
  151. *p++ = val;
  152. count--;
  153. }
  154. *frameUsed += used * 4;
  155. return stereo? used * 2: used;
  156. }
  159. static ssize_t pmac_ct_s16(const u_char *userPtr, size_t userCount,
  160.    u_char frame[], ssize_t *frameUsed,
  161.    ssize_t frameLeft)
  162. {
  163. ssize_t count, used;
  164. int stereo = dmasound.soft.stereo;
  165. short *fp = (short *) &frame[*frameUsed];
  167. frameLeft >>= 2;
  168. userCount >>= (stereo? 2: 1);
  169. used = count = min_t(unsigned long, userCount, frameLeft);
  170. if (!stereo) {
  171. short *up = (short *) userPtr;
  172. while (count > 0) {
  173. short data;
  174. if (get_user(data, up++))
  175. return -EFAULT;
  176. *fp++ = data;
  177. *fp++ = data;
  178. count--;
  179. }
  180. } else {
  181. if (copy_from_user(fp, userPtr, count * 4))
  182. return -EFAULT;
  183. }
  184. *frameUsed += used * 4;
  185. return stereo? used * 4: used * 2;
  186. }
  188. static ssize_t pmac_ct_u16(const u_char *userPtr, size_t userCount,
  189.    u_char frame[], ssize_t *frameUsed,
  190.    ssize_t frameLeft)
  191. {
  192. ssize_t count, used;
  193. int mask = (dmasound.soft.format == AFMT_U16_LE? 0x0080: 0x8000);
  194. int stereo = dmasound.soft.stereo;
  195. short *fp = (short *) &frame[*frameUsed];
  196. short *up = (short *) userPtr;
  198. frameLeft >>= 2;
  199. userCount >>= (stereo? 2: 1);
  200. used = count = min_t(unsigned long, userCount, frameLeft);
  201. while (count > 0) {
  202. short data;
  203. if (get_user(data, up++))
  204. return -EFAULT;
  205. data ^= mask;
  206. *fp++ = data;
  207. if (stereo) {
  208. if (get_user(data, up++))
  209. return -EFAULT;
  210. data ^= mask;
  211. }
  212. *fp++ = data;
  213. count--;
  214. }
  215. *frameUsed += used * 4;
  216. return stereo? used * 4: used * 2;
  217. }
  220. static ssize_t pmac_ctx_law(const u_char *userPtr, size_t userCount,
  221.     u_char frame[], ssize_t *frameUsed,
  222.     ssize_t frameLeft)
  223. {
  224. unsigned short *table = (unsigned short *)
  225. (dmasound.soft.format == AFMT_MU_LAW
  226.  ? dmasound_ulaw2dma16 : dmasound_alaw2dma16);
  227. unsigned int data = expand_data;
  228. unsigned int *p = (unsigned int *) &frame[*frameUsed];
  229. int bal = expand_bal;
  230. int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
  231. int utotal, ftotal;
  232. int stereo = dmasound.soft.stereo;
  234. frameLeft >>= 2;
  235. if (stereo)
  236. userCount >>= 1;
  237. ftotal = frameLeft;
  238. utotal = userCount;
  239. while (frameLeft) {
  240. u_char c;
  241. if (bal < 0) {
  242. if (userCount == 0)
  243. break;
  244. if (get_user(c, userPtr++))
  245. return -EFAULT;
  246. data = table[c];
  247. if (stereo) {
  248. if (get_user(c, userPtr++))
  249. return -EFAULT;
  250. data = (data << 16) + table[c];
  251. } else
  252. data = (data << 16) + data;
  253. userCount--;
  254. bal += hSpeed;
  255. }
  256. *p++ = data;
  257. frameLeft--;
  258. bal -= sSpeed;
  259. }
  260. expand_bal = bal;
  261. expand_data = data;
  262. *frameUsed += (ftotal - frameLeft) * 4;
  263. utotal -= userCount;
  264. return stereo? utotal * 2: utotal;
  265. }
  267. static ssize_t pmac_ctx_s8(const u_char *userPtr, size_t userCount,
  268.    u_char frame[], ssize_t *frameUsed,
  269.    ssize_t frameLeft)
  270. {
  271. unsigned int *p = (unsigned int *) &frame[*frameUsed];
  272. unsigned int data = expand_data;
  273. int bal = expand_bal;
  274. int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
  275. int stereo = dmasound.soft.stereo;
  276. int utotal, ftotal;
  278. frameLeft >>= 2;
  279. if (stereo)
  280. userCount >>= 1;
  281. ftotal = frameLeft;
  282. utotal = userCount;
  283. while (frameLeft) {
  284. u_char c;
  285. if (bal < 0) {
  286. if (userCount == 0)
  287. break;
  288. if (get_user(c, userPtr++))
  289. return -EFAULT;
  290. data = c << 8;
  291. if (stereo) {
  292. if (get_user(c, userPtr++))
  293. return -EFAULT;
  294. data = (data << 16) + (c << 8);
  295. } else
  296. data = (data << 16) + data;
  297. userCount--;
  298. bal += hSpeed;
  299. }
  300. *p++ = data;
  301. frameLeft--;
  302. bal -= sSpeed;
  303. }
  304. expand_bal = bal;
  305. expand_data = data;
  306. *frameUsed += (ftotal - frameLeft) * 4;
  307. utotal -= userCount;
  308. return stereo? utotal * 2: utotal;
  309. }
  312. static ssize_t pmac_ctx_u8(const u_char *userPtr, size_t userCount,
  313.    u_char frame[], ssize_t *frameUsed,
  314.    ssize_t frameLeft)
  315. {
  316. unsigned int *p = (unsigned int *) &frame[*frameUsed];
  317. unsigned int data = expand_data;
  318. int bal = expand_bal;
  319. int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
  320. int stereo = dmasound.soft.stereo;
  321. int utotal, ftotal;
  323. frameLeft >>= 2;
  324. if (stereo)
  325. userCount >>= 1;
  326. ftotal = frameLeft;
  327. utotal = userCount;
  328. while (frameLeft) {
  329. u_char c;
  330. if (bal < 0) {
  331. if (userCount == 0)
  332. break;
  333. if (get_user(c, userPtr++))
  334. return -EFAULT;
  335. data = (c ^ 0x80) << 8;
  336. if (stereo) {
  337. if (get_user(c, userPtr++))
  338. return -EFAULT;
  339. data = (data << 16) + ((c ^ 0x80) << 8);
  340. } else
  341. data = (data << 16) + data;
  342. userCount--;
  343. bal += hSpeed;
  344. }
  345. *p++ = data;
  346. frameLeft--;
  347. bal -= sSpeed;
  348. }
  349. expand_bal = bal;
  350. expand_data = data;
  351. *frameUsed += (ftotal - frameLeft) * 4;
  352. utotal -= userCount;
  353. return stereo? utotal * 2: utotal;
  354. }
  357. static ssize_t pmac_ctx_s16(const u_char *userPtr, size_t userCount,
  358.     u_char frame[], ssize_t *frameUsed,
  359.     ssize_t frameLeft)
  360. {
  361. unsigned int *p = (unsigned int *) &frame[*frameUsed];
  362. unsigned int data = expand_data;
  363. unsigned short *up = (unsigned short *) userPtr;
  364. int bal = expand_bal;
  365. int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
  366. int stereo = dmasound.soft.stereo;
  367. int utotal, ftotal;
  369. frameLeft >>= 2;
  370. userCount >>= (stereo? 2: 1);
  371. ftotal = frameLeft;
  372. utotal = userCount;
  373. while (frameLeft) {
  374. unsigned short c;
  375. if (bal < 0) {
  376. if (userCount == 0)
  377. break;
  378. if (get_user(data, up++))
  379. return -EFAULT;
  380. if (stereo) {
  381. if (get_user(c, up++))
  382. return -EFAULT;
  383. data = (data << 16) + c;
  384. } else
  385. data = (data << 16) + data;
  386. userCount--;
  387. bal += hSpeed;
  388. }
  389. *p++ = data;
  390. frameLeft--;
  391. bal -= sSpeed;
  392. }
  393. expand_bal = bal;
  394. expand_data = data;
  395. *frameUsed += (ftotal - frameLeft) * 4;
  396. utotal -= userCount;
  397. return stereo? utotal * 4: utotal * 2;
  398. }
  401. static ssize_t pmac_ctx_u16(const u_char *userPtr, size_t userCount,
  402.     u_char frame[], ssize_t *frameUsed,
  403.     ssize_t frameLeft)
  404. {
  405. int mask = (dmasound.soft.format == AFMT_U16_LE? 0x0080: 0x8000);
  406. unsigned int *p = (unsigned int *) &frame[*frameUsed];
  407. unsigned int data = expand_data;
  408. unsigned short *up = (unsigned short *) userPtr;
  409. int bal = expand_bal;
  410. int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
  411. int stereo = dmasound.soft.stereo;
  412. int utotal, ftotal;
  414. frameLeft >>= 2;
  415. userCount >>= (stereo? 2: 1);
  416. ftotal = frameLeft;
  417. utotal = userCount;
  418. while (frameLeft) {
  419. unsigned short c;
  420. if (bal < 0) {
  421. if (userCount == 0)
  422. break;
  423. if (get_user(data, up++))
  424. return -EFAULT;
  425. data ^= mask;
  426. if (stereo) {
  427. if (get_user(c, up++))
  428. return -EFAULT;
  429. data = (data << 16) + (c ^ mask);
  430. } else
  431. data = (data << 16) + data;
  432. userCount--;
  433. bal += hSpeed;
  434. }
  435. *p++ = data;
  436. frameLeft--;
  437. bal -= sSpeed;
  438. }
  439. expand_bal = bal;
  440. expand_data = data;
  441. *frameUsed += (ftotal - frameLeft) * 4;
  442. utotal -= userCount;
  443. return stereo? utotal * 4: utotal * 2;
  444. }
  446. /* data in routines... */
  448. static ssize_t pmac_ct_s8_read(const u_char *userPtr, size_t userCount,
  449.   u_char frame[], ssize_t *frameUsed,
  450.   ssize_t frameLeft)
  451. {
  452. ssize_t count, used;
  453. short *p = (short *) &frame[*frameUsed];
  454. int val, stereo = dmasound.soft.stereo;
  456. frameLeft >>= 2;
  457. if (stereo)
  458. userCount >>= 1;
  459. used = count = min_t(unsigned long, userCount, frameLeft);
  460. while (count > 0) {
  461. u_char data;
  463. val = *p++;
  464. data = val >> 8;
  465. if (put_user(data, (u_char *)userPtr++))
  466. return -EFAULT;
  467. if (stereo) {
  468. val = *p;
  469. data = val >> 8;
  470. if (put_user(data, (u_char *)userPtr++))
  471. return -EFAULT;
  472. }
  473. p++;
  474. count--;
  475. }
  476. *frameUsed += used * 4;
  477. return stereo? used * 2: used;
  478. }
  481. static ssize_t pmac_ct_u8_read(const u_char *userPtr, size_t userCount,
  482.   u_char frame[], ssize_t *frameUsed,
  483.   ssize_t frameLeft)
  484. {
  485. ssize_t count, used;
  486. short *p = (short *) &frame[*frameUsed];
  487. int val, stereo = dmasound.soft.stereo;
  489. frameLeft >>= 2;
  490. if (stereo)
  491. userCount >>= 1;
  492. used = count = min_t(unsigned long, userCount, frameLeft);
  493. while (count > 0) {
  494. u_char data;
  496. val = *p++;
  497. data = (val >> 8) ^ 0x80;
  498. if (put_user(data, (u_char *)userPtr++))
  499. return -EFAULT;
  500. if (stereo) {
  501. val = *p;
  502. data = (val >> 8) ^ 0x80;
  503. if (put_user(data, (u_char *)userPtr++))
  504. return -EFAULT;
  505. }
  506. p++;
  507. count--;
  508. }
  509. *frameUsed += used * 4;
  510. return stereo? used * 2: used;
  511. }
  513. static ssize_t pmac_ct_s16_read(const u_char *userPtr, size_t userCount,
  514.    u_char frame[], ssize_t *frameUsed,
  515.    ssize_t frameLeft)
  516. {
  517. ssize_t count, used;
  518. int stereo = dmasound.soft.stereo;
  519. short *fp = (short *) &frame[*frameUsed];
  521. frameLeft >>= 2;
  522. userCount >>= (stereo? 2: 1);
  523. used = count = min_t(unsigned long, userCount, frameLeft);
  524. if (!stereo) {
  525. short *up = (short *) userPtr;
  526. while (count > 0) {
  527. short data;
  528. data = *fp;
  529. if (put_user(data, up++))
  530. return -EFAULT;
  531. fp+=2;
  532. count--;
  533. }
  534. } else {
  535. if (copy_to_user((u_char *)userPtr, fp, count * 4))
  536. return -EFAULT;
  537. }
  538. *frameUsed += used * 4;
  539. return stereo? used * 4: used * 2;
  540. }
  542. static ssize_t pmac_ct_u16_read(const u_char *userPtr, size_t userCount,
  543.    u_char frame[], ssize_t *frameUsed,
  544.    ssize_t frameLeft)
  545. {
  546. ssize_t count, used;
  547. int mask = (dmasound.soft.format == AFMT_U16_LE? 0x0080: 0x8000);
  548. int stereo = dmasound.soft.stereo;
  549. short *fp = (short *) &frame[*frameUsed];
  550. short *up = (short *) userPtr;
  552. frameLeft >>= 2;
  553. userCount >>= (stereo? 2: 1);
  554. used = count = min_t(unsigned long, userCount, frameLeft);
  555. while (count > 0) {
  556. int data;
  558. data = *fp++;
  559. data ^= mask;
  560. if (put_user(data, up++))
  561. return -EFAULT;
  562. if (stereo) {
  563. data = *fp;
  564. data ^= mask;
  565. if (put_user(data, up++))
  566. return -EFAULT;
  567. }
  568. fp++;
  569. count--;
  570. }
  571. *frameUsed += used * 4;
  572. return stereo? used * 4: used * 2;
  573. }
  575. TRANS transAwacsNormal = {
  576. ct_ulaw: pmac_ct_law,
  577. ct_alaw: pmac_ct_law,
  578. ct_s8: pmac_ct_s8,
  579. ct_u8: pmac_ct_u8,
  580. ct_s16be: pmac_ct_s16,
  581. ct_u16be: pmac_ct_u16,
  582. ct_s16le: pmac_ct_s16,
  583. ct_u16le: pmac_ct_u16,
  584. };
  586. TRANS transAwacsExpand = {
  587. ct_ulaw: pmac_ctx_law,
  588. ct_alaw: pmac_ctx_law,
  589. ct_s8: pmac_ctx_s8,
  590. ct_u8: pmac_ctx_u8,
  591. ct_s16be: pmac_ctx_s16,
  592. ct_u16be: pmac_ctx_u16,
  593. ct_s16le: pmac_ctx_s16,
  594. ct_u16le: pmac_ctx_u16,
  595. };
  597. TRANS transAwacsNormalRead = {
  598. ct_s8: pmac_ct_s8_read,
  599. ct_u8: pmac_ct_u8_read,
  600. ct_s16be: pmac_ct_s16_read,
  601. ct_u16be: pmac_ct_u16_read,
  602. ct_s16le: pmac_ct_s16_read,
  603. ct_u16le: pmac_ct_u16_read,
  604. };
  606. /* translation tables */
  607. /* 16 bit mu-law */
  609. static short dmasound_ulaw2dma16[] = {
  610. -32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956,
  611. -23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764,
  612. -15996, -15484, -14972, -14460, -13948, -13436, -12924, -12412,
  613. -11900, -11388, -10876, -10364, -9852, -9340, -8828, -8316,
  614. -7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
  615. -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
  616. -3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
  617. -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
  618. -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
  619. -1372, -1308, -1244, -1180, -1116, -1052, -988, -924,
  620. -876, -844, -812, -780, -748, -716, -684, -652,
  621. -620, -588, -556, -524, -492, -460, -428, -396,
  622. -372, -356, -340, -324, -308, -292, -276, -260,
  623. -244, -228, -212, -196, -180, -164, -148, -132,
  624. -120, -112, -104, -96, -88, -80, -72, -64,
  625. -56, -48, -40, -32, -24, -16, -8, 0,
  626. 32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
  627. 23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
  628. 15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
  629. 11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316,
  630. 7932, 7676, 7420, 7164, 6908, 6652, 6396, 6140,
  631. 5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092,
  632. 3900, 3772, 3644, 3516, 3388, 3260, 3132, 3004,
  633. 2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980,
  634. 1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
  635. 1372, 1308, 1244, 1180, 1116, 1052, 988, 924,
  636. 876, 844, 812, 780, 748, 716, 684, 652,
  637. 620, 588, 556, 524, 492, 460, 428, 396,
  638. 372, 356, 340, 324, 308, 292, 276, 260,
  639. 244, 228, 212, 196, 180, 164, 148, 132,
  640. 120, 112, 104, 96, 88, 80, 72, 64,
  641. 56, 48, 40, 32, 24, 16, 8, 0,
  642. };
  644. /* 16 bit A-law */
  646. static short dmasound_alaw2dma16[] = {
  647. -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
  648. -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
  649. -2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
  650. -3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
  651. -22016, -20992, -24064, -23040, -17920, -16896, -19968, -18944,
  652. -30208, -29184, -32256, -31232, -26112, -25088, -28160, -27136,
  653. -11008, -10496, -12032, -11520, -8960, -8448, -9984, -9472,
  654. -15104, -14592, -16128, -15616, -13056, -12544, -14080, -13568,
  655. -344, -328, -376, -360, -280, -264, -312, -296,
  656. -472, -456, -504, -488, -408, -392, -440, -424,
  657. -88, -72, -120, -104, -24, -8, -56, -40,
  658. -216, -200, -248, -232, -152, -136, -184, -168,
  659. -1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
  660. -1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
  661. -688, -656, -752, -720, -560, -528, -624, -592,
  662. -944, -912, -1008, -976, -816, -784, -880, -848,
  663. 5504, 5248, 6016, 5760, 4480, 4224, 4992, 4736,
  664. 7552, 7296, 8064, 7808, 6528, 6272, 7040, 6784,
  665. 2752, 2624, 3008, 2880, 2240, 2112, 2496, 2368,
  666. 3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392,
  667. 22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
  668. 30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
  669. 11008, 10496, 12032, 11520, 8960, 8448, 9984, 9472,
  670. 15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
  671. 344, 328, 376, 360, 280, 264, 312, 296,
  672. 472, 456, 504, 488, 408, 392, 440, 424,
  673. 88, 72, 120, 104, 24, 8, 56, 40,
  674. 216, 200, 248, 232, 152, 136, 184, 168,
  675. 1376, 1312, 1504, 1440, 1120, 1056, 1248, 1184,
  676. 1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696,
  677. 688, 656, 752, 720, 560, 528, 624, 592,
  678. 944, 912, 1008, 976, 816, 784, 880, 848,
  679. };