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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
portableio.c
资源名称：shine.zip　[点击查看]
上传用户：jgz_ta
上传日期：2007-11-29
资源大小：73k
文件大小：9k
源码类别：

mpeg/mp3

开发平台：

C/C++

portableio.c：源码内容
  1. //    Shine is an MP3 encoder
  2. //    Copyright (C) 1999-2000  Gabriel Bouvigne
  3. //
  4. //    This library is free software; you can redistribute it and/or
  5. //    modify it under the terms of the GNU Library General Public
  6. //    License as published by the Free Software Foundation; either
  7. //    version 2 of the License, or (at your option) any later version.
  8. //
  9. //    This library is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12. //    Library General Public License for more details.
  15. /* Copyright (C) 1988-1991 Apple Computer, Inc.
  16.  * All Rights Reserved.
  17.  *
  18.  * Warranty Information
  19.  * Even though Apple has reviewed this software, Apple makes no warranty
  20.  * or representation, either express or implied, with respect to this
  21.  * software, its quality, accuracy, merchantability, or fitness for a 
  22.  * particular purpose.  As a result, this software is provided "as is,"
  23.  * and you, its user, are assuming the entire risk as to its quality
  24.  * and accuracy.
  25.  *
  26.  * This code may be used and freely distributed as long as it includes
  27.  * this copyright notice and the warranty information.
  28.  *
  29.  *
  30.  * Motorola processors (Macintosh, Sun, Sparc, MIPS, etc)
  31.  * pack bytes from high to low (they are big-endian).
  32.  * Use the HighLow routines to match the native format
  33.  * of these machines.
  34.  *
  35.  * Intel-like machines (PCs, Sequent)
  36.  * pack bytes from low to high (the are little-endian).
  37.  * Use the LowHigh routines to match the native format
  38.  * of these machines.
  39.  *
  40.  * These routines have been tested on the following machines:
  41.  * Apple Macintosh, MPW 3.1 C compiler
  42.  * Apple Macintosh, THINK C compiler
  43.  * Silicon Graphics IRIS, MIPS compiler
  44.  * Cray X/MP and Y/MP
  45.  * Digital Equipment VAX
  46.  *
  47.  *
  48.  * Implemented by Malcolm Slaney and Ken Turkowski.
  49.  *
  50.  * Malcolm Slaney contributions during 1988-1990 include big- and little-
  51.  * endian file I/O, conversion to and from Motorola's extended 80-bit
  52.  * floating-point format, and conversions to and from IEEE single-
  53.  * precision floating-point format.
  54.  *
  55.  * In 1991, Ken Turkowski implemented the conversions to and from
  56.  * IEEE double-precision format, added more precision to the extended
  57.  * conversions, and accommodated conversions involving +/- infinity,
  58.  * NaN's, and denormalized numbers.
  59.  *
  60.  * $Id: portableio.c,v 2.6 1991/04/30 17:06:02 malcolm Exp $
  61.  *
  62.  * $Log: portableio.c,v $
  63.  * Revision 2.6  91/04/30  17:06:02  malcolm
  64.  */
  66. #include <stdio.h>
  67. #include <string.h>
  68. #include <math.h>
  69. #include "portableio.h"
  71. /****************************************************************
  72.  * Big/little-endian independent I/O routines.
  73.  ****************************************************************/
  76. int
  77. ReadByte(fp)
  78. FILE *fp;
  79. {
  80. int result;
  82. result = getc(fp) & 0xff;
  83. if (result & 0x80)
  84. result = result - 0x100;
  85. return result;
  86. }
  89. int
  90. Read16BitsLowHigh(fp)
  91. FILE *fp;
  92. {
  93. int first, second, result;
  95. first = 0xff & getc(fp);
  96. second = 0xff & getc(fp);
  98. result = (second << 8) + first;
  99. #ifndef THINK_C42
  100. if (result & 0x8000)
  101. result = result - 0x10000;
  102. #endif /* THINK_C */
  103. return(result);
  104. }
  107. int
  108. Read16BitsHighLow(fp)
  109. FILE *fp;
  110. {
  111. int first, second, result;
  113. first = 0xff & getc(fp);
  114. second = 0xff & getc(fp);
  116. result = (first << 8) + second;
  117. #ifndef THINK_C42
  118. if (result & 0x8000)
  119. result = result - 0x10000;
  120. #endif /* THINK_C */
  121. return(result);
  122. }
  125. void
  126. Write8Bits(fp, i)
  127. FILE *fp;
  128. int i;
  129. {
  130. putc(i&0xff,fp);
  131. }
  134. void
  135. Write16BitsLowHigh(fp, i)
  136. FILE *fp;
  137. int i;
  138. {
  139. putc(i&0xff,fp);
  140. putc((i>>8)&0xff,fp);
  141. }
  144. void
  145. Write16BitsHighLow(fp, i)
  146. FILE *fp;
  147. int i;
  148. {
  149. putc((i>>8)&0xff,fp);
  150. putc(i&0xff,fp);
  151. }
  154. int
  155. Read24BitsHighLow(fp)
  156. FILE *fp;
  157. {
  158. int first, second, third;
  159. int result;
  161. first = 0xff & getc(fp);
  162. second = 0xff & getc(fp);
  163. third = 0xff & getc(fp);
  165. result = (first << 16) + (second << 8) + third;
  166. if (result & 0x800000)
  167. result = result - 0x1000000;
  168. return(result);
  169. }
  171. #define Read32BitsLowHigh(f) Read32Bits(f)
  174. int
  175. Read32Bits(fp)
  176. FILE *fp;
  177. {
  178. int first, second, result;
  180. first = 0xffff & Read16BitsLowHigh(fp);
  181. second = 0xffff & Read16BitsLowHigh(fp);
  183. result = (second << 16) + first;
  184. #ifdef CRAY
  185. if (result & 0x80000000)
  186. result = result - 0x100000000;
  187. #endif /* CRAY */
  188. return(result);
  189. }
  192. int
  193. Read32BitsHighLow(fp)
  194. FILE *fp;
  195. {
  196. int first, second, result;
  198. first = 0xffff & Read16BitsHighLow(fp);
  199. second = 0xffff & Read16BitsHighLow(fp);
  201. result = (first << 16) + second;
  202. #ifdef CRAY
  203. if (result & 0x80000000)
  204. result = result - 0x100000000;
  205. #endif
  206. return(result);
  207. }
  210. void
  211. Write32Bits(fp, i)
  212. FILE *fp;
  213. int i;
  214. {
  215. Write16BitsLowHigh(fp,(int)(i&0xffffL));
  216. Write16BitsLowHigh(fp,(int)((i>>16)&0xffffL));
  217. }
  220. void
  221. Write32BitsLowHigh(fp, i)
  222. FILE *fp;
  223. int i;
  224. {
  225. Write16BitsLowHigh(fp,(int)(i&0xffffL));
  226. Write16BitsLowHigh(fp,(int)((i>>16)&0xffffL));
  227. }
  230. void
  231. Write32BitsHighLow(fp, i)
  232. FILE *fp;
  233. int i;
  234. {
  235. Write16BitsHighLow(fp,(int)((i>>16)&0xffffL));
  236. Write16BitsHighLow(fp,(int)(i&0xffffL));
  237. }
  239. void ReadBytes(fp, p, n)
  240. FILE *fp;
  241. char *p;
  242. int n;
  243. {
  244. while (!feof(fp) && n-- > 0)
  245. *p++ = getc(fp);
  246. }
  248. void ReadBytesSwapped(fp, p, n)
  249. FILE *fp;
  250. char *p;
  251. int n;
  252. {
  253. register char *q = p;
  255. while (!feof(fp) && n-- > 0)
  256. *q++ = getc(fp);
  258. for (q--; p < q; p++, q--){
  259. n = *p;
  260. *p = *q;
  261. *q = n;
  262. }
  263. }
  265. void WriteBytes(fp, p, n)
  266. FILE *fp;
  267. char *p;
  268. int n;
  269. {
  270. while (n-- > 0)
  271. putc(*p++, fp);
  272. }
  274. void WriteBytesSwapped(fp, p, n)
  275. FILE *fp;
  276. char *p;
  277. int n;
  278. {
  279. p += n-1;
  280. while (n-- > 0)
  281. putc(*p--, fp);
  282. }
  284. defdouble
  285. ReadIeeeFloatHighLow(fp)
  286. FILE *fp;
  287. {
  288. char bits[kFloatLength];
  290. ReadBytes(fp, bits, kFloatLength);
  291. return ConvertFromIeeeSingle(bits);
  292. }
  294. defdouble
  295. ReadIeeeFloatLowHigh(fp)
  296. FILE *fp;
  297. {
  298. char bits[kFloatLength];
  300. ReadBytesSwapped(fp, bits, kFloatLength);
  301. return ConvertFromIeeeSingle(bits);
  302. }
  304. defdouble
  305. ReadIeeeDoubleHighLow(fp)
  306. FILE *fp;
  307. {
  308. char bits[kDoubleLength];
  310. ReadBytes(fp, bits, kDoubleLength);
  311. return ConvertFromIeeeDouble(bits);
  312. }
  314. defdouble
  315. ReadIeeeDoubleLowHigh(fp)
  316. FILE *fp;
  317. {
  318. char bits[kDoubleLength];
  320. ReadBytesSwapped(fp, bits, kDoubleLength);
  321. return ConvertFromIeeeDouble(bits);
  322. }
  324. defdouble
  325. ReadIeeeExtendedHighLow(fp)
  326. FILE *fp;
  327. {
  328. char bits[kExtendedLength];
  330. ReadBytes(fp, bits, kExtendedLength);
  331. return ConvertFromIeeeExtended(bits);
  332. }
  334. defdouble
  335. ReadIeeeExtendedLowHigh(fp)
  336. FILE *fp;
  337. {
  338. char bits[kExtendedLength];
  340. ReadBytesSwapped(fp, bits, kExtendedLength);
  341. return ConvertFromIeeeExtended(bits);
  342. }
  344. void
  345. WriteIeeeFloatLowHigh(fp, num)
  346. FILE *fp;
  347. defdouble num;
  348. {
  349. char bits[kFloatLength];
  351. ConvertToIeeeSingle(num,bits);
  352. WriteBytesSwapped(fp,bits,kFloatLength);
  353. }
  355. void
  356. WriteIeeeFloatHighLow(fp, num)
  357. FILE *fp;
  358. defdouble num;
  359. {
  360. char bits[kFloatLength];
  362. ConvertToIeeeSingle(num,bits);
  363. WriteBytes(fp,bits,kFloatLength);
  364. }
  366. void
  367. WriteIeeeDoubleLowHigh(fp, num)
  368. FILE *fp;
  369. defdouble num;
  370. {
  371. char bits[kDoubleLength];
  373. ConvertToIeeeDouble(num,bits);
  374. WriteBytesSwapped(fp,bits,kDoubleLength);
  375. }
  377. void
  378. WriteIeeeDoubleHighLow(fp, num)
  379. FILE *fp;
  380. defdouble num;
  381. {
  382. char bits[kDoubleLength];
  384. ConvertToIeeeDouble(num,bits);
  385. WriteBytes(fp,bits,kDoubleLength);
  386. }
  388. void
  389. WriteIeeeExtendedLowHigh(fp, num)
  390. FILE *fp;
  391. defdouble num;
  392. {
  393. char bits[kExtendedLength];
  395. ConvertToIeeeExtended(num,bits);
  396. WriteBytesSwapped(fp,bits,kExtendedLength);
  397. }
  400. void
  401. WriteIeeeExtendedHighLow(fp, num)
  402. FILE *fp;
  403. defdouble num;
  404. {
  405. char bits[kExtendedLength];
  407. ConvertToIeeeExtended(num,bits);
  408. WriteBytes(fp,bits,kExtendedLength);
  409. }
  412. enum e_byte_order DetermineByteOrder()
  413. {
  414.     char s[ sizeof(long) + 1 ];
  415.     union
  416.     {
  417.         long longval;
  418.         char charval[ sizeof(long) ];
  419.     } probe;
  420.     probe.longval = 0x41424344L;  /* ABCD in ASCII */
  421.     strncpy( s, probe.charval, sizeof(long) );
  422.     s[ sizeof(long) ] = '';
  423.     /* fprintf( stderr, "byte order is %sn", s ); */
  424.     if ( strcmp(s, "ABCD") == 0 )
  425.         return order_bigEndian;
  426.     else
  427.         if ( strcmp(s, "DCBA") == 0 )
  428.             return order_littleEndian;
  429.         else
  430.             return order_unknown;
  431. }
  433. void SwapBytesInWords( short *loc, int words )
  434. {
  435.     int i;
  436.     short thisval;
  437.     char *dst, *src;
  438.     src = (char *) &thisval;
  439.     for ( i = 0; i < words; i++ )
  440.     {
  441.         thisval = *loc;
  442.         dst = (char *) loc++;
  443.         dst[0] = src[1];
  444.         dst[1] = src[0];
  445.     }
  446. }