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 1993-2003 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 #include <string.h>
30 #include <stdio.h>
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <memory.h>
36 #include <unistd.h>
37
38 #include <sys/types.h>
39 #include <sys/stat.h>
40 #include <sys/file.h>
41 #include <sys/t_lock.h>
42
43 #include <AudioDebug.h>
44 #include <AudioUnixfile.h>
45 #include <libaudio.h>
46 #include <audio_hdr.h>
47 #include <audio/au.h>
48
49 // class AudioUnixfile methods
50
51 // Constructor with pathname and mode arg
52 AudioUnixfile::
AudioUnixfile(const char * path,const FileAccess acc)53 AudioUnixfile(
54 const char *path, // pathname
55 const FileAccess acc): // access mode
56 AudioStream(path), fd(-1), block(TRUE), mode(acc),
57 infostring(new char[1]), infolength(1)
58 {
59 infostring[0] = '\0';
60 }
61
62 // Destructor
63 AudioUnixfile::
~AudioUnixfile()64 ~AudioUnixfile()
65 {
66 // If the file is open, close it
67 if (opened())
68 (void) Close();
69
70 // Deallocate the dynamic storage
71 delete infostring;
72 }
73
74 // Generic open with search path routine just calls default Open()
75 AudioError AudioUnixfile::
OpenPath(const char *)76 OpenPath(
77 const char *)
78 {
79 return (Open());
80 }
81
82 // Decode an audio file header
83 // This routine reads the audio file header and decodes it.
84 //
85 // This method should be specialized by subclasses that are not files,
86 // like devices for instance.
87 //
88 // XXX - this routine should be rewritten for C++
89 AudioError AudioUnixfile::
decode_filehdr()90 decode_filehdr()
91 {
92 Boolean saveblock; // saved state of the blocking i/o flag
93 AudioHdr hdr_local; // local copy of header
94 Audio_hdr ohdr; // XXX - old libaudio hdr
95 au_filehdr_t fhdr;
96 char *ibuf;
97 int file_type;
98 int infosize;
99 int cnt;
100 struct stat st;
101 AudioError err;
102
103 // If fd is not open, or file header already decoded, skip it
104 if (!isfdset() || opened())
105 return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));
106
107 // Stat the file, to see if it is a regular file
108 if (fstat(getfd(), &st) < 0)
109 return (RaiseError(AUDIO_UNIXERROR));
110
111 // Make sure the file is not set for blocking i/o
112 saveblock = GetBlocking();
113 if (!saveblock)
114 SetBlocking(TRUE);
115
116 // Read the file header, but not the info field
117 // XXX - Should use C++ input method
118 cnt = read(getfd(), (char *)&fhdr, sizeof (fhdr));
119 if (cnt != sizeof (fhdr)) {
120 return (RaiseError(AUDIO_UNIXERROR));
121 }
122
123 // Check the validity of the header and get the size of the info field
124 err = (AudioError) audio_decode_filehdr(getfd(), (unsigned char *)&fhdr,
125 &file_type, &ohdr, &infosize);
126 if (err != AUDIO_SUCCESS)
127 return (RaiseError(err));
128
129 // Allocate and read in the info field
130 ibuf = new char[infosize];
131 cnt = read(getfd(), ibuf, infosize);
132 if (cnt != infosize) {
133 delete ibuf;
134 return (RaiseError(AUDIO_UNIXERROR));
135 }
136 SetBlocking(saveblock); // Restore the saved blocking i/o state
137
138 // XXX - convert from libaudio header
139 hdr_local = GetHeader();
140 hdr_local.sample_rate = ohdr.sample_rate;
141 hdr_local.samples_per_unit = ohdr.samples_per_unit;
142 hdr_local.bytes_per_unit = ohdr.bytes_per_unit;
143 hdr_local.channels = ohdr.channels;
144 hdr_local.encoding = (AudioEncoding) ohdr.encoding;
145 hdr_local.endian = BIG_ENDIAN; // Files are always written in
146 // big endian.
147
148 err = SetHeader(hdr_local);
149 if (err != AUDIO_SUCCESS) {
150 delete ibuf;
151 return (RaiseError(err));
152 }
153 SetInfostring(ibuf, infosize);
154 delete ibuf;
155
156 // Only trust the file size for regular files
157 if (S_ISREG(st.st_mode)) {
158 setlength(GetHeader().Bytes_to_Time(
159 st.st_size - infosize - sizeof (au_filehdr_t)));
160
161 // Sanity check
162 if ((ohdr.data_size != AUDIO_UNKNOWN_SIZE) &&
163 (GetLength() != GetHeader().Bytes_to_Time(ohdr.data_size)))
164 PrintMsg(_MGET_(
165 "AudioUnixfile: header/file size mismatch"));
166
167 // always consider it to be unknown if not reading a real file
168 // since there's no real way to verify if the header is
169 // correct.
170 } else {
171 setlength(AUDIO_UNKNOWN_TIME);
172 }
173
174 // set flag for opened() test
175 filehdrset = TRUE;
176
177 return (AUDIO_SUCCESS);
178 }
179
180 // Write an audio file header
181 // This routine encodes the audio file header and writes it out.
182 // XXX - It assumes that the file pointer is set to the start of the file.
183 //
184 // This method should be specialized by subclasses that are not files,
185 // like devices for instance.
186 //
187 // XXX - this routine should be rewritten for C++
188 AudioError AudioUnixfile::
encode_filehdr()189 encode_filehdr()
190 {
191 Boolean saveblock; // saved state of the blocking i/o flag
192 AudioHdr hdr_local; // local copy of header
193 Audio_hdr ohdr; // XXX - old libaudio hdr
194 AudioError err;
195
196 // If fd is not open, or file header already written, skip it
197 if (!isfdset() || opened())
198 return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));
199
200 // XXX - Set up the libaudio hdr
201 hdr_local = GetHeader();
202 hdr_local.endian = BIG_ENDIAN; // Files are always written big endian.
203 err = SetHeader(hdr_local);
204 if (err != AUDIO_SUCCESS) {
205 return (RaiseError(err));
206 }
207
208 ohdr.sample_rate = hdr_local.sample_rate;
209 ohdr.samples_per_unit = hdr_local.samples_per_unit;
210 ohdr.bytes_per_unit = hdr_local.bytes_per_unit;
211 ohdr.channels = hdr_local.channels;
212 ohdr.encoding = hdr_local.encoding;
213 if (Undefined(GetLength()))
214 ohdr.data_size = AUDIO_UNKNOWN_SIZE;
215 else
216 ohdr.data_size = (uint_t)GetHeader().Time_to_Bytes(GetLength());
217
218 /* Make sure the file is not set for blocking i/o */
219 saveblock = GetBlocking();
220 if (!saveblock)
221 SetBlocking(TRUE);
222
223 // XXX - Should use C++ output method
224 err = (AudioError) audio_write_filehdr(getfd(), &ohdr, FILE_AU,
225 infostring, infolength);
226
227 // set flag for opened() test
228 if (err == AUDIO_SUCCESS)
229 filehdrset = TRUE;
230
231 SetBlocking(saveblock); // Restore the saved blocking i/o state
232 return (RaiseError(err));
233 }
234
235 // Set a file blocking/non-blocking
236 // This method should be subclassed by objects that always block (eg, files)
237 void AudioUnixfile::
SetBlocking(Boolean b)238 SetBlocking(
239 Boolean b) // FALSE to set non-blocking
240 {
241 int flag;
242
243 // If the file is open, set blocking/non-blocking now
244 if (isfdset()) {
245 flag = fcntl(getfd(), F_GETFL, 0);
246 if ((flag < 0) && (errno == EOVERFLOW || errno == EINVAL)) {
247 RaiseError(AUDIO_UNIXERROR, Fatal,
248 (char *)"Large File");
249 } else if (b) {
250 flag &= ~(O_NDELAY | O_NONBLOCK); // set blocking
251 } else {
252 flag |= O_NONBLOCK; // set non-blocking
253 }
254 if (fcntl(getfd(), F_SETFL, flag) < 0) {
255 RaiseError(AUDIO_UNIXERROR, Warning);
256 }
257 }
258 // Set the blocking flag (this may affect the Open() behavior)
259 block = b;
260 }
261
262 // Return a pointer to the info string
263 // XXX - returns a pointer to the string stored in the object
264 // XXX - assumes ASCII data
265 char *const AudioUnixfile::
GetInfostring(int & len) const266 GetInfostring(
267 int& len) const // returned length of string
268 {
269 len = infolength;
270 return (infostring);
271 }
272
273 // Set the info string
274 void AudioUnixfile::
SetInfostring(const char * str,int len)275 SetInfostring(
276 const char *str, // new info string
277 int len) // length of string
278 {
279 // If length defaulted, assume an ASCII string
280 if (len == -1)
281 len = strlen(str) + 1;
282 delete infostring;
283 infostring = new char[len];
284 infolength = len;
285 (void) memcpy(infostring, str, len);
286 }
287
288 // Close file
289 AudioError AudioUnixfile::
Close()290 Close()
291 {
292 // If the file is open, close it
293 if (isfdset()) {
294 if (close(getfd()) < 0)
295 return (RaiseError(AUDIO_UNIXERROR));
296 } else {
297 return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));
298 }
299
300 // Init important values, in case the file is reopened
301 setfd(-1);
302 filehdrset = FALSE;
303 (void) SetReadPosition((Double)0., Absolute);
304 (void) SetWritePosition((Double)0., Absolute);
305 return (AUDIO_SUCCESS);
306 }
307
308 // Read data from underlying file into specified buffer.
309 // No data format translation takes place.
310 // The object's read position is not updated (subclasses can change this)
311 AudioError AudioUnixfile::
ReadData(void * buf,size_t & len,Double & pos)312 ReadData(
313 void* buf, // destination buffer address
314 size_t& len, // buffer length (updated)
315 Double& pos) // start position (updated)
316 {
317 off_t offset;
318 off_t cnt;
319 AudioError err;
320
321 // Save buffer size and zero transfer count
322 cnt = (off_t)len;
323 len = 0;
324
325 // Cannot read if file is not open
326 if (!opened() || !mode.Readable())
327 return (RaiseError(AUDIO_ERR_NOEFFECT));
328
329 // Position must be valid
330 if (Undefined(pos) || (pos < 0.) || (cnt < 0))
331 return (RaiseError(AUDIO_ERR_BADARG));
332
333 // Position the file pointer to the right place
334 err = seekread(pos, offset);
335 if (err != AUDIO_SUCCESS)
336 return (err);
337
338 // Check for EOF
339 if (pos >= GetLength()) {
340 err = AUDIO_EOF;
341 err.sys = AUDIO_COPY_INPUT_EOF;
342 return (err);
343 }
344
345 // Zero-length reads are finished
346 if (GetHeader().Bytes_to_Bytes(cnt) == 0) {
347 err = AUDIO_SUCCESS;
348 err.sys = AUDIO_COPY_ZERO_LIMIT;
349 return (err);
350 }
351
352 // Read as much data as possible
353 cnt = read(fd, (char *)buf, (int)cnt);
354 if (cnt < 0) {
355 if (errno == EOVERFLOW) {
356 perror("read");
357 exit(1);
358 } else if ((errno == EINTR) ||
359 (((errno == EWOULDBLOCK) || (errno == EAGAIN)) &&
360 !GetBlocking())) {
361 // Is this an interrupted or failed non-blocking request?
362 err = AUDIO_SUCCESS;
363 err.sys = AUDIO_COPY_SHORT_INPUT;
364 return (err);
365 }
366 return (RaiseError(AUDIO_UNIXERROR));
367 }
368
369 // End-of-file?
370 if ((cnt == 0) && GetBlocking()) {
371 if (isDevice() || isPipe()) {
372 AUDIO_DEBUG((1,
373 "Zero-length blocking device/pipe read?!\n"));
374 }
375 err = AUDIO_EOF;
376 err.sys = AUDIO_COPY_INPUT_EOF;
377 return (err);
378 }
379 err = AUDIO_SUCCESS;
380 if (cnt == 0) {
381 err.sys = AUDIO_COPY_SHORT_INPUT;
382 }
383
384 // Return the updated byte count and position
385 len = (size_t)cnt;
386 if (GetHeader().Bytes_to_Bytes(cnt) != len) {
387 AUDIO_DEBUG((1,
388 "Read returned a partial sample frame?!\n"));
389 }
390 pos = GetHeader().Bytes_to_Time(offset + len);
391
392 // Check to see if the endian is right.
393 coerceEndian((unsigned char *)buf, len, localByteOrder());
394
395 return (err);
396 }
397
398 // Write data to underlying file from specified buffer.
399 // No data format translation takes place.
400 // The object's write position is not updated (subclasses can change this)
401 AudioError AudioUnixfile::
WriteData(void * buf,size_t & len,Double & pos)402 WriteData(
403 void* buf, // source buffer address
404 size_t& len, // buffer length (updated)
405 Double& pos) // start position (updated)
406 {
407 off_t offset;
408 off_t cnt;
409 AudioError err;
410
411 // Save buffer size and zero transfer count
412 cnt = (off_t)len;
413 len = 0;
414
415 // Cannot write if file is not open
416 if (!opened() || !mode.Writeable())
417 return (RaiseError(AUDIO_ERR_NOEFFECT));
418
419 // Position must be valid
420 if (Undefined(pos) || (pos < 0.) || (cnt < 0))
421 return (RaiseError(AUDIO_ERR_BADARG));
422
423 // Zero-length writes are easy
424 if (GetHeader().Bytes_to_Bytes(cnt) == 0) {
425 err = AUDIO_SUCCESS;
426 err.sys = AUDIO_COPY_ZERO_LIMIT;
427 return (err);
428 }
429
430 // Position the file pointer to the right place
431 err = seekwrite(pos, offset);
432 if (err != AUDIO_SUCCESS)
433 return (err);
434
435 // Make sure data is in target's endian format before writing.
436 // This conversion is done inplace so we need to change back.
437 // We assume that the data in buf is in localByteOrder.
438 // Only files should have order issues.
439 if (localByteOrder() != GetHeader().endian)
440 coerceEndian((unsigned char *)buf, (size_t)cnt, SWITCH_ENDIAN);
441
442 // Write as much data as possible
443 err = AUDIO_SUCCESS;
444 cnt = write(fd, (char *)buf, (int)cnt);
445 if (cnt < 0) {
446 if (errno == EFBIG) {
447 perror("write");
448 exit(1);
449 } else if ((errno == EWOULDBLOCK) || (errno == EAGAIN)) {
450 // Is this a failed non-blocking request?
451 err.sys = AUDIO_COPY_SHORT_OUTPUT;
452 return (err);
453 }
454 return (RaiseError(AUDIO_UNIXERROR));
455 }
456 if (cnt == 0)
457 err.sys = AUDIO_COPY_SHORT_OUTPUT;
458
459 // Switch the endian back if local order doesn't match target order.
460 if (localByteOrder() != GetHeader().endian)
461 coerceEndian((unsigned char *)buf, (size_t)cnt, SWITCH_ENDIAN);
462
463 // Return the updated byte count and position
464 len = (size_t)cnt;
465 pos = GetHeader().Bytes_to_Time(offset + len);
466
467 // If the current position is beyond old EOF, update the size
468 if (!Undefined(GetLength()) && (pos > GetLength())) {
469 setlength(pos);
470 }
471
472 return (AUDIO_SUCCESS);
473 }
474
475 // Seek in input stream
476 // Ordinary streams (ie, pipes and devices) cannot be rewound.
477 // A forward seek in them consumes data by reading it.
478 //
479 // This method should be specialized by subclasses that can actually seek,
480 // like regular files for instance.
481 //
482 AudioError AudioUnixfile::
seekread(Double pos,off_t & offset)483 seekread(
484 Double pos, // position to seek to
485 off_t& offset) // returned byte offset
486 {
487 char *bufp; // temporary input buffer
488 size_t bufl; // input buffer size
489 size_t cnt; // input byte count
490 long icnt; // read size
491 Boolean saveblock; // saved state of the blocking i/o flag
492 Double buflen;
493 AudioError err;
494
495 offset = GetHeader().Time_to_Bytes(pos);
496 pos -= ReadPosition();
497
498 // If the seek is backwards, do nothing
499 if (pos < 0.)
500 return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));
501
502 // If the seek is to the current position, then do nothing.
503 icnt = GetHeader().Time_to_Bytes(pos);
504 if (icnt == 0)
505 return (AUDIO_SUCCESS);
506
507 // The seek is determinate and forward.
508 // We'll have to consume data to get there.
509 // First allocate a buffer to stuff the data into.
510 // Then set the stream for blocking i/o (saving the old state).
511 buflen = max(pos, 1.);
512 bufl = (size_t)GetHeader().Time_to_Bytes(buflen);
513 bufp = new char[bufl];
514 if (bufp == 0) { // allocation error, try a smaller buf
515 bufl = (size_t)sysconf(_SC_PAGESIZE);
516 bufp = new char[bufl];
517 if (bufp == 0)
518 return (RaiseError(AUDIO_UNIXERROR));
519 }
520 // XXX - May have to realign to partial frame count!
521
522 saveblock = GetBlocking();
523 if (!saveblock)
524 SetBlocking(TRUE);
525
526 // Loop until the seek is satisfied (or an error occurs).
527 do {
528 // Limit the read to keep from going too far
529 cnt = (icnt >= (long)bufl) ? bufl : (size_t)icnt;
530 err = Read(bufp, cnt);
531 if (err != AUDIO_SUCCESS)
532 break;
533 icnt -= (long)cnt;
534 } while (icnt > 0);
535
536 SetBlocking(saveblock); // Restore the saved blocking i/o state
537 delete bufp; // Free the temporary buffer
538 return (RaiseError(err));
539 }
540
541 // Seek in output stream
542 // Ordinary streams (ie, pipes and devices) cannot be rewound.
543 // A forward seek in them writes NULL data.
544 //
545 // This method should be specialized by subclasses that can actually seek,
546 // like regular files for instance.
547 //
548 AudioError AudioUnixfile::
seekwrite(Double pos,off_t & offset)549 seekwrite(
550 Double pos, // position to seek to
551 off_t& offset) // returned byte offset
552 {
553 char *bufp; // temporary output buffer
554 size_t bufl; // output buffer size
555 size_t cnt; // output byte count
556 long ocnt; // write size
557 Boolean saveblock; // saved state of the blocking i/o flag
558 Double buflen;
559 AudioError err;
560
561 offset = GetHeader().Time_to_Bytes(pos);
562 pos -= WritePosition();
563
564 // If the seek is backwards, do nothing
565 if (pos < 0.)
566 return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));
567
568 // If the seek is to the current position, then do nothing.
569 ocnt = GetHeader().Time_to_Bytes(pos);
570 if (ocnt == 0)
571 return (AUDIO_SUCCESS);
572
573 // The seek is determinate and forward.
574 // We'll have to produce NULL data to get there.
575 // XXX - not implemented correctly yet
576 buflen = max(pos, 1.);
577 bufl = (size_t)GetHeader().Time_to_Bytes(buflen);
578 bufp = new char[bufl];
579 if (bufp == 0) { // allocation error, try a smaller buf
580 bufl = (size_t)sysconf(_SC_PAGESIZE);
581 bufp = new char[bufl];
582 if (bufp == 0)
583 return (RaiseError(AUDIO_UNIXERROR));
584 }
585
586 // XXX - May have to realign to partial frame count!
587 saveblock = GetBlocking();
588 if (!saveblock)
589 SetBlocking(TRUE);
590
591 // Loop until the seek is satisfied (or an error occurs).
592 do {
593 // Limit the write to keep from going too far
594 cnt = (ocnt >= (long)bufl) ? bufl : (size_t)ocnt;
595 err = Write(bufp, cnt);
596 if (err != AUDIO_SUCCESS)
597 break;
598 ocnt -= (long)cnt;
599 } while (ocnt > 0);
600
601 SetBlocking(saveblock); // Restore the saved blocking i/o state
602 delete bufp; // Free the temporary buffer
603 return (RaiseError(err));
604 }
605