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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
sbtb.c
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：9k
源码类别：

Symbian

开发平台：

C/C++

sbtb.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "statname.h"
  38. void windowB(float *vbuf, int vb_ptr, unsigned char *pcm);
  39. void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
  40. void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm);
  41. void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
  42. void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm);
  43. void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
  45. /*============================================================*/
  46. void sbtB_mono(float *sample, unsigned char *pcm, 
  47.                int n, float vbuf[][512], int vb_ptr_arg[])
  48. {
  49. int i;
  51. vb_ptr = vb_ptr_arg[0];
  52. for(i=0;i<n;i++) {
  53.   fdct32(sample, vbuf[0]+vb_ptr);
  54.   windowB(vbuf[0], vb_ptr, pcm);
  55.   sample += 64;
  56.   vb_ptr = (vb_ptr-32) & 511;
  57.   pcm += 32;
  58. }
  60. vb_ptr_arg[0] = vb_ptr;
  61. }
  62. /*------------------------------------------------------------*/
  63. void sbtB_dual(float *sample, unsigned char *pcm, 
  64.                int n, float vbuf[][512], int vb_ptr_arg[])
  65. {
  66. int i;
  68. vb_ptr = vb_ptr_arg[0];
  69. for(i=0;i<n;i++) {
  70.   fdct32_dual(sample, vbuf[0]+vb_ptr);
  71.   fdct32_dual(sample+1, vbuf[1]+vb_ptr);
  72.   windowB_dual(vbuf[0], vb_ptr, pcm);
  73.   windowB_dual(vbuf[1], vb_ptr, pcm+1);
  74.   sample += 64;
  75.   vb_ptr = (vb_ptr-32) & 511;
  76.   pcm += 64;
  77. }
  80. vb_ptr_arg[0] = vb_ptr;
  81. }
  82. /*------------------------------------------------------------*/
  83. #ifdef REDUCTION
  84. /*------------------------------------------------------------*/
  85. /* convert dual to mono */
  86. void sbtB_dual_mono(float *sample, unsigned char *pcm, 
  87.                     int n, float vbuf[][512], int vb_ptr_arg[])
  88. {
  89. int i;
  91. vb_ptr = vb_ptr_arg[0];
  92. for(i=0;i<n;i++) {
  93.   fdct32_dual_mono(sample, vbuf[0]+vb_ptr);
  94.   windowB(vbuf[0], vb_ptr, pcm);
  95.   sample += 64;
  96.   vb_ptr = (vb_ptr-32) & 511;
  97.   pcm += 32;
  98. }
  100. vb_ptr_arg[0] = vb_ptr;
  101. }
  102. /*------------------------------------------------------------*/
  103. /* convert dual to left */
  104. void sbtB_dual_left(float *sample, unsigned char *pcm, 
  105.                     int n, float vbuf[][512], int vb_ptr_arg[])
  106. {
  107. int i;
  108. vb_ptr = vb_ptr_arg[0];
  109. for(i=0;i<n;i++) {
  110.   fdct32_dual(sample, vbuf[0]+vb_ptr);
  111.   windowB(vbuf[0], vb_ptr, pcm);
  112.   sample += 64;
  113.   vb_ptr = (vb_ptr-32) & 511;
  114.   pcm += 32;
  115. }
  116. vb_ptr_arg[0] = vb_ptr;
  117. }
  118. /*------------------------------------------------------------*/
  119. /* convert dual to right */
  120. void sbtB_dual_right(float *sample, unsigned char *pcm, 
  121.                      int n, float vbuf[][512], int vb_ptr_arg[])
  122. {
  123. int i;
  125. vb_ptr = vb_ptr_arg[0];
  126. sample++;   /* point to right chan */
  127. for(i=0;i<n;i++) {
  128.   fdct32_dual(sample, vbuf[0]+vb_ptr);
  129.   windowB(vbuf[0], vb_ptr, pcm);
  130.   sample += 64;
  131.   vb_ptr = (vb_ptr-32) & 511;
  132.   pcm += 32;
  133. }
  134. vb_ptr_arg[0] = vb_ptr;
  135. }
  136. /*------------------------------------------------------------*/
  137. /*---------------- 16 pt sbt's  -------------------------------*/
  138. /*------------------------------------------------------------*/
  139. void sbtB16_mono(float *sample, unsigned char *pcm, 
  140.                  int n, float vbuf[][512], int vb_ptr_arg[])
  141. {
  142. int i;
  144. vb_ptr = vb_ptr_arg[0];
  145. for(i=0;i<n;i++) {
  146.   fdct16(sample, vbuf[0]+vb_ptr);
  147.   windowB16(vbuf[0], vb_ptr, pcm);
  148.   sample += 64;
  149.   vb_ptr = (vb_ptr-16) & 255;
  150.   pcm += 16;
  151. }
  153. vb_ptr_arg[0] = vb_ptr;
  154. }
  155. /*------------------------------------------------------------*/
  156. void sbtB16_dual(float *sample, unsigned char *pcm, 
  157.                  int n, float vbuf[][512], int vb_ptr_arg[])
  158. {
  159. int i;
  161. vb_ptr = vb_ptr_arg[0];
  162. for(i=0;i<n;i++) {
  163.   fdct16_dual(sample, vbuf[0]+vb_ptr);
  164.   fdct16_dual(sample+1, vbuf[1]+vb_ptr);
  165.   windowB16_dual(vbuf[0], vb_ptr, pcm);
  166.   windowB16_dual(vbuf[1], vb_ptr, pcm+1);
  167.   sample += 64;
  168.   vb_ptr = (vb_ptr-16) & 255;
  169.   pcm += 32;
  170. }
  171. vb_ptr_arg[0] = vb_ptr;
  172. }
  173. /*------------------------------------------------------------*/
  174. void sbtB16_dual_mono(float *sample, unsigned char *pcm, 
  175.                       int n, float vbuf[][512], int vb_ptr_arg[])
  176. {
  177. int i;
  179. vb_ptr = vb_ptr_arg[0];
  180. for(i=0;i<n;i++) {
  181.   fdct16_dual_mono(sample, vbuf[0]+vb_ptr);
  182.   windowB16(vbuf[0], vb_ptr, pcm);
  183.   sample += 64;
  184.   vb_ptr = (vb_ptr-16) & 255;
  185.   pcm += 16;
  186. }
  187. vb_ptr_arg[0] = vb_ptr;
  188. }
  189. /*------------------------------------------------------------*/
  190. void sbtB16_dual_left(float *sample, unsigned char *pcm, 
  191.                       int n, float vbuf[][512], int vb_ptr_arg[])
  192. {
  193. int i;
  195. vb_ptr = vb_ptr_arg[0];
  196. for(i=0;i<n;i++) {
  197.   fdct16_dual(sample, vbuf[0]+vb_ptr);
  198.   windowB16(vbuf[0], vb_ptr, pcm);
  199.   sample += 64;
  200.   vb_ptr = (vb_ptr-16) & 255;
  201.   pcm += 16;
  202. }
  203. vb_ptr_arg[0] = vb_ptr;
  204. }
  205. /*------------------------------------------------------------*/
  206. void sbtB16_dual_right(float *sample, unsigned char *pcm, 
  207.                        int n, float vbuf[][512], int vb_ptr_arg[])
  208. {
  209. int i;
  211. vb_ptr = vb_ptr_arg[0];
  212. sample++;
  213. for(i=0;i<n;i++) {
  214.   fdct16_dual(sample, vbuf[0]+vb_ptr);
  215.   windowB16(vbuf[0], vb_ptr, pcm);
  216.   sample += 64;
  217.   vb_ptr = (vb_ptr-16) & 255;
  218.   pcm += 16;
  219. }
  220. vb_ptr_arg[0] = vb_ptr;
  221. }
  222. /*------------------------------------------------------------*/
  223. /*---------------- 8 pt sbt's  -------------------------------*/
  224. /*------------------------------------------------------------*/
  225. void sbtB8_mono(float *sample, unsigned char *pcm, 
  226.                 int n, float vbuf[][512], int vb_ptr_arg[])
  227. {
  228. int i;
  230. vb_ptr = vb_ptr_arg[0];
  231. for(i=0;i<n;i++) {
  232.   fdct8(sample, vbuf[0]+vb_ptr);
  233.   windowB8(vbuf[0], vb_ptr, pcm);
  234.   sample += 64;
  235.   vb_ptr = (vb_ptr-8) & 127;
  236.   pcm += 8;
  237. }
  239. vb_ptr_arg[0] = vb_ptr;
  240. }
  241. /*------------------------------------------------------------*/
  242. void sbtB8_dual(float *sample, unsigned char *pcm, 
  243.                 int n, float vbuf[][512], int vb_ptr_arg[])
  244. {
  245. int i;
  247. vb_ptr = vb_ptr_arg[0];
  248. for(i=0;i<n;i++) {
  249.   fdct8_dual(sample, vbuf[0]+vb_ptr);
  250.   fdct8_dual(sample+1, vbuf[1]+vb_ptr);
  251.   windowB8_dual(vbuf[0], vb_ptr, pcm);
  252.   windowB8_dual(vbuf[1], vb_ptr, pcm+1);
  253.   sample += 64;
  254.   vb_ptr = (vb_ptr-8) & 127;
  255.   pcm += 16;
  256. }
  257. vb_ptr_arg[0] = vb_ptr;
  258. }
  259. /*------------------------------------------------------------*/
  260. void sbtB8_dual_mono(float *sample, unsigned char *pcm, 
  261.                      int n, float vbuf[][512], int vb_ptr_arg[])
  262. {
  263. int i;
  265. vb_ptr = vb_ptr_arg[0];
  266. for(i=0;i<n;i++) {
  267.   fdct8_dual_mono(sample, vbuf[0]+vb_ptr);
  268.   windowB8(vbuf[0], vb_ptr, pcm);
  269.   sample += 64;
  270.   vb_ptr = (vb_ptr-8) & 127;
  271.   pcm += 8;
  272. }
  273. vb_ptr_arg[0] = vb_ptr;
  274. }
  275. /*------------------------------------------------------------*/
  276. void sbtB8_dual_left(float *sample, unsigned char *pcm, 
  277.                      int n, float vbuf[][512], int vb_ptr_arg[])
  278. {
  279. int i;
  281. vb_ptr = vb_ptr_arg[0];
  282. for(i=0;i<n;i++) {
  283.   fdct8_dual(sample, vbuf[0]+vb_ptr);
  284.   windowB8(vbuf[0], vb_ptr, pcm);
  285.   sample += 64;
  286.   vb_ptr = (vb_ptr-8) & 127;
  287.   pcm += 8;
  288. }
  289. vb_ptr_arg[0] = vb_ptr;
  290. }
  291. /*------------------------------------------------------------*/
  292. void sbtB8_dual_right(float *sample, unsigned char *pcm, 
  293.                       int n, float vbuf[][512], int vb_ptr_arg[])
  294. {
  295. int i;
  297. vb_ptr = vb_ptr_arg[0];
  298. sample++;
  299. for(i=0;i<n;i++) {
  300.   fdct8_dual(sample, vbuf[0]+vb_ptr);
  301.   windowB8(vbuf[0], vb_ptr, pcm);
  302.   sample += 64;
  303.   vb_ptr = (vb_ptr-8) & 127;
  304.   pcm += 8;
  305. }
  306. vb_ptr_arg[0] = vb_ptr;
  307. }
  308. /*------------------------------------------------------------*/
  309. // end reduction 8 bit
  310. #endif