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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
au.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：18k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

au.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2000 Erik de Castro Lopo <erikd@zip.com.au>
  3. **  
  4. ** This program is free software; you can redistribute it and/or modify
  5. ** it under the terms of the GNU Lesser General Public License as published by
  6. ** the Free Software Foundation; either version 2.1 of the License, or
  7. ** (at your option) any later version.
  8. ** 
  9. ** This program 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
  12. ** GNU Lesser General Public License for more details.
  13. ** 
  14. ** You should have received a copy of the GNU Lesser General Public License
  15. ** along with this program; if not, write to the Free Software 
  16. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17. */
  20. #include <stdio.h>
  21. #include <unistd.h>
  22. #include <fcntl.h>
  23. #include <string.h>
  24. #include <ctype.h>
  26. #include "sndfile.h"
  27. #include "config.h"
  28. #include "sfendian.h"
  29. #include "common.h"
  30. #include "pcm.h"
  31. #include "au.h"
  32. #include "ulaw.h"
  33. #include "alaw.h"
  36. /*------------------------------------------------------------------------------
  37. ** Macros to handle big/little endian issues.
  38. */
  40. #if (CPU_IS_LITTLE_ENDIAN == 1)
  41. #define MAKE_MARKER(a,b,c,d) ((a)|((b)<<8)|((c)<<16)|((d)<<24))
  42. #elif (CPU_IS_BIG_ENDIAN == 1)
  43. #define MAKE_MARKER(a,b,c,d) (((a)<<24)|((b)<<16)|((c)<<8)|(d))
  44. #else
  45. #error "Cannot determine endian-ness of processor."
  46. #endif
  48. #define DOTSND_MARKER (MAKE_MARKER ('.', 's', 'n', 'd')) 
  49. #define DNSDOT_MARKER (MAKE_MARKER ('d', 'n', 's', '.')) 
  51. /*------------------------------------------------------------------------------
  52. ** Known AU file encoding types.
  53. */
  55. enum
  56. { AU_ENCODING_ULAW_8 = 1, /* 8-bit u-law samples */
  57. AU_ENCODING_PCM_8 = 2, /* 8-bit linear samples */
  58. AU_ENCODING_PCM_16 = 3, /* 16-bit linear samples */
  59. AU_ENCODING_PCM_24 = 4, /* 24-bit linear samples */
  60. AU_ENCODING_PCM_32 = 5, /* 32-bit linear samples */
  62. AU_ENCODING_FLOAT = 6, /* floating-point samples */
  63. AU_ENCODING_DOUBLE = 7, /* double-precision float samples */
  64. AU_ENCODING_INDIRECT = 8, /* fragmented sampled data */
  65. AU_ENCODING_NESTED = 9, /* ? */
  66. AU_ENCODING_DSP_CORE = 10, /* DSP program */
  67. AU_ENCODING_DSP_DATA_8 = 11, /* 8-bit fixed-point samples */
  68. AU_ENCODING_DSP_DATA_16 = 12, /* 16-bit fixed-point samples */
  69. AU_ENCODING_DSP_DATA_24 = 13, /* 24-bit fixed-point samples */
  70. AU_ENCODING_DSP_DATA_32 = 14, /* 32-bit fixed-point samples */
  72. AU_ENCODING_DISPLAY = 16, /* non-audio display data */
  73. AU_ENCODING_MULAW_SQUELCH = 17, /* ? */
  74. AU_ENCODING_EMPHASIZED = 18, /* 16-bit linear with emphasis */
  75. AU_ENCODING_NEXT = 19, /* 16-bit linear with compression (NEXT) */
  76. AU_ENCODING_COMPRESSED_EMPHASIZED = 20, /* A combination of the two above */
  77. AU_ENCODING_DSP_COMMANDS = 21, /* Music Kit DSP commands */
  78. AU_ENCODING_DSP_COMMANDS_SAMPLES = 22, /* ? */
  80. AU_ENCODING_ADPCM_G721_32 = 23, /* G721 32 kbs ADPCM - 4 bits per sample. */
  81. AU_ENCODING_ADPCM_G722 = 24,
  82. AU_ENCODING_ADPCM_G723_24 = 25, /* G723 24 kbs ADPCM - 3 bits per sample. */
  83. AU_ENCODING_ADPCM_G723_5 = 26,
  85. AU_ENCODING_ALAW_8 = 27
  86. } ;
  88. /*------------------------------------------------------------------------------
  89. ** Typedefs.
  90. */
  91.  
  92. typedef struct
  93. { int dataoffset ;
  94. int datasize ;
  95. int encoding ;
  96.     int samplerate ;
  97.     int channels ;
  98. } AU_FMT ;
  101. /*------------------------------------------------------------------------------
  102. ** Private static functions.
  103. */
  105. static int au_close (SF_PRIVATE *psf) ;
  107. static int  get_encoding (unsigned int format, unsigned int bitwidth) ;
  108. static char*  get_encoding_str(int format) ;
  109. static void endswap_au_fmt (AU_FMT *pau_fmt) ;
  112. /*------------------------------------------------------------------------------
  113. ** Public functions.
  114. */
  116. int  au_open_read (SF_PRIVATE *psf)
  117. { AU_FMT au_fmt ;
  118. unsigned int marker, dword ;
  119. int big_endian_file, error = SFE_NO_ERROR ;
  120. /*or*/
  121. int force_open; 
  122. force_open = ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORCE_OPEN)?1:0;
  123. /*end or*/
  125. fread (&marker, sizeof (marker), 1, psf->file) ;
  126. if (marker == DOTSND_MARKER)
  127. big_endian_file = 1 ;
  128. else if (marker == DNSDOT_MARKER)
  129. big_endian_file = 0 ;
  130. else
  131. return SFE_AU_NO_DOTSND ;
  133. psf_sprintf (psf, "%Dn", marker) ;
  135. fread (&au_fmt, sizeof (AU_FMT), 1, psf->file) ;
  137. if (CPU_IS_LITTLE_ENDIAN && big_endian_file)
  138. endswap_au_fmt (&au_fmt) ;
  139. else if (CPU_IS_BIG_ENDIAN && ! big_endian_file)
  140. endswap_au_fmt (&au_fmt) ;
  142. psf_sprintf (psf, "  Data Offset : %dn", au_fmt.dataoffset) ;
  144. if (au_fmt.dataoffset + au_fmt.datasize != psf->filelength)
  145. { dword = psf->filelength - au_fmt.dataoffset ;
  146. psf_sprintf (psf, "  Data Size   : %d (should be %d)n", au_fmt.datasize, dword) ;
  147. au_fmt.datasize = dword ;
  148. }
  149. else
  150. psf_sprintf (psf, "  Data Size   : %dn", au_fmt.datasize) ;
  152.   psf->dataoffset = au_fmt.dataoffset ;
  153. psf->datalength = psf->filelength - psf->dataoffset ;
  155.   psf->current  = 0 ;
  156. psf->endian   = big_endian_file ? SF_ENDIAN_BIG : SF_ENDIAN_LITTLE ;
  157. psf->sf.seekable = SF_TRUE ;
  158.  
  159.   if (fseek (psf->file, psf->dataoffset, SEEK_SET))
  160. return SFE_BAD_SEEK ;
  162. psf->close = (func_close) au_close ;
  164. psf->sf.samplerate = au_fmt.samplerate ;
  165. psf->sf.channels  = au_fmt.channels ;
  167. /* Only fill in type major. */
  168. psf->sf.format = big_endian_file ? SF_FORMAT_AU : SF_FORMAT_AULE ;
  170. psf->sf.sections  = 1 ;
  172. psf_sprintf (psf, "  Encoding    : %d => %sn", au_fmt.encoding, get_encoding_str (au_fmt.encoding)) ;
  174. psf_sprintf (psf, "  Sample Rate : %dn", au_fmt.samplerate) ;
  175. psf_sprintf (psf, "  Channels    : %dn", au_fmt.channels) ;
  177. /*or*/
  178. if(force_open)
  179.     psf->sf.format_tag = au_fmt.encoding;
  180. /*end or*/
  182. switch (au_fmt.encoding)
  183. { case  AU_ENCODING_ULAW_8 :
  184. psf->sf.pcmbitwidth = 16 ; /* After decoding */
  185. psf->bytewidth    = 1 ; /* Before decoding */
  186. psf->blockwidth = psf->sf.channels * psf->bytewidth ;
  188. psf->sf.format |= SF_FORMAT_ULAW ;
  190. psf->read_short  = (func_short)  ulaw_read_ulaw2s ;
  191. psf->read_int    = (func_int)    ulaw_read_ulaw2i ;
  192. psf->read_double = (func_double) ulaw_read_ulaw2d ;
  194. break ;
  196. case  AU_ENCODING_PCM_8 :
  197. psf->sf.pcmbitwidth = 8 ;
  198. psf->bytewidth      = BITWIDTH2BYTES (psf->sf.pcmbitwidth) ;
  199. psf->blockwidth = psf->sf.channels * psf->bytewidth ;
  201. psf->sf.format |= SF_FORMAT_PCM ;
  203. psf->read_short  = (func_short)  pcm_read_sc2s ;
  204. psf->read_int    = (func_int)    pcm_read_sc2i ;
  205. psf->read_double = (func_double) pcm_read_sc2d ;
  206. break ;
  208. case  AU_ENCODING_PCM_16 :
  209. psf->sf.pcmbitwidth = 16 ;
  210. psf->bytewidth      = BITWIDTH2BYTES (psf->sf.pcmbitwidth) ;
  211. psf->blockwidth = psf->sf.channels * psf->bytewidth ;
  213. psf->sf.format |= SF_FORMAT_PCM ;
  215. if (big_endian_file)
  216. { psf->read_short  = (func_short)  pcm_read_bes2s ;
  217. psf->read_int    = (func_int)    pcm_read_bes2i ;
  218. psf->read_double = (func_double) pcm_read_bes2d ;
  219. }
  220. else
  221. { psf->read_short  = (func_short)  pcm_read_les2s ;
  222. psf->read_int    = (func_int)    pcm_read_les2i ;
  223. psf->read_double = (func_double) pcm_read_les2d ;
  224. } ;
  225. break ;
  227. case  AU_ENCODING_PCM_24 :
  228. psf->sf.pcmbitwidth = 24 ;
  229. psf->bytewidth      = BITWIDTH2BYTES (psf->sf.pcmbitwidth) ;
  230. psf->blockwidth = psf->sf.channels * psf->bytewidth ;
  232. psf->sf.format |= SF_FORMAT_PCM ;
  234. if (big_endian_file)
  235. { psf->read_short  = (func_short)  pcm_read_bet2s ;
  236. psf->read_int    = (func_int)    pcm_read_bet2i ;
  237. psf->read_double = (func_double) pcm_read_bet2d ;
  238. }
  239. else
  240. { psf->read_short  = (func_short)  pcm_read_let2s ;
  241. psf->read_int    = (func_int)    pcm_read_let2i ;
  242. psf->read_double = (func_double) pcm_read_let2d ;
  243. } ;
  244. break ;
  246. case  AU_ENCODING_PCM_32 :
  247. psf->sf.pcmbitwidth = 32 ;
  248. psf->bytewidth      = BITWIDTH2BYTES (psf->sf.pcmbitwidth) ;
  249. psf->blockwidth = psf->sf.channels * psf->bytewidth ;
  251. psf->sf.format |= SF_FORMAT_PCM ;
  253. if (big_endian_file)
  254. { psf->read_short  = (func_short)  pcm_read_bei2s ;
  255. psf->read_int    = (func_int)    pcm_read_bei2i ;
  256. psf->read_double = (func_double) pcm_read_bei2d ;
  257. }
  258. else
  259. { psf->read_short  = (func_short)  pcm_read_lei2s ;
  260. psf->read_int    = (func_int)    pcm_read_lei2i ;
  261. psf->read_double = (func_double) pcm_read_lei2d ;
  262. } ;
  263. break ;
  265. case  AU_ENCODING_ALAW_8 :
  266. psf->sf.pcmbitwidth = 16 ; /* After decoding */
  267. psf->bytewidth    = 1 ; /* Before decoding */
  268. psf->blockwidth = psf->sf.channels * psf->bytewidth ;
  270. psf->sf.format |= SF_FORMAT_ALAW ;
  272. psf->read_short  = (func_short)  alaw_read_alaw2s ;
  273. psf->read_int    = (func_int)    alaw_read_alaw2i ;
  274. psf->read_double = (func_double) alaw_read_alaw2d ;
  275. break ;
  277. case  AU_ENCODING_ADPCM_G721_32 :  /* G721 32kbs ADPCM */
  278. if (psf->sf.channels != 1)
  279. { psf_sprintf (psf, "Channels != 1n") ;
  280. break ;
  281. } ;
  282. psf->sf.pcmbitwidth = 16 ; /* After decoding */
  284. psf->sf.format |= SF_FORMAT_G721_32 ;
  286. error = au_g72x_reader_init (psf, AU_H_G721_32) ;
  287. psf->sf.seekable = SF_FALSE ;
  288. break ;
  290. case  AU_ENCODING_ADPCM_G723_24 :  /* G723 24kbs ADPCM */
  291. if (psf->sf.channels != 1)
  292. { psf_sprintf (psf, "Channels != 1n") ;
  293. break ;
  294. } ;
  295. psf->sf.pcmbitwidth = 16 ; /* After decoding */
  297. psf->sf.format |= SF_FORMAT_G723_24 ;
  299. error = au_g72x_reader_init (psf, AU_H_G723_24) ;
  300. psf->sf.seekable = SF_FALSE ;
  301. break ;
  303. case  AU_ENCODING_NEXT :
  304. error = SFE_AU_UNKNOWN_FORMAT ;
  305. break ;
  307. default : 
  308. error = SFE_AU_UNKNOWN_FORMAT ;
  309. break ;
  310. } ;
  312. if (error)
  313. {
  314.     //or
  315.     if(force_open)
  316.     {
  317. error=SFE_NO_ERROR;
  318. psf->sf.format |= SF_FORCE_OPEN ;
  319.     
  320.     }
  321.     else
  322.     //end or
  323. return error ;
  324. }
  326. if (! psf->sf.samples && psf->blockwidth)
  327. psf->sf.samples = au_fmt.datasize / psf->blockwidth ;
  330. return 0 ;
  331. } /* au_open_read */
  333. /*------------------------------------------------------------------------------
  334. */
  336. int  au_nh_open_read (SF_PRIVATE *psf)
  337. { if (fseek (psf->file, psf->dataoffset, SEEK_SET))
  338. return SFE_BAD_SEEK ;
  340. psf_sprintf (psf, "Setting up for 8kHz, mono, u-law.n") ;
  342. psf->sf.format = SF_FORMAT_AU | SF_FORMAT_ULAW ;
  344.   psf->dataoffset = 0 ;
  345.   psf->current  = 0 ;
  346. psf->endian   = 0 ;  /* Irrelevant but it must be something. */
  347. psf->sf.seekable = SF_TRUE ;
  348. psf->sf.samplerate = 8000 ;
  349. psf->sf.channels  = 1 ;
  350. psf->sf.sections  = 1 ;
  351. psf->sf.pcmbitwidth = 16 ; /* After decoding */
  352. psf->bytewidth    = 1 ; /* Before decoding */
  354. psf->read_short  = (func_short)  ulaw_read_ulaw2s ;
  355. psf->read_int    = (func_int)    ulaw_read_ulaw2i ;
  356. psf->read_double = (func_double) ulaw_read_ulaw2d ;
  357. psf->close       = (func_close)  au_close ;
  359. psf->blockwidth = 1 ;
  360. psf->sf.samples = psf->filelength ;
  361. psf->datalength = psf->filelength ;
  363. return 0 ;
  364. } /* au_open_read */
  366. /*------------------------------------------------------------------------------
  367. */
  369. int  au_open_write (SF_PRIVATE *psf)
  370. { AU_FMT au_fmt ;
  371. unsigned int dword, encoding, format, subformat, big_endian_file ;
  372. int error = 0 ;
  374. format = psf->sf.format & SF_FORMAT_TYPEMASK ;
  375. subformat = psf->sf.format & SF_FORMAT_SUBMASK ;
  376. if (format == SF_FORMAT_AU)
  377. big_endian_file = 1 ;
  378. else if (format == SF_FORMAT_AULE)
  379. big_endian_file = 0 ;
  380. else
  381. return SFE_BAD_OPEN_FORMAT ;
  383. if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW || 
  384. subformat == SF_FORMAT_G721_32 || subformat == SF_FORMAT_G723_24)
  385. psf->bytewidth = 1 ;
  386. else
  387. //or
  388.     if(subformat == SF_FORCE_OPEN)
  389. psf->bytewidth = psf->sf.bytewidth;
  390.     else
  391. //end or    
  392. psf->bytewidth = BITWIDTH2BYTES (psf->sf.pcmbitwidth) ;
  394. psf->endian      = big_endian_file ? SF_ENDIAN_BIG : SF_ENDIAN_LITTLE ;
  395. psf->sf.seekable = SF_TRUE ;
  396. psf->blockwidth  = psf->bytewidth * psf->sf.channels ;
  397.   psf->dataoffset  = 6 * sizeof (dword) ;
  398. psf->datalength  = psf->blockwidth * psf->sf.samples ;
  399. psf->filelength  = psf->datalength + psf->dataoffset ;
  400. psf->error       = 0 ;
  402. //or
  403. if(subformat == SF_FORCE_OPEN)
  404.     encoding=psf->sf.format_tag;
  405. else
  406. //end or
  407.     encoding = get_encoding (subformat, psf->bytewidth * 8) ;
  408.     
  409. if (! encoding)
  410. return SFE_BAD_OPEN_FORMAT ;
  412. au_fmt.dataoffset = 24 ;
  413. au_fmt.datasize   = psf->datalength ;
  414. au_fmt.encoding   = encoding ;
  415. au_fmt.samplerate = psf->sf.samplerate ;
  416. au_fmt.channels   = psf->sf.channels ;
  418. if (CPU_IS_LITTLE_ENDIAN && big_endian_file)
  419. endswap_au_fmt (&au_fmt) ;
  420. else if (CPU_IS_BIG_ENDIAN && ! big_endian_file)
  421. endswap_au_fmt (&au_fmt) ;
  423. dword = big_endian_file ? DOTSND_MARKER : DNSDOT_MARKER ; /* Marker */
  424. fwrite (&dword, sizeof (dword), 1, psf->file) ;
  426. fwrite (&au_fmt, sizeof (AU_FMT), 1, psf->file) ;
  428. psf->close = (func_close) au_close ;
  430. switch (encoding)
  431. { case  AU_ENCODING_ULAW_8 : /* 8-bit Ulaw encoding. */
  432. psf->write_short  = (func_short)  ulaw_write_s2ulaw ;
  433. psf->write_int    = (func_int)    ulaw_write_i2ulaw ;
  434. psf->write_double = (func_double) ulaw_write_d2ulaw ;
  435. break ;
  437. case  AU_ENCODING_PCM_8 : /* 8-bit linear PCM. */
  438. psf->write_short  = (func_short)  pcm_write_s2sc ;
  439. psf->write_int    = (func_int)    pcm_write_i2sc ;
  440. psf->write_double = (func_double) pcm_write_d2sc ;
  441. break ;
  443. case  AU_ENCODING_PCM_16 : /* 16-bit linear PCM. */
  444. if (big_endian_file)
  445. { psf->write_short  = (func_short)  pcm_write_s2bes ;
  446. psf->write_int    = (func_int)    pcm_write_i2bes ;
  447. psf->write_double = (func_double) pcm_write_d2bes ;
  448. }
  449. else
  450. { psf->write_short  = (func_short)  pcm_write_s2les ;
  451. psf->write_int    = (func_int)    pcm_write_i2les ;
  452. psf->write_double = (func_double) pcm_write_d2les ;
  453. } ;
  454. break ;
  456. case  AU_ENCODING_PCM_24 : /* 24-bit linear PCM */
  457. if (big_endian_file)
  458. { psf->write_short  = (func_short)  pcm_write_s2bet ;
  459. psf->write_int    = (func_int)    pcm_write_i2bet ;
  460. psf->write_double = (func_double) pcm_write_d2bet ;
  461. }
  462. else
  463. { psf->write_short  = (func_short)  pcm_write_s2let ;
  464. psf->write_int    = (func_int)    pcm_write_i2let ;
  465. psf->write_double = (func_double) pcm_write_d2let ;
  466. } ;
  467. break ;
  469. case  AU_ENCODING_PCM_32 : /* 32-bit linear PCM. */
  470. if (big_endian_file)
  471. { psf->write_short  = (func_short)  pcm_write_s2bei ;
  472. psf->write_int    = (func_int)    pcm_write_i2bei ;
  473. psf->write_double = (func_double) pcm_write_d2bei ;
  474. }
  475. else
  476. { psf->write_short  = (func_short)  pcm_write_s2lei ;
  477. psf->write_int    = (func_int)    pcm_write_i2lei ;
  478. psf->write_double = (func_double) pcm_write_d2lei ;
  479. } ;
  480. break ;
  482. case  AU_ENCODING_ALAW_8 : /* 8-bit Alaw encoding. */
  483. psf->write_short  = (func_short)  alaw_write_s2alaw ;
  484. psf->write_int    = (func_int)    alaw_write_i2alaw ;
  485. psf->write_double = (func_double) alaw_write_d2alaw ;
  486. break ;
  488. case  AU_ENCODING_ADPCM_G721_32 :  
  489. if (psf->sf.channels != 1)
  490. { psf_sprintf (psf, "Channels != 1n") ;
  491. break ;
  492. } ;
  493. psf->sf.pcmbitwidth = 16 ; /* After decoding */
  494. psf->bytewidth    = 0 ;
  495. psf->blockwidth = psf->sf.channels * psf->bytewidth ;
  497. psf->sf.format |= SF_FORMAT_G721_32 ;
  499. error = au_g72x_writer_init (psf, AU_H_G721_32) ;
  500. break ;
  502. case  AU_ENCODING_ADPCM_G723_24 :  
  503. if (psf->sf.channels != 1)
  504. { psf_sprintf (psf, "Channels != 1n") ;
  505. break ;
  506. } ;
  507. psf->sf.pcmbitwidth = 16 ; /* After decoding */
  508. psf->bytewidth    = 0 ;
  509. psf->blockwidth = psf->sf.channels * psf->bytewidth ;
  511. psf->sf.format |= SF_FORMAT_G721_32 ;
  513. error = au_g72x_writer_init (psf, AU_H_G723_24) ;
  514. break ;
  516. default :   break ;
  517. } ;
  519. return error ;
  520. } /* au_open_write */
  522. /*------------------------------------------------------------------------------
  523. */
  525. int au_close (SF_PRIVATE  *psf)
  526. { unsigned int dword ;
  528. if (psf->mode == SF_MODE_WRITE)
  529. { /*  Now we know for certain the length of the file we can
  530.  *  re-write correct values for the datasize header element.
  531.  */
  533. fseek (psf->file, 0, SEEK_END) ;
  534. psf->filelength = ftell (psf->file) ;
  536. psf->datalength = psf->filelength - psf->dataoffset ;
  537. fseek (psf->file, 2 * sizeof (dword), SEEK_SET) ;
  539. if (psf->endian == SF_ENDIAN_BIG)
  540. dword = H2BE_INT (psf->datalength) ;
  541. else if (psf->endian == SF_ENDIAN_LITTLE)
  542. dword = H2LE_INT (psf->datalength) ;
  543. else
  544. dword = 0xFFFFFFFF ;
  545. fwrite (&dword, sizeof (dword), 1, psf->file) ;
  546. } ;
  548. if (psf->fdata)
  549. free (psf->fdata) ;
  550. psf->fdata = NULL ;
  552. return 0 ;
  553. } /* au_close */
  555. static
  556. int get_encoding (unsigned int format, unsigned int bitwidth)
  557. { if (format == SF_FORMAT_ULAW)
  558. return AU_ENCODING_ULAW_8 ;
  560. if (format == SF_FORMAT_ALAW)
  561. return AU_ENCODING_ALAW_8 ;
  563. if (format == SF_FORMAT_G721_32)
  564. return AU_ENCODING_ADPCM_G721_32 ;
  566. if (format == SF_FORMAT_G723_24)
  567. return AU_ENCODING_ADPCM_G723_24 ;
  569. if (format != SF_FORMAT_PCM)
  570. return 0 ;
  572. /* For PCM encoding, the header encoding field depends on the bitwidth. */
  573. switch (bitwidth)
  574. { case 8  : return AU_ENCODING_PCM_8 ;
  575. case 16 : return AU_ENCODING_PCM_16 ;
  576. case 24 : return AU_ENCODING_PCM_24 ;
  577. case 32 : return AU_ENCODING_PCM_32 ;
  578. default : break ;
  579. } ;
  580. return 0 ;
  581. } /* get encoding */
  583. static
  584. void endswap_au_fmt (AU_FMT *pau_fmt)
  585. { pau_fmt->dataoffset = ENDSWAP_INT (pau_fmt->dataoffset) ;
  586. pau_fmt->datasize   = ENDSWAP_INT (pau_fmt->datasize) ;
  587. pau_fmt->encoding   = ENDSWAP_INT (pau_fmt->encoding) ;
  588.     pau_fmt->samplerate = ENDSWAP_INT (pau_fmt->samplerate) ;
  589.     pau_fmt->channels   = ENDSWAP_INT (pau_fmt->channels) ;
  590. } /* endswap_au_fmt */
  592. static
  593. char* get_encoding_str (int format)
  594. { switch (format)
  595. { case  AU_ENCODING_ULAW_8 :
  596. return "8-bit ISDN u-law" ;
  598. case  AU_ENCODING_PCM_8 :
  599. return "8-bit linear PCM" ;
  601. case  AU_ENCODING_PCM_16 :
  602. return "16-bit linear PCM" ;
  604. case  AU_ENCODING_PCM_24 :
  605. return "24-bit linear PCM" ;
  607. case  AU_ENCODING_PCM_32 :
  608. return "32-bit linear PCM" ;
  610. case  AU_ENCODING_ALAW_8 :
  611. return "8-bit ISDN A-law" ;
  613. case  AU_ENCODING_ADPCM_G721_32 :  
  614. return "G721 32kbs ADPCM" ;
  616. case  AU_ENCODING_ADPCM_G723_24 :  
  617. return "G723 24kbs ADPCM" ;
  619. case  AU_ENCODING_NEXT :
  620. return "Weird NeXT encoding format (unsupported)" ;
  621. } ;
  622. return "Unknown!!" ;
  623. } /* get_encoding_str */