1 /*
2 ** Copyright (C) 2001-2018 Erik de Castro Lopo <erikd@mega-nerd.com>
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 */
18
19 /* RANT:
20 ** The VOC file format is the most brain damaged format I have yet had to deal
21 ** with. No one programmer could have bee stupid enough to put this together.
22 ** Instead it looks like a series of manic, dyslexic assembly language programmers
23 ** hacked it to fit their needs.
24 ** Utterly woeful.
25 */
26
27 #include "sfconfig.h"
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #include "sndfile.h"
34 #include "sfendian.h"
35 #include "common.h"
36
37
38 /*------------------------------------------------------------------------------
39 * Typedefs for file chunks.
40 */
41
42 #define VOC_MAX_SECTIONS 200
43
44 enum
45 { VOC_TERMINATOR = 0,
46 VOC_SOUND_DATA = 1,
47 VOC_SOUND_CONTINUE = 2,
48 VOC_SILENCE = 3,
49 VOC_MARKER = 4,
50 VOC_ASCII = 5,
51 VOC_REPEAT = 6,
52 VOC_END_REPEAT = 7,
53 VOC_EXTENDED = 8,
54 VOC_EXTENDED_II = 9
55 } ;
56
57 typedef struct
58 { int samples ;
59 int offset ; /* Offset of zero => silence. */
60 } SND_DATA_BLOCKS ;
61
62 typedef struct
63 { unsigned int sections, section_types ;
64 int samplerate, channels, bitwidth ;
65 SND_DATA_BLOCKS blocks [VOC_MAX_SECTIONS] ;
66 } VOC_DATA ;
67
68 /*------------------------------------------------------------------------------
69 * Private static functions.
70 */
71
72 static int voc_close (SF_PRIVATE *psf) ;
73 static int voc_write_header (SF_PRIVATE *psf, int calc_length) ;
74 static int voc_read_header (SF_PRIVATE *psf) ;
75
76 static const char* voc_encoding2str (int encoding) ;
77
78 #if 0
79
80 /* These functions would be required for files with more than one VOC_SOUND_DATA
81 ** segment. Not sure whether to bother implementing this.
82 */
83
84 static int voc_multi_init (SF_PRIVATE *psf, VOC_DATA *pvoc) ;
85
86 static int voc_multi_read_uc2s (SF_PRIVATE *psf, short *ptr, int len) ;
87 static int voc_multi_read_les2s (SF_PRIVATE *psf, short *ptr, int len) ;
88
89 static int voc_multi_read_uc2i (SF_PRIVATE *psf, int *ptr, int len) ;
90 static int voc_multi_read_les2i (SF_PRIVATE *psf, int *ptr, int len) ;
91
92 static int voc_multi_read_uc2f (SF_PRIVATE *psf, float *ptr, int len) ;
93 static int voc_multi_read_les2f (SF_PRIVATE *psf, float *ptr, int len) ;
94
95 static int voc_multi_read_uc2d (SF_PRIVATE *psf, double *ptr, int len) ;
96 static int voc_multi_read_les2d (SF_PRIVATE *psf, double *ptr, int len) ;
97 #endif
98
99 /*------------------------------------------------------------------------------
100 ** Public function.
101 */
102
103 int
voc_open(SF_PRIVATE * psf)104 voc_open (SF_PRIVATE *psf)
105 { int subformat, error = 0 ;
106
107 if (psf->is_pipe)
108 return SFE_VOC_NO_PIPE ;
109
110 if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
111 { if ((error = voc_read_header (psf)))
112 return error ;
113 } ;
114
115 subformat = SF_CODEC (psf->sf.format) ;
116
117 if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
118 { if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_VOC)
119 return SFE_BAD_OPEN_FORMAT ;
120
121 psf->endian = SF_ENDIAN_LITTLE ;
122
123 if ((error = voc_write_header (psf, SF_FALSE)))
124 return error ;
125
126 psf->write_header = voc_write_header ;
127 } ;
128
129 psf->blockwidth = psf->bytewidth * psf->sf.channels ;
130
131 psf->container_close = voc_close ;
132
133 switch (subformat)
134 { case SF_FORMAT_PCM_U8 :
135 case SF_FORMAT_PCM_16 :
136 error = pcm_init (psf) ;
137 break ;
138
139 case SF_FORMAT_ALAW :
140 error = alaw_init (psf) ;
141 break ;
142
143 case SF_FORMAT_ULAW :
144 error = ulaw_init (psf) ;
145 break ;
146
147 default : return SFE_UNIMPLEMENTED ;
148 } ;
149
150 return error ;
151 } /* voc_open */
152
153 /*------------------------------------------------------------------------------
154 */
155
156 static int
voc_read_header(SF_PRIVATE * psf)157 voc_read_header (SF_PRIVATE *psf)
158 { VOC_DATA *pvoc ;
159 char creative [20] ;
160 unsigned char block_type, rate_byte ;
161 short version, checksum, encoding, dataoffset ;
162 int offset ;
163
164 /* Set position to start of file to begin reading header. */
165 offset = psf_binheader_readf (psf, "pb", 0, creative, SIGNED_SIZEOF (creative)) ;
166
167 if (creative [sizeof (creative) - 1] != 0x1A)
168 return SFE_VOC_NO_CREATIVE ;
169
170 /* Terminate the string. */
171 creative [sizeof (creative) - 1] = 0 ;
172
173 if (strcmp ("Creative Voice File", creative))
174 return SFE_VOC_NO_CREATIVE ;
175
176 psf_log_printf (psf, "%s\n", creative) ;
177
178 offset += psf_binheader_readf (psf, "e222", &dataoffset, &version, &checksum) ;
179
180 psf->dataoffset = dataoffset ;
181
182 psf_log_printf (psf, "dataoffset : %d\n"
183 "version : 0x%X\n"
184 "checksum : 0x%X\n", psf->dataoffset, version, checksum) ;
185
186 if (version != 0x010A && version != 0x0114)
187 return SFE_VOC_BAD_VERSION ;
188
189 if (! (psf->codec_data = malloc (sizeof (VOC_DATA))))
190 return SFE_MALLOC_FAILED ;
191
192 pvoc = (VOC_DATA*) psf->codec_data ;
193
194 memset (pvoc, 0, sizeof (VOC_DATA)) ;
195
196 /* Set the default encoding now. */
197 psf->sf.format = SF_FORMAT_VOC ; /* Major format */
198 encoding = SF_FORMAT_PCM_U8 ; /* Minor format */
199 psf->endian = SF_ENDIAN_LITTLE ;
200
201 while (1)
202 { char header [256] ;
203 unsigned size ;
204 short count ;
205
206 block_type = 0 ;
207 offset += psf_binheader_readf (psf, "1", &block_type) ;
208
209 switch (block_type)
210 { case VOC_ASCII :
211 offset += psf_binheader_readf (psf, "e3", &size) ;
212
213 psf_log_printf (psf, " ASCII : %d\n", size) ;
214
215 if (size < sizeof (header) - 1)
216 { offset += psf_binheader_readf (psf, "b", header, size) ;
217 header [size] = 0 ;
218 psf_log_printf (psf, " text : %s\n", header) ;
219 continue ;
220 }
221
222 offset += psf_binheader_readf (psf, "j", size) ;
223 continue ;
224
225 case VOC_REPEAT :
226 offset += psf_binheader_readf (psf, "e32", &size, &count) ;
227 psf_log_printf (psf, " Repeat : %d\n", count) ;
228 continue ;
229
230 case VOC_SOUND_DATA :
231 case VOC_EXTENDED :
232 case VOC_EXTENDED_II :
233 break ;
234
235 default : psf_log_printf (psf, "*** Weird block marker (%d)\n", block_type) ;
236 } ;
237
238 break ;
239 } ;
240
241 if (block_type == VOC_SOUND_DATA)
242 { unsigned char compression ;
243 int size ;
244
245 offset += psf_binheader_readf (psf, "e311", &size, &rate_byte, &compression) ;
246
247 psf->sf.samplerate = 1000000 / (256 - (rate_byte & 0xFF)) ;
248
249 psf_log_printf (psf, " Sound Data : %d\n sr : %d => %dHz\n comp : %d\n",
250 size, rate_byte, psf->sf.samplerate, compression) ;
251
252 if (offset + size - 1 > psf->filelength)
253 { psf_log_printf (psf, "Seems to be a truncated file.\n") ;
254 psf_log_printf (psf, "offset: %d size: %d sum: %d filelength: %D\n", offset, size, offset + size, psf->filelength) ;
255 return SFE_VOC_BAD_SECTIONS ;
256 }
257 else if (psf->filelength - offset - size > 4)
258 { psf_log_printf (psf, "Seems to be a multi-segment file (#1).\n") ;
259 psf_log_printf (psf, "offset: %d size: %d sum: %d filelength: %D\n", offset, size, offset + size, psf->filelength) ;
260 return SFE_VOC_BAD_SECTIONS ;
261 } ;
262
263 psf->dataoffset = offset ;
264 psf->dataend = psf->filelength - 1 ;
265
266 psf->sf.channels = 1 ;
267 psf->bytewidth = 1 ;
268
269 psf->sf.format = SF_FORMAT_VOC | SF_FORMAT_PCM_U8 ;
270
271 return 0 ;
272 } ;
273
274 if (block_type == VOC_EXTENDED)
275 { unsigned char pack, stereo, compression ;
276 unsigned short rate_short ;
277 int size ;
278
279 offset += psf_binheader_readf (psf, "e3211", &size, &rate_short, &pack, &stereo) ;
280
281 psf_log_printf (psf, " Extended : %d\n", size) ;
282 if (size == 4)
283 psf_log_printf (psf, " size : 4\n") ;
284 else
285 psf_log_printf (psf, " size : %d (should be 4)\n", size) ;
286
287 psf_log_printf (psf, " pack : %d\n"
288 " stereo : %s\n", pack, (stereo ? "yes" : "no")) ;
289
290 if (stereo)
291 { psf->sf.channels = 2 ;
292 psf->sf.samplerate = 128000000 / (65536 - rate_short) ;
293 }
294 else
295 { psf->sf.channels = 1 ;
296 psf->sf.samplerate = 256000000 / (65536 - rate_short) ;
297 } ;
298
299 psf_log_printf (psf, " sr : %d => %dHz\n", (rate_short & 0xFFFF), psf->sf.samplerate) ;
300
301 offset += psf_binheader_readf (psf, "1", &block_type) ;
302
303 if (block_type != VOC_SOUND_DATA)
304 { psf_log_printf (psf, "*** Expecting VOC_SOUND_DATA section.\n") ;
305 return SFE_VOC_BAD_FORMAT ;
306 } ;
307
308 offset += psf_binheader_readf (psf, "e311", &size, &rate_byte, &compression) ;
309
310 psf_log_printf (psf, " Sound Data : %d\n"
311 " sr : %d\n"
312 " comp : %d\n", size, rate_byte, compression) ;
313
314
315 if (offset + size - 1 > psf->filelength)
316 { psf_log_printf (psf, "Seems to be a truncated file.\n") ;
317 psf_log_printf (psf, "offset: %d size: %d sum: %d filelength: %D\n", offset, size, offset + size, psf->filelength) ;
318 return SFE_VOC_BAD_SECTIONS ;
319 }
320 else if (offset + size - 1 < psf->filelength)
321 { psf_log_printf (psf, "Seems to be a multi-segment file (#2).\n") ;
322 psf_log_printf (psf, "offset: %d size: %d sum: %d filelength: %D\n", offset, size, offset + size, psf->filelength) ;
323 return SFE_VOC_BAD_SECTIONS ;
324 } ;
325
326 psf->dataoffset = offset ;
327 psf->dataend = psf->filelength - 1 ;
328
329 psf->bytewidth = 1 ;
330
331 psf->sf.format = SF_FORMAT_VOC | SF_FORMAT_PCM_U8 ;
332
333 return 0 ;
334 }
335
336 if (block_type == VOC_EXTENDED_II)
337 { unsigned char bitwidth, channels ;
338 int size, fourbytes ;
339
340 offset += psf_binheader_readf (psf, "e341124", &size, &psf->sf.samplerate,
341 &bitwidth, &channels, &encoding, &fourbytes) ;
342
343 if (size * 2 == psf->filelength - 39)
344 { int temp_size = psf->filelength - 31 ;
345
346 psf_log_printf (psf, " Extended II : %d (SoX bug: should be %d)\n", size, temp_size) ;
347 size = temp_size ;
348 }
349 else
350 psf_log_printf (psf, " Extended II : %d\n", size) ;
351
352 psf_log_printf (psf, " sample rate : %d\n"
353 " bit width : %d\n"
354 " channels : %d\n", psf->sf.samplerate, bitwidth, channels) ;
355
356 if (bitwidth == 16 && encoding == 0)
357 { encoding = 4 ;
358 psf_log_printf (psf, " encoding : 0 (SoX bug: should be 4 for 16 bit signed PCM)\n") ;
359 }
360 else
361 psf_log_printf (psf, " encoding : %d => %s\n", encoding, voc_encoding2str (encoding)) ;
362
363
364 psf_log_printf (psf, " fourbytes : %X\n", fourbytes) ;
365
366 psf->sf.channels = channels ;
367
368 psf->dataoffset = offset ;
369 psf->dataend = psf->filelength - 1 ;
370
371 if (size + 31 == psf->filelength + 1)
372 { /* Hack for reading files produced using
373 ** sf_command (SFC_UPDATE_HEADER_NOW).
374 */
375 psf_log_printf (psf, "Missing zero byte at end of file.\n") ;
376 size = psf->filelength - 30 ;
377 psf->dataend = 0 ;
378 }
379 else if (size + 31 > psf->filelength)
380 { psf_log_printf (psf, "Seems to be a truncated file.\n") ;
381 size = psf->filelength - 31 ;
382 }
383 else if (size + 31 < psf->filelength)
384 psf_log_printf (psf, "Seems to be a multi-segment file (#3).\n") ;
385
386 switch (encoding)
387 { case 0 :
388 psf->sf.format = SF_FORMAT_VOC | SF_FORMAT_PCM_U8 ;
389 psf->bytewidth = 1 ;
390 break ;
391
392 case 4 :
393 psf->sf.format = SF_FORMAT_VOC | SF_FORMAT_PCM_16 ;
394 psf->bytewidth = 2 ;
395 break ;
396
397 case 6 :
398 psf->sf.format = SF_FORMAT_VOC | SF_FORMAT_ALAW ;
399 psf->bytewidth = 1 ;
400 break ;
401
402 case 7 :
403 psf->sf.format = SF_FORMAT_VOC | SF_FORMAT_ULAW ;
404 psf->bytewidth = 1 ;
405 break ;
406
407 default : /* Unknown */
408 return SFE_VOC_BAD_FORMAT ;
409 break ;
410 } ;
411
412 } ;
413
414 return 0 ;
415 } /* voc_read_header */
416
417 /*====================================================================================
418 */
419
420 static int
voc_write_header(SF_PRIVATE * psf,int calc_length)421 voc_write_header (SF_PRIVATE *psf, int calc_length)
422 { sf_count_t current ;
423 int rate_const, subformat ;
424
425 current = psf_ftell (psf) ;
426
427 if (calc_length)
428 { psf->filelength = psf_get_filelen (psf) ;
429
430 psf->datalength = psf->filelength - psf->dataoffset ;
431 if (psf->dataend)
432 psf->datalength -= psf->filelength - psf->dataend ;
433
434 psf->sf.frames = psf->datalength / (psf->bytewidth * psf->sf.channels) ;
435 } ;
436
437 subformat = SF_CODEC (psf->sf.format) ;
438 /* Reset the current header length to zero. */
439 psf->header.ptr [0] = 0 ;
440 psf->header.indx = 0 ;
441 psf_fseek (psf, 0, SEEK_SET) ;
442
443 /* VOC marker and 0x1A byte. */
444 psf_binheader_writef (psf, "eb1", BHWv ("Creative Voice File"), BHWz (19), BHW1 (0x1A)) ;
445
446 /* Data offset, version and other. */
447 psf_binheader_writef (psf, "e222", BHW2 (26), BHW2 (0x0114), BHW2 (0x111F)) ;
448
449 /* Use same logic as SOX.
450 ** If the file is mono 8 bit data, use VOC_SOUND_DATA.
451 ** If the file is mono 16 bit data, use VOC_EXTENED.
452 ** Otherwise use VOC_EXTENED_2.
453 */
454
455 if (subformat == SF_FORMAT_PCM_U8 && psf->sf.channels == 1)
456 { /* samplerate = 1000000 / (256 - rate_const) ; */
457 rate_const = 256 - 1000000 / psf->sf.samplerate ;
458
459 /* First type marker, length, rate_const and compression */
460 psf_binheader_writef (psf, "e1311", BHW1 (VOC_SOUND_DATA), BHW3 ((int) (psf->datalength + 1)), BHW1 (rate_const), BHW1 (0)) ;
461 }
462 else if (subformat == SF_FORMAT_PCM_U8 && psf->sf.channels == 2)
463 { /* sample_rate = 128000000 / (65536 - rate_short) ; */
464 rate_const = 65536 - 128000000 / psf->sf.samplerate ;
465
466 /* First write the VOC_EXTENDED section
467 ** marker, length, rate_const and compression
468 */
469 psf_binheader_writef (psf, "e13211", BHW1 (VOC_EXTENDED), BHW3 (4), BHW2 (rate_const), BHW1 (0), BHW1 (1)) ;
470
471 /* samplerate = 1000000 / (256 - rate_const) ; */
472 rate_const = 256 - 1000000 / psf->sf.samplerate ;
473
474 /* Now write the VOC_SOUND_DATA section
475 ** marker, length, rate_const and compression
476 */
477 psf_binheader_writef (psf, "e1311", BHW1 (VOC_SOUND_DATA), BHW3 ((int) (psf->datalength + 1)), BHW1 (rate_const), BHW1 (0)) ;
478 }
479 else
480 { int length ;
481
482 if (psf->sf.channels < 1 || psf->sf.channels > 2)
483 return SFE_CHANNEL_COUNT ;
484
485 switch (subformat)
486 { case SF_FORMAT_PCM_U8 :
487 psf->bytewidth = 1 ;
488 length = psf->sf.frames * psf->sf.channels * psf->bytewidth + 12 ;
489 /* Marker, length, sample rate, bitwidth, stereo flag, encoding and fourt zero bytes. */
490 psf_binheader_writef (psf, "e1341124", BHW1 (VOC_EXTENDED_II), BHW3 (length), BHW4 (psf->sf.samplerate), BHW1 (16), BHW1 (psf->sf.channels), BHW2 (4), BHW4 (0)) ;
491 break ;
492
493 case SF_FORMAT_PCM_16 :
494 psf->bytewidth = 2 ;
495 length = psf->sf.frames * psf->sf.channels * psf->bytewidth + 12 ;
496 /* Marker, length, sample rate, bitwidth, stereo flag, encoding and fourt zero bytes. */
497 psf_binheader_writef (psf, "e1341124", BHW1 (VOC_EXTENDED_II), BHW3 (length), BHW4 (psf->sf.samplerate), BHW1 (16), BHW1 (psf->sf.channels), BHW2 (4), BHW4 (0)) ;
498 break ;
499
500 case SF_FORMAT_ALAW :
501 psf->bytewidth = 1 ;
502 length = psf->sf.frames * psf->sf.channels * psf->bytewidth + 12 ;
503 psf_binheader_writef (psf, "e1341124", BHW1 (VOC_EXTENDED_II), BHW3 (length), BHW4 (psf->sf.samplerate), BHW1 (8), BHW1 (psf->sf.channels), BHW2 (6), BHW4 (0)) ;
504 break ;
505
506 case SF_FORMAT_ULAW :
507 psf->bytewidth = 1 ;
508 length = psf->sf.frames * psf->sf.channels * psf->bytewidth + 12 ;
509 psf_binheader_writef (psf, "e1341124", BHW1 (VOC_EXTENDED_II), BHW3 (length), BHW4 (psf->sf.samplerate), BHW1 (8), BHW1 (psf->sf.channels), BHW2 (7), BHW4 (0)) ;
510 break ;
511
512 default : return SFE_UNIMPLEMENTED ;
513 } ;
514 } ;
515
516 psf_fwrite (psf->header.ptr, psf->header.indx, 1, psf) ;
517
518 if (psf->error)
519 return psf->error ;
520
521 psf->dataoffset = psf->header.indx ;
522
523 if (current > 0)
524 psf_fseek (psf, current, SEEK_SET) ;
525
526 return psf->error ;
527 } /* voc_write_header */
528
529 static int
voc_close(SF_PRIVATE * psf)530 voc_close (SF_PRIVATE *psf)
531 {
532 if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
533 { /* Now we know for certain the length of the file we can re-write
534 ** correct values for the FORM, 8SVX and BODY chunks.
535 */
536 unsigned char byte = VOC_TERMINATOR ;
537
538
539 psf_fseek (psf, 0, SEEK_END) ;
540
541 /* Write terminator */
542 psf_fwrite (&byte, 1, 1, psf) ;
543
544 voc_write_header (psf, SF_TRUE) ;
545 } ;
546
547 return 0 ;
548 } /* voc_close */
549
550 static const char*
voc_encoding2str(int encoding)551 voc_encoding2str (int encoding)
552 {
553 switch (encoding)
554 { case 0 : return "8 bit unsigned PCM" ;
555 case 4 : return "16 bit signed PCM" ;
556 case 6 : return "A-law" ;
557 case 7 : return "u-law" ;
558 default : break ;
559 }
560 return "*** Unknown ***" ;
561 } /* voc_encoding2str */
562
563 /*====================================================================================
564 */
565
566 #if 0
567 static int
568 voc_multi_init (SF_PRIVATE *psf, VOC_DATA *pvoc)
569 {
570 psf->sf.frames = 0 ;
571
572 if (pvoc->bitwidth == 8)
573 { psf->read_short = voc_multi_read_uc2s ;
574 psf->read_int = voc_multi_read_uc2i ;
575 psf->read_float = voc_multi_read_uc2f ;
576 psf->read_double = voc_multi_read_uc2d ;
577 return 0 ;
578 } ;
579
580 if (pvoc->bitwidth == 16)
581 { psf->read_short = voc_multi_read_les2s ;
582 psf->read_int = voc_multi_read_les2i ;
583 psf->read_float = voc_multi_read_les2f ;
584 psf->read_double = voc_multi_read_les2d ;
585 return 0 ;
586 } ;
587
588 psf_log_printf (psf, "Error : bitwith != 8 && bitwidth != 16.\n") ;
589
590 return SFE_UNIMPLEMENTED ;
591 } /* voc_multi_read_int */
592
593 /*------------------------------------------------------------------------------------
594 */
595
596 static int
597 voc_multi_read_uc2s (SF_PRIVATE *psf, short *ptr, int len)
598 {
599
600 return 0 ;
601 } /* voc_multi_read_uc2s */
602
603 static int
604 voc_multi_read_les2s (SF_PRIVATE *psf, short *ptr, int len)
605 {
606
607 return 0 ;
608 } /* voc_multi_read_les2s */
609
610
611 static int
612 voc_multi_read_uc2i (SF_PRIVATE *psf, int *ptr, int len)
613 {
614
615 return 0 ;
616 } /* voc_multi_read_uc2i */
617
618 static int
619 voc_multi_read_les2i (SF_PRIVATE *psf, int *ptr, int len)
620 {
621
622 return 0 ;
623 } /* voc_multi_read_les2i */
624
625
626 static int
627 voc_multi_read_uc2f (SF_PRIVATE *psf, float *ptr, int len)
628 {
629
630 return 0 ;
631 } /* voc_multi_read_uc2f */
632
633 static int
634 voc_multi_read_les2f (SF_PRIVATE *psf, float *ptr, int len)
635 {
636
637 return 0 ;
638 } /* voc_multi_read_les2f */
639
640
641 static int
642 voc_multi_read_uc2d (SF_PRIVATE *psf, double *ptr, int len)
643 {
644
645 return 0 ;
646 } /* voc_multi_read_uc2d */
647
648 static int
649 voc_multi_read_les2d (SF_PRIVATE *psf, double *ptr, int len)
650 {
651
652 return 0 ;
653 } /* voc_multi_read_les2d */
654
655 #endif
656
657 /*------------------------------------------------------------------------------------
658
659 Creative Voice (VOC) file format
660 --------------------------------
661
662 ~From: galt@dsd.es.com
663
664 (byte numbers are hex!)
665
666 HEADER (bytes 00-19)
667 Series of DATA BLOCKS (bytes 1A+) [Must end w/ Terminator Block]
668
669 - ---------------------------------------------------------------
670
671 HEADER:
672 =======
673 byte # Description
674 ------ ------------------------------------------
675 00-12 "Creative Voice File"
676 13 1A (eof to abort printing of file)
677 14-15 Offset of first datablock in .voc file (std 1A 00
678 in Intel Notation)
679 16-17 Version number (minor,major) (VOC-HDR puts 0A 01)
680 18-19 1's Comp of Ver. # + 1234h (VOC-HDR puts 29 11)
681
682 - ---------------------------------------------------------------
683
684 DATA BLOCK:
685 ===========
686
687 Data Block: TYPE(1-byte), SIZE(3-bytes), INFO(0+ bytes)
688 NOTE: Terminator Block is an exception -- it has only the TYPE byte.
689
690 TYPE Description Size (3-byte int) Info
691 ---- ----------- ----------------- -----------------------
692 00 Terminator (NONE) (NONE)
693 01 Sound data 2+length of data *
694 02 Sound continue length of data Voice Data
695 03 Silence 3 **
696 04 Marker 2 Marker# (2 bytes)
697 05 ASCII length of string null terminated string
698 06 Repeat 2 Count# (2 bytes)
699 07 End repeat 0 (NONE)
700 08 Extended 4 ***
701
702 *Sound Info Format:
703 ---------------------
704 00 Sample Rate
705 01 Compression Type
706 02+ Voice Data
707
708 **Silence Info Format:
709 ----------------------------
710 00-01 Length of silence - 1
711 02 Sample Rate
712
713
714 ***Extended Info Format:
715 ---------------------
716 00-01 Time Constant: Mono: 65536 - (256000000/sample_rate)
717 Stereo: 65536 - (25600000/(2*sample_rate))
718 02 Pack
719 03 Mode: 0 = mono
720 1 = stereo
721
722
723 Marker# -- Driver keeps the most recent marker in a status byte
724 Count# -- Number of repetitions + 1
725 Count# may be 1 to FFFE for 0 - FFFD repetitions
726 or FFFF for endless repetitions
727 Sample Rate -- SR byte = 256-(1000000/sample_rate)
728 Length of silence -- in units of sampling cycle
729 Compression Type -- of voice data
730 8-bits = 0
731 4-bits = 1
732 2.6-bits = 2
733 2-bits = 3
734 Multi DAC = 3+(# of channels) [interesting--
735 this isn't in the developer's manual]
736
737
738 ---------------------------------------------------------------------------------
739 Addendum submitted by Votis Kokavessis:
740
741 After some experimenting with .VOC files I found out that there is a Data Block
742 Type 9, which is not covered in the VOC.TXT file. Here is what I was able to discover
743 about this block type:
744
745
746 TYPE: 09
747 SIZE: 12 + length of data
748 INFO: 12 (twelve) bytes
749
750 INFO STRUCTURE:
751
752 Bytes 0-1: (Word) Sample Rate (e.g. 44100)
753 Bytes 2-3: zero (could be that bytes 0-3 are a DWord for Sample Rate)
754 Byte 4: Sample Size in bits (e.g. 16)
755 Byte 5: Number of channels (e.g. 1 for mono, 2 for stereo)
756 Byte 6: Unknown (equal to 4 in all files I examined)
757 Bytes 7-11: zero
758
759
760 -------------------------------------------------------------------------------------*/
761
762 /*=====================================================================================
763 **=====================================================================================
764 **=====================================================================================
765 **=====================================================================================
766 */
767
768 /*------------------------------------------------------------------------
769 The following is taken from the Audio File Formats FAQ dated 2-Jan-1995
770 and submitted by Guido van Rossum <guido@cwi.nl>.
771 --------------------------------------------------------------------------
772 Creative Voice (VOC) file format
773 --------------------------------
774
775 From: galt@dsd.es.com
776
777 (byte numbers are hex!)
778
779 HEADER (bytes 00-19)
780 Series of DATA BLOCKS (bytes 1A+) [Must end w/ Terminator Block]
781
782 - ---------------------------------------------------------------
783
784 HEADER:
785 -------
786 byte # Description
787 ------ ------------------------------------------
788 00-12 "Creative Voice File"
789 13 1A (eof to abort printing of file)
790 14-15 Offset of first datablock in .voc file (std 1A 00
791 in Intel Notation)
792 16-17 Version number (minor,major) (VOC-HDR puts 0A 01)
793 18-19 2's Comp of Ver. # + 1234h (VOC-HDR puts 29 11)
794
795 - ---------------------------------------------------------------
796
797 DATA BLOCK:
798 -----------
799
800 Data Block: TYPE(1-byte), SIZE(3-bytes), INFO(0+ bytes)
801 NOTE: Terminator Block is an exception -- it has only the TYPE byte.
802
803 TYPE Description Size (3-byte int) Info
804 ---- ----------- ----------------- -----------------------
805 00 Terminator (NONE) (NONE)
806 01 Sound data 2+length of data *
807 02 Sound continue length of data Voice Data
808 03 Silence 3 **
809 04 Marker 2 Marker# (2 bytes)
810 05 ASCII length of string null terminated string
811 06 Repeat 2 Count# (2 bytes)
812 07 End repeat 0 (NONE)
813 08 Extended 4 ***
814
815 *Sound Info Format: **Silence Info Format:
816 --------------------- ----------------------------
817 00 Sample Rate 00-01 Length of silence - 1
818 01 Compression Type 02 Sample Rate
819 02+ Voice Data
820
821 ***Extended Info Format:
822 ---------------------
823 00-01 Time Constant: Mono: 65536 - (256000000/sample_rate)
824 Stereo: 65536 - (25600000/(2*sample_rate))
825 02 Pack
826 03 Mode: 0 = mono
827 1 = stereo
828
829
830 Marker# -- Driver keeps the most recent marker in a status byte
831 Count# -- Number of repetitions + 1
832 Count# may be 1 to FFFE for 0 - FFFD repetitions
833 or FFFF for endless repetitions
834 Sample Rate -- SR byte = 256-(1000000/sample_rate)
835 Length of silence -- in units of sampling cycle
836 Compression Type -- of voice data
837 8-bits = 0
838 4-bits = 1
839 2.6-bits = 2
840 2-bits = 3
841 Multi DAC = 3+(# of channels) [interesting--
842 this isn't in the developer's manual]
843
844 Detailed description of new data blocks (VOC files version 1.20 and above):
845
846 (Source is fax from Barry Boone at Creative Labs, 405/742-6622)
847
848 BLOCK 8 - digitized sound attribute extension, must preceed block 1.
849 Used to define stereo, 8 bit audio
850 BYTE bBlockID; // = 8
851 BYTE nBlockLen[3]; // 3 byte length
852 WORD wTimeConstant; // time constant = same as block 1
853 BYTE bPackMethod; // same as in block 1
854 BYTE bVoiceMode; // 0-mono, 1-stereo
855
856 Data is stored left, right
857
858 BLOCK 9 - data block that supersedes blocks 1 and 8.
859 Used for stereo, 16 bit.
860
861 BYTE bBlockID; // = 9
862 BYTE nBlockLen[3]; // length 12 plus length of sound
863 DWORD dwSamplesPerSec; // samples per second, not time const.
864 BYTE bBitsPerSample; // e.g., 8 or 16
865 BYTE bChannels; // 1 for mono, 2 for stereo
866 WORD wFormat; // see below
867 BYTE reserved[4]; // pad to make block w/o data
868 // have a size of 16 bytes
869
870 Valid values of wFormat are:
871
872 0x0000 8-bit unsigned PCM
873 0x0001 Creative 8-bit to 4-bit ADPCM
874 0x0002 Creative 8-bit to 3-bit ADPCM
875 0x0003 Creative 8-bit to 2-bit ADPCM
876 0x0004 16-bit signed PCM
877 0x0006 CCITT a-Law
878 0x0007 CCITT u-Law
879 0x02000 Creative 16-bit to 4-bit ADPCM
880
881 Data is stored left, right
882
883 ------------------------------------------------------------------------*/
884