1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * This file contains a set of Very Paranoid routines to convert
31 * audio file headers to in-core audio headers and vice versa.
32 *
33 * They are robust enough to handle any random file input without
34 * crashing miserably. Of course, bad audio headers coming from
35 * the calling program can cause significant problems.
36 */
37
38 #include <stdlib.h>
39 #include <memory.h>
40 #include <fcntl.h>
41 #include <errno.h> /* needed for large file error checking */
42 #include <stdio.h>
43 #include <sys/types.h>
44 #include <sys/file.h>
45 #include <sys/stat.h>
46 #include <libintl.h>
47 #include <math.h>
48
49 #include <libaudio_impl.h> /* include other audio hdr's */
50
51 /* Round up to a double boundary */
52 #define ROUND_DBL(x) (((x) + 7) & ~7)
53
54 #define HEADER_BUFFER 100
55
56 #define _MGET_(str) (char *)dgettext(TEXT_DOMAIN, str)
57
58 static int audio_encode_aiff(Audio_hdr *, unsigned char *, unsigned int *);
59 static int audio_encode_au(Audio_hdr *, char *, unsigned int,
60 unsigned char *, unsigned int *);
61 static int audio_encode_wav(Audio_hdr *, unsigned char *, unsigned int *);
62 static double convert_from_ieee_extended(unsigned char *);
63 static void convert_to_ieee_extended(double, unsigned char *);
64
65 /*
66 * Write an audio file header to an output stream.
67 *
68 * The file header is encoded from the supplied Audio_hdr structure.
69 * If 'infop' is not NULL, it is the address of a buffer containing 'info'
70 * data. 'ilen' specifies the size of this buffer.
71 * The entire file header will be zero-padded to a double-word boundary.
72 *
73 * Note that the file header is stored on-disk in big-endian format,
74 * regardless of the machine type.
75 *
76 * Note also that the output file descriptor must not have been set up
77 * non-blocking i/o. If non-blocking behavior is desired, set this
78 * flag after writing the file header.
79 */
80 int
audio_write_filehdr(int fd,Audio_hdr * hdrp,int file_type,char * infop,unsigned int ilen)81 audio_write_filehdr(int fd, Audio_hdr *hdrp, int file_type, char *infop,
82 unsigned int ilen)
83 /* file descriptor */
84 /* audio header */
85 /* audio header type */
86 /* info buffer pointer */
87 /* buffer size */
88 {
89 int err;
90 unsigned blen;
91 unsigned char *buf; /* temporary buffer */
92
93 /* create tmp buf for the encoding routines to work with */
94 blen = HEADER_BUFFER + (infop ? ilen : 0) + 4;
95 blen = ROUND_DBL(blen);
96
97 if (!(buf = (unsigned char *)calloc(1, blen))) {
98 return (AUDIO_UNIXERROR);
99 }
100
101 switch (file_type) {
102 case FILE_AU:
103 err = audio_encode_au(hdrp, infop, ilen, buf, &blen);
104 break;
105 case FILE_WAV:
106 err = audio_encode_wav(hdrp, buf, &blen);
107 break;
108 case FILE_AIFF:
109 err = audio_encode_aiff(hdrp, buf, &blen);
110 break;
111 default:
112 return (AUDIO_ERR_BADFILETYPE);
113 }
114
115 if (err != AUDIO_SUCCESS) {
116 return (err);
117 }
118
119 /* Write and free the holding buffer */
120 err = write(fd, (char *)buf, (int)blen);
121 (void) free((char *)buf);
122
123 if (err != blen)
124 return ((err < 0) ? AUDIO_UNIXERROR : AUDIO_ERR_BADFILEHDR);
125
126 return (AUDIO_SUCCESS);
127
128 }
129
130 /*
131 * Rewrite the aiff header chunk length and the data chunk length fields.
132 */
133 static int
audio_rewrite_aiff_filesize(int fd,unsigned int size,unsigned int channels,unsigned int bytes_per_sample)134 audio_rewrite_aiff_filesize(int fd, unsigned int size, unsigned int channels,
135 unsigned int bytes_per_sample)
136 {
137 unsigned int offset;
138 unsigned int tmp_uint;
139 unsigned int tmp_uint2;
140 unsigned int total_size;
141
142 /* first fix aiff_hdr_size */
143 total_size = size + sizeof (aiff_hdr_chunk_t) +
144 AUDIO_AIFF_COMM_CHUNK_SIZE + sizeof (aiff_ssnd_chunk_t);
145 tmp_uint = total_size - (2 * sizeof (int));
146 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &tmp_uint2);
147 offset = sizeof (int);
148 if (lseek(fd, offset, SEEK_SET) < 0) {
149 return (AUDIO_ERR_NOEFFECT);
150 }
151 if (write(fd, &tmp_uint2, sizeof (tmp_uint2)) != sizeof (tmp_uint2)) {
152 return (AUDIO_ERR_NOEFFECT);
153 }
154
155 /* fix the frame count */
156 tmp_uint = size / channels / bytes_per_sample;
157 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &tmp_uint2);
158 offset = sizeof (aiff_hdr_chunk_t) + (2 * sizeof (int)) +
159 sizeof (short);
160 if (lseek(fd, offset, SEEK_SET) < 0) {
161 return (AUDIO_ERR_NOEFFECT);
162 }
163 if (write(fd, &tmp_uint2, sizeof (tmp_uint2)) != sizeof (tmp_uint2)) {
164 return (AUDIO_ERR_NOEFFECT);
165 }
166
167 /* fix the data size */
168 tmp_uint = size + sizeof (aiff_ssnd_chunk_t) - (2 * sizeof (int));
169 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &tmp_uint2);
170 offset = sizeof (aiff_hdr_chunk_t) + AUDIO_AIFF_COMM_CHUNK_SIZE +
171 sizeof (int);
172 if (lseek(fd, offset, SEEK_SET) < 0) {
173 return (AUDIO_ERR_NOEFFECT);
174 }
175 if (write(fd, &tmp_uint2, sizeof (tmp_uint2)) != sizeof (tmp_uint2)) {
176 return (AUDIO_ERR_NOEFFECT);
177 }
178
179 return (AUDIO_SUCCESS);
180
181 }
182
183 /*
184 * Rewrite the data size field for the .au file format. Rewrite the audio
185 * file header au_data_size field with the supplied value. Otherwise,
186 * return AUDIO_ERR_NOEFFECT.
187 */
188 static int
audio_rewrite_au_filesize(int fd,unsigned int size)189 audio_rewrite_au_filesize(int fd, unsigned int size)
190 {
191 au_filehdr_t fhdr;
192 int err;
193 int data;
194 int offset;
195
196 /* seek to the position of the au_data_size member */
197 offset = (char *)&fhdr.au_data_size - (char *)&fhdr;
198 if (lseek(fd, offset, SEEK_SET) < 0) {
199 return (AUDIO_ERR_NOEFFECT);
200 }
201
202 /* Encode the 32-bit integer header field */
203 AUDIO_AU_HOST2FILE(&size, &data);
204
205 /* Write the data */
206 err = write(fd, (char *)&data, sizeof (fhdr.au_data_size));
207 if (err != sizeof (fhdr.au_data_size))
208 return ((err < 0) ? AUDIO_UNIXERROR : AUDIO_ERR_BADFILEHDR);
209
210 return (AUDIO_SUCCESS);
211
212 }
213
214 /*
215 * Rewrite the riff header chunk length and the data chunk length fields.
216 */
217 static int
audio_rewrite_wav_filesize(int fd,unsigned int size)218 audio_rewrite_wav_filesize(int fd, unsigned int size)
219 {
220 wav_filehdr_t fhdr;
221 int calc_size;
222 int err;
223 int data;
224 int offset;
225
226 /* seek to the position of the riff header chunk length */
227 calc_size = size + sizeof (fhdr) - sizeof (fhdr.wav_riff_ID) -
228 sizeof (fhdr.wav_riff_size);
229 AUDIO_WAV_HOST2FILE_INT(&calc_size, &data);
230 offset = (char *)&fhdr.wav_riff_size - (char *)&fhdr;
231 if (lseek(fd, offset, SEEK_SET) < 0) {
232 return (AUDIO_ERR_NOEFFECT);
233 }
234
235 /* Write the data */
236 err = write(fd, (char *)&data, sizeof (fhdr.wav_riff_size));
237 if (err != sizeof (fhdr.wav_riff_size))
238 return ((err < 0) ? AUDIO_UNIXERROR : AUDIO_ERR_BADFILEHDR);
239
240 /* now seek to the position of the data chunk length */
241 AUDIO_WAV_HOST2FILE_INT(&size, &data);
242 offset = (char *)&fhdr.wav_data_size - (char *)&fhdr;
243 if (lseek(fd, offset, SEEK_SET) < 0) {
244 return (AUDIO_ERR_NOEFFECT);
245 }
246
247 /* Write the data */
248 err = write(fd, (char *)&data, sizeof (fhdr.wav_data_size));
249 if (err != sizeof (fhdr.wav_data_size))
250 return ((err < 0) ? AUDIO_UNIXERROR : AUDIO_ERR_BADFILEHDR);
251
252 return (AUDIO_SUCCESS);
253
254 }
255
256 /*
257 * Rewrite the data size field of an audio header to the output stream if
258 * the output file is capable of seeking.
259 */
260 int
audio_rewrite_filesize(int fd,int file_type,unsigned int size,unsigned int channels,unsigned int bytes_per_sample)261 audio_rewrite_filesize(int fd, int file_type, unsigned int size,
262 unsigned int channels, unsigned int bytes_per_sample)
263 /* file descriptor */
264 /* audio file type */
265 /* new data size */
266 /* number of channels */
267 /* number of bytes per sample */
268 {
269 int fcntl_err;
270
271 /* Can we seek back in this file and write without appending? */
272 fcntl_err = fcntl(fd, F_GETFL, 0);
273 if ((fcntl_err < 0) && ((errno == EOVERFLOW) || (errno == EINVAL))) {
274 /* Large file encountered (probably) */
275 perror("fcntl");
276 exit(1);
277 } else if ((lseek(fd, (off_t)0, SEEK_SET) < 0) ||
278 (fcntl_err & FAPPEND)) {
279 return (AUDIO_ERR_NOEFFECT);
280 }
281
282 switch (file_type) {
283 case FILE_AU:
284 return (audio_rewrite_au_filesize(fd, size));
285 case FILE_WAV:
286 return (audio_rewrite_wav_filesize(fd, size));
287 case FILE_AIFF:
288 return (audio_rewrite_aiff_filesize(fd, size, channels,
289 bytes_per_sample));
290 default:
291 return (AUDIO_ERR_BADFILETYPE);
292 }
293 }
294
295
296 /*
297 * Decode an audio file header from an input stream.
298 *
299 * The file header is decoded into the supplied Audio_hdr structure, regardless
300 * of the file format. Thus .wav and .aiff files look like .au files once the
301 * header is decoded.
302 *
303 * If 'infop' is not NULL, it is the address of a buffer to which the
304 * 'info' portion of the file header will be copied. 'ilen' specifies
305 * the maximum number of bytes to copy. The buffer will be NULL-terminated,
306 * even if it means over-writing the last byte.
307 *
308 * Note that the .au file header is stored on-disk in big-endian format,
309 * regardless of the machine type. This may not have been true if
310 * the file was written on a non-Sun machine. For now, such
311 * files will appear invalid.
312 *
313 * Note also that the input file descriptor must not have been set up
314 * non-blocking i/o. If non-blocking behavior is desired, set this
315 * flag after reading the file header.
316 */
317 int
audio_read_filehdr(int fd,Audio_hdr * hdrp,int * file_type,char * infop,unsigned int ilen)318 audio_read_filehdr(int fd, Audio_hdr *hdrp, int *file_type, char *infop,
319 unsigned int ilen)
320 /* input file descriptor */
321 /* output audio header */
322 /* audio file type */
323 /* info buffer pointer */
324 /* buffer size */
325 {
326 int err;
327 int dsize;
328 int isize;
329 unsigned resid;
330 unsigned char buf[HEADER_BUFFER];
331 struct stat st;
332
333 /* decode the file header and fill in the hdrp structure */
334 if ((err = audio_decode_filehdr(fd, buf, file_type, hdrp, &isize)) !=
335 AUDIO_SUCCESS) {
336 goto checkerror;
337 }
338
339 /* Stat the file, to determine if it is a regular file. */
340 err = fstat(fd, &st);
341 if (err < 0) {
342 return (AUDIO_UNIXERROR);
343 }
344
345 /*
346 * If au_data_size is not indeterminate (i.e., this isn't a pipe),
347 * try to validate the au_offset and au_data_size.
348 */
349 if (*file_type == FILE_AU && hdrp->data_size != AUDIO_UNKNOWN_SIZE) {
350 /* Only trust the size for regular files */
351 if (S_ISREG(st.st_mode)) {
352 dsize = isize + hdrp->data_size + sizeof (au_filehdr_t);
353 if (st.st_size < dsize) {
354 (void) fprintf(stderr,
355 _MGET_("Warning: More audio data "
356 "than the file header specifies\n"));
357 } else if (st.st_size > dsize) {
358 (void) fprintf(stderr,
359 _MGET_("Warning: Less audio data "
360 "than the file header specifies\n"));
361 }
362 }
363 }
364
365 resid = isize;
366 /*
367 * Deal with extra header data.
368 */
369 if ((infop != NULL) && (ilen != 0)) {
370 /*
371 * If infop is non-NULL, try to read in the info data
372 */
373 if (isize > ilen)
374 isize = ilen;
375 err = read(fd, infop, (int)isize);
376 if (err != isize)
377 goto checkerror;
378
379 /* Zero any residual bytes in the text buffer */
380 if (isize < ilen)
381 (void) memset(&infop[isize], '\0',
382 (int)(ilen - isize));
383 else
384 infop[ilen - 1] = '\0'; /* zero-terminate */
385
386 resid -= err; /* subtract the amount read */
387 }
388
389 /*
390 * If we truncated the info, seek or read data until info size
391 * is satisfied. If regular file, seek nearly to end and check
392 * for eof.
393 */
394 if (resid != 0) {
395 if (S_ISREG(st.st_mode)) {
396 err = lseek(fd, (off_t)(resid - 1), SEEK_CUR);
397 if ((err < 0) ||
398 ((err = read(fd, (char *)buf, 1)) != 1))
399 goto checkerror;
400 } else while (resid != 0) {
401 char junk[8192]; /* temporary buffer */
402
403 isize = (resid > sizeof (junk)) ?
404 sizeof (junk) : resid;
405 err = read(fd, junk, isize);
406 if (err != isize)
407 goto checkerror;
408 resid -= err;
409 }
410 }
411
412 return (AUDIO_SUCCESS);
413
414 checkerror:
415 if ((err < 0) && (errno == EOVERFLOW)) {
416 perror("read");
417 exit(1);
418 } else {
419 return ((err < 0) ? AUDIO_UNIXERROR : AUDIO_ERR_BADFILEHDR);
420 }
421 return (AUDIO_SUCCESS);
422 }
423
424 /*
425 * Return TRUE if the named file is an audio file. Else, return FALSE.
426 */
427 int
audio_isaudiofile(char * name)428 audio_isaudiofile(char *name)
429 {
430 int fd;
431 int err;
432 int file_type; /* ignored */
433 int isize;
434 Audio_hdr hdr;
435 unsigned char buf[sizeof (au_filehdr_t)];
436
437 /* Open the file (set O_NONBLOCK in case the name refers to a device) */
438 fd = open(name, O_RDONLY | O_NONBLOCK);
439 if (fd < 0) {
440 if (errno == EOVERFLOW) {
441 perror("open");
442 exit(1);
443 } else {
444 return (FALSE);
445 }
446 }
447
448 /* Read the header (but not the text info). */
449 err = read(fd, (char *)buf, sizeof (buf));
450 if (err < 0) {
451 if (errno == EOVERFLOW) {
452 perror("open");
453 exit(1);
454 } else {
455 return (FALSE);
456 }
457 }
458 (void) close(fd);
459
460 if ((err == sizeof (buf)) &&
461 (audio_decode_filehdr(fd, buf, &file_type, &hdr, &isize) ==
462 AUDIO_SUCCESS)) {
463 return (hdr.encoding);
464 } else {
465 return (FALSE);
466 }
467 }
468
469 /*
470 * audio_endian()
471 *
472 * This routine tests the magic number at the head of a buffer
473 * containing the file header. The first thing in the header
474 * should be the magic number.
475 */
476 static int
audio_endian(unsigned char * buf,int * file_type)477 audio_endian(unsigned char *buf, int *file_type)
478 {
479 unsigned int magic1;
480 unsigned int magic2;
481
482 /* put the buffer into an int that is aligned properly */
483 (void) memcpy(&magic1, buf, sizeof (magic1));
484
485 magic2 = magic1;
486 SWABI(magic2);
487
488 if (magic1 == AUDIO_AU_FILE_MAGIC || magic2 == AUDIO_AU_FILE_MAGIC) {
489 *file_type = FILE_AU;
490 return (AUDIO_ENDIAN_BIG);
491 } else if (magic1 == AUDIO_WAV_RIFF_ID || magic2 == AUDIO_WAV_RIFF_ID) {
492 *file_type = FILE_WAV;
493 return (AUDIO_ENDIAN_SMALL);
494 } else if (magic1 == AUDIO_AIFF_HDR_CHUNK_ID ||
495 magic2 == AUDIO_AIFF_HDR_CHUNK_ID) {
496 *file_type = FILE_AIFF;
497 return (AUDIO_ENDIAN_BIG);
498 }
499
500 return (AUDIO_ENDIAN_UNKNOWN);
501 }
502
503 /*
504 * Decode an aiff file header. Unlike .au and .wav, we have to process
505 * by chunk.
506 */
507 static int
decode_aiff(int fd,unsigned char * buf,Audio_hdr * hdrp,int * isize)508 decode_aiff(int fd, unsigned char *buf, Audio_hdr *hdrp, int *isize)
509 {
510 aiff_hdr_chunk_t hdr_chunk;
511 aiff_comm_chunk_t comm_chunk;
512 aiff_ssnd_chunk_t ssnd_chunk;
513 uint32_t ID;
514 uint32_t size;
515 uint32_t tmp;
516 int data_type;
517 int hdr_sizes;
518 int sr;
519 short bits_per_sample;
520 short channels;
521
522 /* we've read in 4 bytes, read in the rest of the wav header */
523 size = sizeof (hdr_chunk) - sizeof (hdr_chunk.aiff_hdr_ID);
524
525 /* read in the rest of the header */
526 if (read(fd, &hdr_chunk.aiff_hdr_size, size) != size) {
527 return (AUDIO_UNIXERROR);
528 }
529
530 /* see which kind of audio file we have */
531 AUDIO_AIFF_FILE2HOST_INT(&hdr_chunk.aiff_hdr_data_type, &data_type);
532 if (data_type != AUDIO_AIFF_HDR_FORM_AIFF) {
533 /* we can't play this version of a .aiff file */
534 return (AUDIO_ERR_BADFILEHDR);
535 }
536
537 hdr_sizes = sizeof (hdr_chunk);
538
539 /*
540 * We don't know what the chunk order will be, so read each, getting
541 * the data we need from each. Eventually we'll get to the end of
542 * the file, in which case we should have all of the info on the
543 * file that we need. We then lseek() back to the data to play.
544 *
545 * We start each loop by reading the chunk ID.
546 */
547 while (read(fd, &tmp, sizeof (tmp)) == sizeof (tmp)) {
548 AUDIO_AIFF_FILE2HOST_INT(&tmp, &ID);
549 switch (ID) {
550 case AUDIO_AIFF_COMM_ID:
551 /* read in the rest of the COMM chunk */
552 size = AUDIO_AIFF_COMM_CHUNK_SIZE -
553 sizeof (comm_chunk.aiff_comm_ID);
554 if (read(fd, &comm_chunk.aiff_comm_size, size) !=
555 size) {
556 return (AUDIO_UNIXERROR);
557 }
558
559 sr = convert_from_ieee_extended(
560 comm_chunk.aiff_comm_sample_rate);
561
562 hdr_sizes += AUDIO_AIFF_COMM_CHUNK_SIZE;
563
564 break;
565 case AUDIO_AIFF_SSND_ID:
566 /* read in the rest of the INST chunk */
567 size = sizeof (ssnd_chunk) -
568 sizeof (ssnd_chunk.aiff_ssnd_ID);
569 if (read(fd, &ssnd_chunk.aiff_ssnd_size, size) !=
570 size) {
571 return (AUDIO_UNIXERROR);
572 }
573
574 /*
575 * This has to be the last chunk because the audio data
576 * follows. So we should have all we need to tell the
577 * app the format information.
578 */
579 hdrp->sample_rate = sr;
580
581 AUDIO_AIFF_FILE2HOST_SHORT(
582 &comm_chunk.aiff_comm_channels,
583 &channels);
584 /* use channels to convert from short to int */
585 hdrp->channels = channels;
586
587 AUDIO_AIFF_FILE2HOST_SHORT(
588 &comm_chunk.aiff_comm_sample_size,
589 &bits_per_sample);
590 switch (bits_per_sample) {
591 case AUDIO_AIFF_COMM_8_BIT_SAMPLE_SIZE:
592 hdrp->encoding = AUDIO_AU_ENCODING_LINEAR_8;
593 break;
594 case AUDIO_AIFF_COMM_16_BIT_SAMPLE_SIZE:
595 hdrp->encoding = AUDIO_AU_ENCODING_LINEAR_16;
596 break;
597 default:
598 return (AUDIO_ERR_BADFILEHDR);
599 }
600
601 AUDIO_AIFF_FILE2HOST_INT(&ssnd_chunk.aiff_ssnd_size,
602 &size);
603 size -= sizeof (ssnd_chunk.aiff_ssnd_offset) +
604 sizeof (ssnd_chunk.aiff_ssnd_block_size);
605 hdrp->data_size = size;
606
607 hdr_sizes += sizeof (ssnd_chunk);
608
609 *isize = hdr_sizes - sizeof (au_filehdr_t);
610
611 return (AUDIO_SUCCESS);
612 default:
613 /*
614 * Unknown chunk. Read the size, which is right after
615 * the ID. Then seek past it to get to the next chunk.
616 */
617 if (read(fd, &size, sizeof (size)) != sizeof (size)) {
618 return (AUDIO_UNIXERROR);
619 }
620
621 if (lseek(fd, size, SEEK_CUR) < 0) {
622 return (AUDIO_UNIXERROR);
623 }
624 break;
625 }
626 }
627
628 return (AUDIO_SUCCESS);
629
630 } /* decode_aiff() */
631
632 /*
633 * Decode an au file header.
634 */
635 static int
decode_au(int fd,unsigned char * buf,Audio_hdr * hdrp,int * isize,boolean_t read_info)636 decode_au(int fd, unsigned char *buf, Audio_hdr *hdrp, int *isize,
637 boolean_t read_info)
638 {
639 au_filehdr_t fhdr;
640 int offset;
641 int size;
642
643 if (read_info) {
644 /* read in the rest of the au header */
645 size = sizeof (fhdr) - sizeof (int);
646 (void) lseek(fd, (off_t)4, SEEK_SET);
647 if (read(fd, &buf[sizeof (int)], size) != size) {
648
649 return (AUDIO_UNIXERROR);
650 }
651 }
652
653 /* put the buffer into a structure that is aligned properly */
654 (void) memcpy(&fhdr, buf, sizeof (fhdr));
655
656 /* Decode the 32-bit integer header fields. */
657 AUDIO_AU_FILE2HOST(&fhdr.au_offset, &offset);
658 AUDIO_AU_FILE2HOST(&fhdr.au_data_size, &hdrp->data_size);
659 AUDIO_AU_FILE2HOST(&fhdr.au_encoding, &hdrp->encoding);
660 AUDIO_AU_FILE2HOST(&fhdr.au_sample_rate, &hdrp->sample_rate);
661 AUDIO_AU_FILE2HOST(&fhdr.au_channels, &hdrp->channels);
662
663 /* Set the info field size (ie, number of bytes left before data). */
664 *isize = offset - sizeof (au_filehdr_t);
665
666 return (AUDIO_SUCCESS);
667
668 } /* decode_au() */
669
670 /*
671 * Decode a wav file header.
672 *
673 * .wav files are stored on-disk in little-endian format.
674 */
675 static int
decode_wav(int fd,unsigned char * buf,Audio_hdr * hdrp,int * isize)676 decode_wav(int fd, unsigned char *buf, Audio_hdr *hdrp, int *isize)
677 {
678 wav_filehdr_t fhdr;
679 uint32_t ID;
680 uint32_t size;
681 short bits_per_sample;
682 short encoding;
683
684 /* we've read in 4 bytes, read in the rest of the wav header */
685 size = sizeof (fhdr) - sizeof (int);
686
687 /* read in the rest of the header */
688 if (read(fd, &buf[sizeof (int)], size) != size) {
689 return (AUDIO_UNIXERROR);
690 }
691
692 /* put the buffer into a structure that is aligned properly */
693 (void) memcpy(&fhdr, buf, sizeof (fhdr));
694
695 /* make sure we have the correct RIFF type */
696 AUDIO_WAV_FILE2HOST_INT(&fhdr.wav_type_ID, &ID);
697 if (ID != AUDIO_WAV_TYPE_ID) {
698 /* not a wave file */
699 return (AUDIO_ERR_BADFILEHDR);
700 }
701
702 /* decode the fields */
703 AUDIO_WAV_FILE2HOST_INT(&fhdr.wav_fmt_ID, &ID);
704 if (ID != AUDIO_WAV_FORMAT_ID) {
705 /* mangled format */
706 return (AUDIO_ERR_BADFILEHDR);
707 }
708
709 AUDIO_WAV_FILE2HOST_SHORT(&fhdr.wav_fmt_encoding, &encoding);
710 AUDIO_WAV_FILE2HOST_SHORT(&fhdr.wav_fmt_channels, &hdrp->channels);
711 AUDIO_WAV_FILE2HOST_INT(&fhdr.wav_fmt_sample_rate, &hdrp->sample_rate);
712 AUDIO_WAV_FILE2HOST_SHORT(&fhdr.wav_fmt_bits_per_sample,
713 &bits_per_sample);
714
715 /* convert .wav encodings to .au encodings */
716 switch (encoding) {
717 case AUDIO_WAV_FMT_ENCODING_PCM:
718 switch (bits_per_sample) {
719 case AUDIO_WAV_FMT_BITS_PER_SAMPLE_8_BITS:
720 hdrp->encoding = AUDIO_AU_ENCODING_LINEAR_8;
721 break;
722 case AUDIO_WAV_FMT_BITS_PER_SAMPLE_16_BITS:
723 hdrp->encoding = AUDIO_AU_ENCODING_LINEAR_16;
724 break;
725 default:
726 return (AUDIO_ERR_BADFILEHDR);
727 }
728 break;
729 case AUDIO_WAV_FMT_ENCODING_ALAW:
730 hdrp->encoding = AUDIO_AU_ENCODING_ALAW;
731 break;
732 case AUDIO_WAV_FMT_ENCODING_MULAW:
733 hdrp->encoding = AUDIO_AU_ENCODING_ULAW;
734 break;
735 default:
736 return (AUDIO_ERR_BADFILEHDR);
737 }
738
739 AUDIO_WAV_FILE2HOST_INT(&fhdr.wav_data_size, &hdrp->data_size);
740
741 *isize = sizeof (wav_filehdr_t) - sizeof (au_filehdr_t);
742
743 return (AUDIO_SUCCESS);
744
745 } /* decode_wav() */
746
747 /*
748 * Try to decode buffer containing an audio file header into an audio header.
749 */
750 int
audio_decode_filehdr(int fd,unsigned char * buf,int * file_type,Audio_hdr * hdrp,int * isize)751 audio_decode_filehdr(int fd, unsigned char *buf, int *file_type,
752 Audio_hdr *hdrp, int *isize)
753 /* file descriptor */
754 /* buffer address */
755 /* audio file type */
756 /* output audio header */
757 /* output size of info */
758 {
759 int err;
760 struct stat fd_stat;
761 boolean_t read_info;
762
763 /* Test for .au first */
764 hdrp->endian = audio_endian(buf, file_type);
765
766 /*
767 * When cat'ing a file, audioconvert will read the whole header
768 * trying to figure out the file. audioplay however, does not.
769 * Hence we check if this is a pipe and do not attempt to read
770 * any more header info if the file type is already known.
771 * Otherwise we overwrite the header data already in the buffer.
772 */
773 if (fstat(fd, &fd_stat) < 0) {
774 return (AUDIO_ERR_BADFILEHDR);
775 }
776 if (S_ISFIFO(fd_stat.st_mode) && (*file_type == FILE_AU)) {
777 read_info = B_FALSE;
778 } else {
779 /*
780 * Not an au file, or file type unknown. Reread the header's
781 * magic number. Fortunately this is always an int.
782 */
783 (void) lseek(fd, (off_t)0, SEEK_SET);
784 err = read(fd, (char *)buf, sizeof (int));
785 read_info = B_TRUE;
786
787 /* test the magic number to determine the endian */
788 if ((hdrp->endian = audio_endian(buf, file_type)) ==
789 AUDIO_ENDIAN_UNKNOWN) {
790
791 return (AUDIO_ERR_BADFILEHDR);
792 }
793 }
794
795 /* decode the different file types, putting the data into hdrp */
796 switch (*file_type) {
797 case FILE_AU:
798 if ((err = decode_au(fd, buf, hdrp, isize, read_info)) !=
799 AUDIO_SUCCESS) {
800 return (err);
801 }
802 break;
803 case FILE_WAV:
804 if ((err = decode_wav(fd, buf, hdrp, isize)) != AUDIO_SUCCESS) {
805 return (err);
806 }
807 break;
808 case FILE_AIFF:
809 if ((err = decode_aiff(fd, buf, hdrp, isize)) !=
810 AUDIO_SUCCESS) {
811 return (err);
812 }
813 break;
814 default:
815 return (AUDIO_ERR_BADFILEHDR);
816 }
817
818 /* Convert from file format info to audio format info */
819 switch (hdrp->encoding) {
820 case AUDIO_AU_ENCODING_ULAW:
821 hdrp->encoding = AUDIO_ENCODING_ULAW;
822 hdrp->bytes_per_unit = 1;
823 hdrp->samples_per_unit = 1;
824 break;
825 case AUDIO_AU_ENCODING_ALAW:
826 hdrp->encoding = AUDIO_ENCODING_ALAW;
827 hdrp->bytes_per_unit = 1;
828 hdrp->samples_per_unit = 1;
829 break;
830 case AUDIO_AU_ENCODING_LINEAR_8:
831 if (*file_type == FILE_WAV) {
832 hdrp->encoding = AUDIO_ENCODING_LINEAR8;
833 } else {
834 hdrp->encoding = AUDIO_ENCODING_LINEAR;
835 }
836 hdrp->bytes_per_unit = 1;
837 hdrp->samples_per_unit = 1;
838 break;
839 case AUDIO_AU_ENCODING_LINEAR_16:
840 hdrp->encoding = AUDIO_ENCODING_LINEAR;
841 hdrp->bytes_per_unit = 2;
842 hdrp->samples_per_unit = 1;
843 break;
844 case AUDIO_AU_ENCODING_LINEAR_24:
845 hdrp->encoding = AUDIO_ENCODING_LINEAR;
846 hdrp->bytes_per_unit = 3;
847 hdrp->samples_per_unit = 1;
848 break;
849 case AUDIO_AU_ENCODING_LINEAR_32:
850 hdrp->encoding = AUDIO_ENCODING_LINEAR;
851 hdrp->bytes_per_unit = 4;
852 hdrp->samples_per_unit = 1;
853 break;
854 case AUDIO_AU_ENCODING_FLOAT:
855 hdrp->encoding = AUDIO_ENCODING_FLOAT;
856 hdrp->bytes_per_unit = 4;
857 hdrp->samples_per_unit = 1;
858 break;
859 case AUDIO_AU_ENCODING_DOUBLE:
860 hdrp->encoding = AUDIO_ENCODING_FLOAT;
861 hdrp->bytes_per_unit = 8;
862 hdrp->samples_per_unit = 1;
863 break;
864 case AUDIO_AU_ENCODING_ADPCM_G721:
865 hdrp->encoding = AUDIO_ENCODING_G721;
866 hdrp->bytes_per_unit = 1;
867 hdrp->samples_per_unit = 2;
868 break;
869 case AUDIO_AU_ENCODING_ADPCM_G723_3:
870 hdrp->encoding = AUDIO_ENCODING_G723;
871 hdrp->bytes_per_unit = 3;
872 hdrp->samples_per_unit = 8;
873 break;
874 case AUDIO_AU_ENCODING_ADPCM_G723_5:
875 hdrp->encoding = AUDIO_ENCODING_G723;
876 hdrp->bytes_per_unit = 5;
877 hdrp->samples_per_unit = 8;
878 break;
879
880 default:
881 return (AUDIO_ERR_BADFILEHDR);
882 }
883 return (AUDIO_SUCCESS);
884 }
885
886 /*
887 * Encode a .aiff file header from the supplied Audio_hdr structure and
888 * store in the supplied char* buffer. blen is the size of the buffer to
889 * store the header in. Unlike .au and .wav we can't cast to a data structure.
890 * We have to build it one chunk at a time.
891 *
892 * NOTE: .aiff doesn't support unsigned 8-bit linear PCM.
893 */
894 static int
audio_encode_aiff(Audio_hdr * hdrp,unsigned char * buf,unsigned int * blen)895 audio_encode_aiff(Audio_hdr *hdrp, unsigned char *buf, unsigned int *blen)
896 /* audio header */
897 /* output buffer */
898 /* output buffer size */
899 {
900 aiff_comm_chunk_t comm_chunk;
901 aiff_hdr_chunk_t hdr_chunk;
902 aiff_ssnd_chunk_t ssnd_chunk;
903 uint32_t tmp_uint;
904 uint32_t tmp_uint2;
905 int buf_size = 0;
906 int encoding;
907 uint16_t tmp_ushort;
908
909 /* the only encoding we support for .aiff is signed linear PCM */
910 if (hdrp->encoding != AUDIO_ENCODING_LINEAR) {
911 return (AUDIO_ERR_ENCODING);
912 }
913
914 /* build the header chunk */
915 tmp_uint = AUDIO_AIFF_HDR_CHUNK_ID;
916 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &hdr_chunk.aiff_hdr_ID);
917 /* needs to be fixed when closed */
918 tmp_uint = AUDIO_AIFF_UNKNOWN_SIZE;
919 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &hdr_chunk.aiff_hdr_size);
920 tmp_uint = AUDIO_AIFF_HDR_FORM_AIFF;
921 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &hdr_chunk.aiff_hdr_data_type);
922 (void) memcpy(&buf[buf_size], &hdr_chunk, sizeof (hdr_chunk));
923 buf_size += sizeof (hdr_chunk);
924
925 /* build the COMM chunk */
926 tmp_uint = AUDIO_AIFF_COMM_ID;
927 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &comm_chunk.aiff_comm_ID);
928 tmp_uint = AUDIO_AIFF_COMM_SIZE;
929 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &comm_chunk.aiff_comm_size);
930 tmp_ushort = hdrp->channels;
931 AUDIO_AIFF_HOST2FILE_SHORT(&tmp_ushort, &comm_chunk.aiff_comm_channels);
932 /* needs to be fixed when closed */
933 tmp_uint = AUDIO_AIFF_UNKNOWN_SIZE;
934 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &tmp_uint2);
935 AUDIO_AIFF_COMM_INT2FRAMES(comm_chunk.aiff_comm_frames, tmp_uint2);
936 tmp_ushort = hdrp->bytes_per_unit * 8;
937 AUDIO_AIFF_HOST2FILE_SHORT(&tmp_ushort,
938 &comm_chunk.aiff_comm_sample_size);
939 convert_to_ieee_extended((double)hdrp->sample_rate,
940 comm_chunk.aiff_comm_sample_rate);
941 (void) memcpy(&buf[buf_size], &comm_chunk, AUDIO_AIFF_COMM_CHUNK_SIZE);
942 buf_size += AUDIO_AIFF_COMM_CHUNK_SIZE;
943
944 /* build the SSND chunk */
945 tmp_uint = AUDIO_AIFF_SSND_ID;
946 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &ssnd_chunk.aiff_ssnd_ID);
947 /* needs to be fixed when closed */
948 tmp_uint = AUDIO_AIFF_UNKNOWN_SIZE;
949 AUDIO_AIFF_HOST2FILE_INT(&tmp_uint, &ssnd_chunk.aiff_ssnd_size);
950 ssnd_chunk.aiff_ssnd_offset = 0;
951 ssnd_chunk.aiff_ssnd_block_size = 0;
952 (void) memcpy(&buf[buf_size], &ssnd_chunk, sizeof (ssnd_chunk));
953 buf_size += sizeof (ssnd_chunk);
954
955 *blen = buf_size;
956
957 return (AUDIO_SUCCESS);
958
959 } /* audio_encode_aiff() */
960
961 /*
962 * Encode a .au file header from the supplied Audio_hdr structure and
963 * store in the supplied char* buffer. blen is the size of the buffer to
964 * store the header in. If 'infop' is not NULL, it is the address of a
965 * buffer containing 'info' data. 'ilen' specifies the size of this buffer.
966 * The entire file header will be zero-padded to a double-word boundary.
967 *
968 * NOTE: .au doesn't support unsigned 8-bit linear PCM.
969 */
970 static int
audio_encode_au(Audio_hdr * hdrp,char * infop,unsigned int ilen,unsigned char * buf,unsigned int * blen)971 audio_encode_au(Audio_hdr *hdrp, char *infop, unsigned int ilen,
972 unsigned char *buf, unsigned int *blen)
973 /* audio header */
974 /* info buffer pointer */
975 /* info buffer size */
976 /* output buffer */
977 /* output buffer size */
978 {
979 au_filehdr_t fhdr;
980 int encoding;
981 int hdrsize;
982 int magic;
983 int offset;
984
985 /*
986 * Set the size of the real header (hdr size + info size).
987 * If no supplied info, make sure a minimum size is accounted for.
988 * Also, round the whole thing up to double-word alignment.
989 */
990 if ((infop == NULL) || (ilen == 0)) {
991 infop = NULL;
992 ilen = 4;
993 }
994 hdrsize = sizeof (fhdr) + ilen;
995 offset = ROUND_DBL(hdrsize);
996
997 /* Check the data encoding. */
998 switch (hdrp->encoding) {
999 case AUDIO_ENCODING_LINEAR8:
1000 return (AUDIO_ERR_ENCODING); /* we don't support ulinear */
1001 case AUDIO_ENCODING_ULAW:
1002 if (hdrp->samples_per_unit != 1)
1003 return (AUDIO_ERR_BADHDR);
1004
1005 switch (hdrp->bytes_per_unit) {
1006 case 1:
1007 encoding = AUDIO_AU_ENCODING_ULAW;
1008 break;
1009 default:
1010 return (AUDIO_ERR_BADHDR);
1011 }
1012 break;
1013 case AUDIO_ENCODING_ALAW:
1014 if (hdrp->samples_per_unit != 1)
1015 return (AUDIO_ERR_BADHDR);
1016
1017 switch (hdrp->bytes_per_unit) {
1018 case 1:
1019 encoding = AUDIO_AU_ENCODING_ALAW;
1020 break;
1021 default:
1022 return (AUDIO_ERR_BADHDR);
1023 }
1024 break;
1025 case AUDIO_ENCODING_LINEAR:
1026 if (hdrp->samples_per_unit != 1)
1027 return (AUDIO_ERR_BADHDR);
1028
1029 switch (hdrp->bytes_per_unit) {
1030 case 1:
1031 encoding = AUDIO_AU_ENCODING_LINEAR_8;
1032 break;
1033 case 2:
1034 encoding = AUDIO_AU_ENCODING_LINEAR_16;
1035 break;
1036 case 3:
1037 encoding = AUDIO_AU_ENCODING_LINEAR_24;
1038 break;
1039 case 4:
1040 encoding = AUDIO_AU_ENCODING_LINEAR_32;
1041 break;
1042 default:
1043 return (AUDIO_ERR_BADHDR);
1044 }
1045 break;
1046 case AUDIO_ENCODING_FLOAT:
1047 if (hdrp->samples_per_unit != 1)
1048 return (AUDIO_ERR_BADHDR);
1049
1050 switch (hdrp->bytes_per_unit) {
1051 case 4:
1052 encoding = AUDIO_AU_ENCODING_FLOAT;
1053 break;
1054 case 8:
1055 encoding = AUDIO_AU_ENCODING_DOUBLE;
1056 break;
1057 default:
1058 return (AUDIO_ERR_BADHDR);
1059 }
1060 break;
1061 case AUDIO_ENCODING_G721:
1062 if (hdrp->bytes_per_unit != 1)
1063 return (AUDIO_ERR_BADHDR);
1064 else if (hdrp->samples_per_unit != 2)
1065 return (AUDIO_ERR_BADHDR);
1066 else
1067 encoding = AUDIO_AU_ENCODING_ADPCM_G721;
1068 break;
1069 case AUDIO_ENCODING_G723:
1070 if (hdrp->samples_per_unit != 8)
1071 return (AUDIO_ERR_BADHDR);
1072 else if (hdrp->bytes_per_unit == 3)
1073 encoding = AUDIO_AU_ENCODING_ADPCM_G723_3;
1074 else if (hdrp->bytes_per_unit == 5)
1075 encoding = AUDIO_AU_ENCODING_ADPCM_G723_5;
1076 else
1077 return (AUDIO_ERR_BADHDR);
1078 break;
1079 default:
1080 return (AUDIO_ERR_BADHDR);
1081 }
1082
1083 /* copy the fhdr into the supplied buffer - make sure it'll fit */
1084 if (*blen < offset) {
1085 /* XXX - is this apropriate? */
1086 return (AUDIO_EOF);
1087 }
1088
1089 /* reset blen to actual size of hdr data */
1090 *blen = (unsigned)offset;
1091
1092 magic = AUDIO_AU_FILE_MAGIC; /* set the magic number */
1093
1094 /* Encode the audio header structure. */
1095 AUDIO_AU_HOST2FILE(&magic, &fhdr.au_magic);
1096 AUDIO_AU_HOST2FILE(&offset, &fhdr.au_offset);
1097 AUDIO_AU_HOST2FILE(&hdrp->data_size, &fhdr.au_data_size);
1098 AUDIO_AU_HOST2FILE(&encoding, &fhdr.au_encoding);
1099 AUDIO_AU_HOST2FILE(&hdrp->sample_rate, &fhdr.au_sample_rate);
1100 AUDIO_AU_HOST2FILE(&hdrp->channels, &fhdr.au_channels);
1101
1102 /* Copy to the buffer */
1103 (void) memcpy(buf, &fhdr, sizeof (fhdr));
1104
1105 /* Copy the info data, if present */
1106 if (infop != NULL) {
1107 (void) memcpy(&buf[sizeof (fhdr)], infop, (int)ilen);
1108 buf += ilen;
1109 }
1110
1111 if (offset > hdrsize) {
1112 (void) memset(&buf[hdrsize], '\0', (size_t)(offset - hdrsize));
1113 }
1114
1115 /* buf now has the data, just return ... */
1116
1117 return (AUDIO_SUCCESS);
1118
1119 } /* audio_encode_au() */
1120
1121 /*
1122 * Encode a .wav file header from the supplied Audio_hdr structure and
1123 * store in the supplied char* buffer. blen is the size of the buffer to
1124 * store the header in. .wav doesn't support an information string like
1125 * .au does.
1126 *
1127 * NOTE: .wav only supports a few encoding methods.
1128 */
1129 static int
audio_encode_wav(Audio_hdr * hdrp,unsigned char * buf,unsigned int * blen)1130 audio_encode_wav(Audio_hdr *hdrp, unsigned char *buf, unsigned int *blen)
1131 /* audio header */
1132 /* output buffer */
1133 /* output buffer size */
1134 {
1135 wav_filehdr_t fhdr;
1136 int bytes_per_second;
1137 int bytes_per_sample;
1138 int bits_per_sample;
1139 int id;
1140 int length;
1141 int type;
1142 short encoding;
1143
1144 /* make sure we've got valid encoding and precision settings for .wav */
1145 switch (hdrp->encoding) {
1146 case AUDIO_ENCODING_LINEAR8:
1147 if (hdrp->bytes_per_unit != 1) {
1148 return (AUDIO_ERR_ENCODING);
1149 }
1150 encoding = AUDIO_WAV_FMT_ENCODING_PCM;
1151 break;
1152 case AUDIO_ENCODING_ULAW:
1153 if (hdrp->bytes_per_unit != 1) {
1154 return (AUDIO_ERR_ENCODING);
1155 }
1156 encoding = AUDIO_WAV_FMT_ENCODING_MULAW;
1157 break;
1158 case AUDIO_ENCODING_ALAW:
1159 if (hdrp->bytes_per_unit != 1) {
1160 return (AUDIO_ERR_ENCODING);
1161 }
1162 encoding = AUDIO_WAV_FMT_ENCODING_ALAW;
1163 break;
1164 case AUDIO_ENCODING_LINEAR:
1165 if (hdrp->bytes_per_unit != 2) {
1166 return (AUDIO_ERR_ENCODING);
1167 }
1168 encoding = AUDIO_WAV_FMT_ENCODING_PCM;
1169 break;
1170 default:
1171 return (AUDIO_ERR_ENCODING);
1172 }
1173
1174 /* fill in the riff chunk */
1175 id = AUDIO_WAV_RIFF_ID;
1176 length = AUDIO_WAV_UNKNOWN_SIZE;
1177 AUDIO_WAV_HOST2FILE_INT(&id, &fhdr.wav_riff_ID);
1178 AUDIO_WAV_HOST2FILE_INT(&length, &fhdr.wav_riff_size);
1179
1180 /* fill in the type chunk */
1181 type = AUDIO_WAV_TYPE_ID;
1182 AUDIO_WAV_HOST2FILE_INT(&type, &fhdr.wav_type_ID);
1183
1184
1185 /* fill in the format chunk */
1186 id = AUDIO_WAV_FORMAT_ID;
1187 length = AUDIO_WAV_FORMAT_SIZE;
1188 bytes_per_second = hdrp->sample_rate * hdrp->channels *
1189 hdrp->bytes_per_unit;
1190 bytes_per_sample = hdrp->channels * hdrp->bytes_per_unit;
1191 bits_per_sample = hdrp->bytes_per_unit * 8;
1192
1193 AUDIO_WAV_HOST2FILE_INT(&id, &fhdr.wav_fmt_ID);
1194 AUDIO_WAV_HOST2FILE_INT(&length, &fhdr.wav_fmt_size);
1195 AUDIO_WAV_HOST2FILE_SHORT(&encoding, &fhdr.wav_fmt_encoding);
1196 AUDIO_WAV_HOST2FILE_SHORT(&hdrp->channels, &fhdr.wav_fmt_channels);
1197 AUDIO_WAV_HOST2FILE_INT(&hdrp->sample_rate, &fhdr.wav_fmt_sample_rate);
1198 AUDIO_WAV_HOST2FILE_INT(&bytes_per_second,
1199 &fhdr.wav_fmt_bytes_per_second);
1200 AUDIO_WAV_HOST2FILE_SHORT(&bytes_per_sample,
1201 &fhdr.wav_fmt_bytes_per_sample);
1202 AUDIO_WAV_HOST2FILE_SHORT(&bits_per_sample,
1203 &fhdr.wav_fmt_bits_per_sample);
1204
1205 /* fill in the data chunk */
1206 id = AUDIO_WAV_DATA_ID_LC;
1207 length = AUDIO_WAV_UNKNOWN_SIZE;
1208 AUDIO_WAV_HOST2FILE_INT(&id, &fhdr.wav_data_ID);
1209 AUDIO_WAV_HOST2FILE_INT(&length, &fhdr.wav_data_size);
1210
1211 *blen = sizeof (fhdr);
1212
1213 /* copy to the buffer */
1214 (void) memcpy(buf, &fhdr, sizeof (fhdr));
1215
1216 return (AUDIO_SUCCESS);
1217
1218 } /* audio_encode_wav() */
1219
1220 /*
1221 * Utility routine used to convert 10 byte IEEE extended float into
1222 * a regular double. Raw data arrives in an unsigned char array. Because
1223 * this is for sample rate, which is always positive, we don't worry
1224 * about the sign.
1225 */
1226 static double
convert_from_ieee_extended(unsigned char * data)1227 convert_from_ieee_extended(unsigned char *data)
1228 {
1229 double value = 0.0;
1230 unsigned long high_mantissa;
1231 unsigned long low_mantissa;
1232 int exponent;
1233
1234 /* first 2 bytes are the exponent */
1235 exponent = ((data[0] & 0x7f) << 8) | data[1];
1236
1237 high_mantissa = ((unsigned long)data[2] << 24) |
1238 ((unsigned long)data[3] << 16) |
1239 ((unsigned long)data[4] << 8) |
1240 (unsigned long)data[5];
1241 low_mantissa = ((unsigned long)data[6] << 24) |
1242 ((unsigned long)data[7] << 16) |
1243 ((unsigned long)data[8] << 8) |
1244 (unsigned long)data[9];
1245
1246 /* convert exponent and mantissas into a real double */
1247 if (exponent == 0 && high_mantissa == 0 && low_mantissa == 0) {
1248 /* everything is 0, so we're done */
1249 value = 0.0;
1250 } else {
1251 if (exponent == 0x7fff) { /* infinity */
1252 value = MAXFLOAT;
1253 } else {
1254 /* convert exponent from being unsigned to signed */
1255 exponent -= 0x3fff;
1256
1257 exponent -= 31;
1258 value = ldexp((double)high_mantissa, exponent);
1259
1260 exponent -= 32;
1261 value += ldexp((double)low_mantissa, exponent);
1262 }
1263 }
1264
1265 return (value);
1266
1267 }
1268
1269 /*
1270 * Utility routine to convert a double into 10 byte IEEE extended floating
1271 * point. The new number is placed into the unsigned char array. This is a
1272 * very brain dead convesion routine. It only supports integers, but then
1273 * that should be all we need for sample rate.
1274 */
1275 static void
convert_to_ieee_extended(double value,unsigned char * data)1276 convert_to_ieee_extended(double value, unsigned char *data)
1277 {
1278 double fmantissa;
1279 int exponent;
1280 int mantissa;
1281
1282 exponent = 16398;
1283 fmantissa = value;
1284
1285 while (fmantissa < 44000) {
1286 fmantissa *= 2;
1287 exponent--;
1288 }
1289
1290 mantissa = (int)fmantissa << 16;
1291
1292 data[0] = exponent >> 8;
1293 data[1] = exponent;
1294 data[2] = mantissa >> 24;
1295 data[3] = mantissa >> 16;
1296 data[4] = mantissa >> 8;
1297 data[5] = mantissa;
1298 data[6] = 0;
1299 data[7] = 0;
1300 data[8] = 0;
1301 data[9] = 0;
1302
1303 }
1304