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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
SDL_wave.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：16k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

SDL_wave.c：源码内容
  1. /*
  2.     SDL - Simple DirectMedia Layer
  3.     Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002  Sam Lantinga
  5.     This library is free software; you can redistribute it and/or
  6.     modify it under the terms of the GNU Library General Public
  7.     License as published by the Free Software Foundation; either
  8.     version 2 of the License, or (at your option) any later version.
  10.     This library is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.     Library General Public License for more details.
  15.     You should have received a copy of the GNU Library General Public
  16.     License along with this library; if not, write to the Free
  17.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.     Sam Lantinga
  20.     slouken@libsdl.org
  21. */
  23. #ifdef SAVE_RCSID
  24. static char rcsid =
  25.  "@(#) $Id: SDL_wave.c,v 1.4 2002/04/22 21:38:02 wmay Exp $";
  26. #endif
  28. #ifndef DISABLE_FILE
  30. /* Microsoft WAVE file loading routines */
  32. #include <stdlib.h>
  33. #include <string.h>
  35. #include "SDL_error.h"
  36. #include "SDL_audio.h"
  37. #include "SDL_wave.h"
  38. #include "SDL_endian.h"
  40. #ifndef NELEMS
  41. #define NELEMS(array) ((sizeof array)/(sizeof array[0]))
  42. #endif
  44. static int ReadChunk(SDL_RWops *src, Chunk *chunk);
  46. struct MS_ADPCM_decodestate {
  47. Uint8 hPredictor;
  48. Uint16 iDelta;
  49. Sint16 iSamp1;
  50. Sint16 iSamp2;
  51. };
  52. static struct MS_ADPCM_decoder {
  53. WaveFMT wavefmt;
  54. Uint16 wSamplesPerBlock;
  55. Uint16 wNumCoef;
  56. Sint16 aCoeff[7][2];
  57. /* * * */
  58. struct MS_ADPCM_decodestate state[2];
  59. } MS_ADPCM_state;
  61. static int InitMS_ADPCM(WaveFMT *format)
  62. {
  63. Uint8 *rogue_feel;
  64. Uint16 extra_info;
  65. int i;
  67. /* Set the rogue pointer to the MS_ADPCM specific data */
  68. MS_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
  69. MS_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
  70. MS_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
  71. MS_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
  72. MS_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
  73. MS_ADPCM_state.wavefmt.bitspersample =
  74.  SDL_SwapLE16(format->bitspersample);
  75. rogue_feel = (Uint8 *)format+sizeof(*format);
  76. if ( sizeof(*format) == 16 ) {
  77. extra_info = ((rogue_feel[1]<<8)|rogue_feel[0]);
  78. rogue_feel += sizeof(Uint16);
  79. }
  80. MS_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1]<<8)|rogue_feel[0]);
  81. rogue_feel += sizeof(Uint16);
  82. MS_ADPCM_state.wNumCoef = ((rogue_feel[1]<<8)|rogue_feel[0]);
  83. rogue_feel += sizeof(Uint16);
  84. if ( MS_ADPCM_state.wNumCoef != 7 ) {
  85. SDL_SetError("Unknown set of MS_ADPCM coefficients");
  86. return(-1);
  87. }
  88. for ( i=0; i<MS_ADPCM_state.wNumCoef; ++i ) {
  89. MS_ADPCM_state.aCoeff[i][0] = ((rogue_feel[1]<<8)|rogue_feel[0]);
  90. rogue_feel += sizeof(Uint16);
  91. MS_ADPCM_state.aCoeff[i][1] = ((rogue_feel[1]<<8)|rogue_feel[0]);
  92. rogue_feel += sizeof(Uint16);
  93. }
  94. return(0);
  95. }
  97. static Sint32 MS_ADPCM_nibble(struct MS_ADPCM_decodestate *state,
  98. Uint8 nybble, Sint16 *coeff)
  99. {
  100. const Sint32 max_audioval = ((1<<(16-1))-1);
  101. const Sint32 min_audioval = -(1<<(16-1));
  102. const Sint32 adaptive[] = {
  103. 230, 230, 230, 230, 307, 409, 512, 614,
  104. 768, 614, 512, 409, 307, 230, 230, 230
  105. };
  106. Sint32 new_sample, delta;
  108. new_sample = ((state->iSamp1 * coeff[0]) +
  109.       (state->iSamp2 * coeff[1]))/256;
  110. if ( nybble & 0x08 ) {
  111. new_sample += state->iDelta * (nybble-0x10);
  112. } else {
  113. new_sample += state->iDelta * nybble;
  114. }
  115. if ( new_sample < min_audioval ) {
  116. new_sample = min_audioval;
  117. } else
  118. if ( new_sample > max_audioval ) {
  119. new_sample = max_audioval;
  120. }
  121. delta = ((Sint32)state->iDelta * adaptive[nybble])/256;
  122. if ( delta < 16 ) {
  123. delta = 16;
  124. }
  125. state->iDelta = delta;
  126. state->iSamp2 = state->iSamp1;
  127. state->iSamp1 = new_sample;
  128. return(new_sample);
  129. }
  131. static int MS_ADPCM_decode(Uint8 **audio_buf, Uint32 *audio_len)
  132. {
  133. struct MS_ADPCM_decodestate *state[2];
  134. Uint8 *freeable, *encoded, *decoded;
  135. Sint32 encoded_len, samplesleft;
  136. Sint8 nybble, stereo;
  137. Sint16 *coeff[2];
  138. Sint32 new_sample;
  140. /* Allocate the proper sized output buffer */
  141. encoded_len = *audio_len;
  142. encoded = *audio_buf;
  143. freeable = *audio_buf;
  144. *audio_len = (encoded_len/MS_ADPCM_state.wavefmt.blockalign) * 
  145. MS_ADPCM_state.wSamplesPerBlock*
  146. MS_ADPCM_state.wavefmt.channels*sizeof(Sint16);
  147. *audio_buf = (Uint8 *)malloc(*audio_len);
  148. if ( *audio_buf == NULL ) {
  149. SDL_Error(SDL_ENOMEM);
  150. return(-1);
  151. }
  152. decoded = *audio_buf;
  154. /* Get ready... Go! */
  155. stereo = (MS_ADPCM_state.wavefmt.channels == 2);
  156. state[0] = &MS_ADPCM_state.state[0];
  157. state[1] = &MS_ADPCM_state.state[stereo];
  158. while ( encoded_len >= MS_ADPCM_state.wavefmt.blockalign ) {
  159. /* Grab the initial information for this block */
  160. state[0]->hPredictor = *encoded++;
  161. if ( stereo ) {
  162. state[1]->hPredictor = *encoded++;
  163. }
  164. state[0]->iDelta = ((encoded[1]<<8)|encoded[0]);
  165. encoded += sizeof(Sint16);
  166. if ( stereo ) {
  167. state[1]->iDelta = ((encoded[1]<<8)|encoded[0]);
  168. encoded += sizeof(Sint16);
  169. }
  170. state[0]->iSamp1 = ((encoded[1]<<8)|encoded[0]);
  171. encoded += sizeof(Sint16);
  172. if ( stereo ) {
  173. state[1]->iSamp1 = ((encoded[1]<<8)|encoded[0]);
  174. encoded += sizeof(Sint16);
  175. }
  176. state[0]->iSamp2 = ((encoded[1]<<8)|encoded[0]);
  177. encoded += sizeof(Sint16);
  178. if ( stereo ) {
  179. state[1]->iSamp2 = ((encoded[1]<<8)|encoded[0]);
  180. encoded += sizeof(Sint16);
  181. }
  182. coeff[0] = MS_ADPCM_state.aCoeff[state[0]->hPredictor];
  183. coeff[1] = MS_ADPCM_state.aCoeff[state[1]->hPredictor];
  185. /* Store the two initial samples we start with */
  186. decoded[0] = state[0]->iSamp2&0xFF;
  187. decoded[1] = state[0]->iSamp2>>8;
  188. decoded += 2;
  189. if ( stereo ) {
  190. decoded[0] = state[1]->iSamp2&0xFF;
  191. decoded[1] = state[1]->iSamp2>>8;
  192. decoded += 2;
  193. }
  194. decoded[0] = state[0]->iSamp1&0xFF;
  195. decoded[1] = state[0]->iSamp1>>8;
  196. decoded += 2;
  197. if ( stereo ) {
  198. decoded[0] = state[1]->iSamp1&0xFF;
  199. decoded[1] = state[1]->iSamp1>>8;
  200. decoded += 2;
  201. }
  203. /* Decode and store the other samples in this block */
  204. samplesleft = (MS_ADPCM_state.wSamplesPerBlock-2)*
  205. MS_ADPCM_state.wavefmt.channels;
  206. while ( samplesleft > 0 ) {
  207. nybble = (*encoded)>>4;
  208. new_sample = MS_ADPCM_nibble(state[0],nybble,coeff[0]);
  209. decoded[0] = new_sample&0xFF;
  210. new_sample >>= 8;
  211. decoded[1] = new_sample&0xFF;
  212. decoded += 2;
  214. nybble = (*encoded)&0x0F;
  215. new_sample = MS_ADPCM_nibble(state[1],nybble,coeff[1]);
  216. decoded[0] = new_sample&0xFF;
  217. new_sample >>= 8;
  218. decoded[1] = new_sample&0xFF;
  219. decoded += 2;
  221. ++encoded;
  222. samplesleft -= 2;
  223. }
  224. encoded_len -= MS_ADPCM_state.wavefmt.blockalign;
  225. }
  226. free(freeable);
  227. return(0);
  228. }
  230. struct IMA_ADPCM_decodestate {
  231. Sint32 sample;
  232. Sint8 index;
  233. };
  234. static struct IMA_ADPCM_decoder {
  235. WaveFMT wavefmt;
  236. Uint16 wSamplesPerBlock;
  237. /* * * */
  238. struct IMA_ADPCM_decodestate state[2];
  239. } IMA_ADPCM_state;
  241. static int InitIMA_ADPCM(WaveFMT *format)
  242. {
  243. Uint8 *rogue_feel;
  244. Uint16 extra_info;
  246. /* Set the rogue pointer to the IMA_ADPCM specific data */
  247. IMA_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
  248. IMA_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
  249. IMA_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
  250. IMA_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
  251. IMA_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
  252. IMA_ADPCM_state.wavefmt.bitspersample =
  253.  SDL_SwapLE16(format->bitspersample);
  254. rogue_feel = (Uint8 *)format+sizeof(*format);
  255. if ( sizeof(*format) == 16 ) {
  256. extra_info = ((rogue_feel[1]<<8)|rogue_feel[0]);
  257. rogue_feel += sizeof(Uint16);
  258. }
  259. IMA_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1]<<8)|rogue_feel[0]);
  260. return(0);
  261. }
  263. static Sint32 IMA_ADPCM_nibble(struct IMA_ADPCM_decodestate *state,Uint8 nybble)
  264. {
  265. const Sint32 max_audioval = ((1<<(16-1))-1);
  266. const Sint32 min_audioval = -(1<<(16-1));
  267. const int index_table[16] = {
  268. -1, -1, -1, -1,
  269.  2,  4,  6,  8,
  270. -1, -1, -1, -1,
  271.  2,  4,  6,  8
  272. };
  273. const Sint32 step_table[89] = {
  274. 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
  275. 34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130,
  276. 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408,
  277. 449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
  278. 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
  279. 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630,
  280. 9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
  281. 22385, 24623, 27086, 29794, 32767
  282. };
  283. Sint32 delta, step;
  285. /* Compute difference and new sample value */
  286. step = step_table[state->index];
  287. delta = step >> 3;
  288. if ( nybble & 0x04 ) delta += step;
  289. if ( nybble & 0x02 ) delta += (step >> 1);
  290. if ( nybble & 0x01 ) delta += (step >> 2);
  291. if ( nybble & 0x08 ) delta = -delta;
  292. state->sample += delta;
  294. /* Update index value */
  295. state->index += index_table[nybble];
  296. if ( state->index > 88 ) {
  297. state->index = 88;
  298. } else
  299. if ( state->index < 0 ) {
  300. state->index = 0;
  301. }
  303. /* Clamp output sample */
  304. if ( state->sample > max_audioval ) {
  305. state->sample = max_audioval;
  306. } else
  307. if ( state->sample < min_audioval ) {
  308. state->sample = min_audioval;
  309. }
  310. return(state->sample);
  311. }
  313. /* Fill the decode buffer with a channel block of data (8 samples) */
  314. static void Fill_IMA_ADPCM_block(Uint8 *decoded, Uint8 *encoded,
  315. int channel, int numchannels, struct IMA_ADPCM_decodestate *state)
  316. {
  317. int i;
  318. Sint8 nybble;
  319. Sint32 new_sample;
  321. decoded += (channel * 2);
  322. for ( i=0; i<4; ++i ) {
  323. nybble = (*encoded)&0x0F;
  324. new_sample = IMA_ADPCM_nibble(state, nybble);
  325. decoded[0] = new_sample&0xFF;
  326. new_sample >>= 8;
  327. decoded[1] = new_sample&0xFF;
  328. decoded += 2 * numchannels;
  330. nybble = (*encoded)>>4;
  331. new_sample = IMA_ADPCM_nibble(state, nybble);
  332. decoded[0] = new_sample&0xFF;
  333. new_sample >>= 8;
  334. decoded[1] = new_sample&0xFF;
  335. decoded += 2 * numchannels;
  337. ++encoded;
  338. }
  339. }
  341. static int IMA_ADPCM_decode(Uint8 **audio_buf, Uint32 *audio_len)
  342. {
  343. struct IMA_ADPCM_decodestate *state;
  344. Uint8 *freeable, *encoded, *decoded;
  345. Sint32 encoded_len, samplesleft;
  346. int c, channels;
  348. /* Check to make sure we have enough variables in the state array */
  349. channels = IMA_ADPCM_state.wavefmt.channels;
  350. if ( channels > NELEMS(IMA_ADPCM_state.state) ) {
  351. SDL_SetError("IMA ADPCM decoder can only handle %d channels",
  352. NELEMS(IMA_ADPCM_state.state));
  353. return(-1);
  354. }
  355. state = IMA_ADPCM_state.state;
  357. /* Allocate the proper sized output buffer */
  358. encoded_len = *audio_len;
  359. encoded = *audio_buf;
  360. freeable = *audio_buf;
  361. *audio_len = (encoded_len/IMA_ADPCM_state.wavefmt.blockalign) * 
  362. IMA_ADPCM_state.wSamplesPerBlock*
  363. IMA_ADPCM_state.wavefmt.channels*sizeof(Sint16);
  364. *audio_buf = (Uint8 *)malloc(*audio_len);
  365. if ( *audio_buf == NULL ) {
  366. SDL_Error(SDL_ENOMEM);
  367. return(-1);
  368. }
  369. decoded = *audio_buf;
  371. /* Get ready... Go! */
  372. while ( encoded_len >= IMA_ADPCM_state.wavefmt.blockalign ) {
  373. /* Grab the initial information for this block */
  374. for ( c=0; c<channels; ++c ) {
  375. /* Fill the state information for this block */
  376. state[c].sample = ((encoded[1]<<8)|encoded[0]);
  377. encoded += 2;
  378. if ( state[c].sample & 0x8000 ) {
  379. state[c].sample -= 0x10000;
  380. }
  381. state[c].index = *encoded++;
  382. /* Reserved byte in buffer header, should be 0 */
  383. if ( *encoded++ != 0 ) {
  384. /* Uh oh, corrupt data?  Buggy code? */;
  385. }
  387. /* Store the initial sample we start with */
  388. decoded[0] = state[c].sample&0xFF;
  389. decoded[1] = state[c].sample>>8;
  390. decoded += 2;
  391. }
  393. /* Decode and store the other samples in this block */
  394. samplesleft = (IMA_ADPCM_state.wSamplesPerBlock-1)*channels;
  395. while ( samplesleft > 0 ) {
  396. for ( c=0; c<channels; ++c ) {
  397. Fill_IMA_ADPCM_block(decoded, encoded,
  398. c, channels, &state[c]);
  399. encoded += 4;
  400. samplesleft -= 8;
  401. }
  402. decoded += (channels * 8 * 2);
  403. }
  404. encoded_len -= IMA_ADPCM_state.wavefmt.blockalign;
  405. }
  406. free(freeable);
  407. return(0);
  408. }
  410. SDL_AudioSpec * SDL_LoadWAV_RW (SDL_RWops *src, int freesrc,
  411. SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
  412. {
  413. int was_error;
  414. Chunk chunk;
  415. int lenread;
  416. int MS_ADPCM_encoded, IMA_ADPCM_encoded;
  417. int samplesize;
  419. /* WAV magic header */
  420. Uint32 RIFFchunk;
  421. Uint32 wavelen;
  422. Uint32 WAVEmagic;
  424. /* FMT chunk */
  425. WaveFMT *format = NULL;
  427. /* Make sure we are passed a valid data source */
  428. was_error = 0;
  429. if ( src == NULL ) {
  430. was_error = 1;
  431. goto done;
  432. }
  434. /* Check the magic header */
  435. RIFFchunk = SDL_ReadLE32(src);
  436. wavelen = SDL_ReadLE32(src);
  437. if ( wavelen == WAVE ) { /* The RIFFchunk has already been read */
  438. WAVEmagic = wavelen;
  439. wavelen   = RIFFchunk;
  440. RIFFchunk = RIFF;
  441. } else {
  442. WAVEmagic = SDL_ReadLE32(src);
  443. }
  444. if ( (RIFFchunk != RIFF) || (WAVEmagic != WAVE) ) {
  445. SDL_SetError("Unrecognized file type (not WAVE)");
  446. was_error = 1;
  447. goto done;
  448. }
  450. /* Read the audio data format chunk */
  451. chunk.data = NULL;
  452. do {
  453. if ( chunk.data != NULL ) {
  454. free(chunk.data);
  455. }
  456. lenread = ReadChunk(src, &chunk);
  457. if ( lenread < 0 ) {
  458. was_error = 1;
  459. goto done;
  460. }
  461. } while ( (chunk.magic == FACT) || (chunk.magic == LIST) );
  463. /* Decode the audio data format */
  464. format = (WaveFMT *)chunk.data;
  465. if ( chunk.magic != FMT ) {
  466. SDL_SetError("Complex WAVE files not supported");
  467. was_error = 1;
  468. goto done;
  469. }
  470. MS_ADPCM_encoded = IMA_ADPCM_encoded = 0;
  471. switch (SDL_SwapLE16(format->encoding)) {
  472. case PCM_CODE:
  473. /* We can understand this */
  474. break;
  475. case MS_ADPCM_CODE:
  476. /* Try to understand this */
  477. if ( InitMS_ADPCM(format) < 0 ) {
  478. was_error = 1;
  479. goto done;
  480. }
  481. MS_ADPCM_encoded = 1;
  482. break;
  483. case IMA_ADPCM_CODE:
  484. /* Try to understand this */
  485. if ( InitIMA_ADPCM(format) < 0 ) {
  486. was_error = 1;
  487. goto done;
  488. }
  489. IMA_ADPCM_encoded = 1;
  490. break;
  491. default:
  492. SDL_SetError("Unknown WAVE data format: 0x%.4x",
  493. SDL_SwapLE16(format->encoding));
  494. was_error = 1;
  495. goto done;
  496. }
  497. memset(spec, 0, (sizeof *spec));
  498. spec->freq = SDL_SwapLE32(format->frequency);
  499. switch (SDL_SwapLE16(format->bitspersample)) {
  500. case 4:
  501. if ( MS_ADPCM_encoded || IMA_ADPCM_encoded ) {
  502. spec->format = AUDIO_S16;
  503. } else {
  504. was_error = 1;
  505. }
  506. break;
  507. case 8:
  508. spec->format = AUDIO_U8;
  509. break;
  510. case 16:
  511. spec->format = AUDIO_S16;
  512. break;
  513. default:
  514. was_error = 1;
  515. break;
  516. }
  517. if ( was_error ) {
  518. SDL_SetError("Unknown %d-bit PCM data format",
  519. SDL_SwapLE16(format->bitspersample));
  520. goto done;
  521. }
  522. spec->channels = (Uint8)SDL_SwapLE16(format->channels);
  523. spec->samples = 4096; /* Good default buffer size */
  525. /* Read the audio data chunk */
  526. *audio_buf = NULL;
  527. do {
  528. if ( *audio_buf != NULL ) {
  529. free(*audio_buf);
  530. }
  531. lenread = ReadChunk(src, &chunk);
  532. if ( lenread < 0 ) {
  533. was_error = 1;
  534. goto done;
  535. }
  536. *audio_len = lenread;
  537. *audio_buf = chunk.data;
  538. } while ( chunk.magic != DATA );
  540. if ( MS_ADPCM_encoded ) {
  541. if ( MS_ADPCM_decode(audio_buf, audio_len) < 0 ) {
  542. was_error = 1;
  543. goto done;
  544. }
  545. }
  546. if ( IMA_ADPCM_encoded ) {
  547. if ( IMA_ADPCM_decode(audio_buf, audio_len) < 0 ) {
  548. was_error = 1;
  549. goto done;
  550. }
  551. }
  553. /* Don't return a buffer that isn't a multiple of samplesize */
  554. samplesize = ((spec->format & 0xFF)/8)*spec->channels;
  555. *audio_len &= ~(samplesize-1);
  557. done:
  558. if ( format != NULL ) {
  559. free(format);
  560. }
  561. if ( freesrc && src ) {
  562. SDL_RWclose(src);
  563. }
  564. if ( was_error ) {
  565. spec = NULL;
  566. }
  567. return(spec);
  568. }
  570. /* Since the WAV memory is allocated in the shared library, it must also
  571.    be freed here.  (Necessary under Win32, VC++)
  572.  */
  573. void SDL_FreeWAV(Uint8 *audio_buf)
  574. {
  575. if ( audio_buf != NULL ) {
  576. free(audio_buf);
  577. }
  578. }
  580. static int ReadChunk(SDL_RWops *src, Chunk *chunk)
  581. {
  582. chunk->magic = SDL_ReadLE32(src);
  583. chunk->length = SDL_ReadLE32(src);
  584. chunk->data = (Uint8 *)malloc(chunk->length);
  585. if ( chunk->data == NULL ) {
  586. SDL_Error(SDL_ENOMEM);
  587. return(-1);
  588. }
  589. if ( SDL_RWread(src, chunk->data, chunk->length, 1) != 1 ) {
  590. SDL_Error(SDL_EFREAD);
  591. free(chunk->data);
  592. return(-1);
  593. }
  594. return(chunk->length);
  595. }
  597. #endif /* ENABLE_FILE */