/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 1993-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/t_lock.h>

#include <AudioDebug.h>
#include <AudioUnixfile.h>
#include <libaudio.h>
#include <audio_hdr.h>
#include <audio/au.h>

// class AudioUnixfile methods

// Constructor with pathname and mode arg
AudioUnixfile::
AudioUnixfile(
        const char              *path,          // pathname
        const FileAccess        acc):           // access mode
        AudioStream(path), mode(acc), block(TRUE), fd(-1),
        infostring(new char[1]), infolength(1)
{
        infostring[0] = '\0';
}

// Destructor
AudioUnixfile::
~AudioUnixfile()
{
        // If the file is open, close it
        if (opened())
                (void) Close();

        // Deallocate the dynamic storage
        delete infostring;
}

// Generic open with search path routine just calls default Open()
AudioError AudioUnixfile::
OpenPath(
        const char *)
{
        return (Open());
}

// Decode an audio file header
// This routine reads the audio file header and decodes it.
//
// This method should be specialized by subclasses that are not files,
// like devices for instance.
//
// XXX - this routine should be rewritten for C++
AudioError AudioUnixfile::
decode_filehdr()
{
        Boolean         saveblock;      // saved state of the blocking i/o flag
        AudioHdr        hdr_local;      // local copy of header
        Audio_hdr       ohdr;           // XXX - old libaudio hdr
        au_filehdr_t    fhdr;
        char            *ibuf;
        int             file_type;
        int             infosize;
        int             cnt;
        struct stat     st;
        AudioError      err;

        // If fd is not open, or file header already decoded, skip it
        if (!isfdset() || opened())
                return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));

        // Stat the file, to see if it is a regular file
        if (fstat(getfd(), &st) < 0)
                return (RaiseError(AUDIO_UNIXERROR));

        // Make sure the file is not set for blocking i/o
        saveblock = GetBlocking();
        if (!saveblock)
                SetBlocking(TRUE);

        // Read the file header, but not the info field
        // XXX - Should use C++ input method
        cnt = read(getfd(), (char *)&fhdr, sizeof (fhdr));
        if (cnt != sizeof (fhdr)) {
                return (RaiseError(AUDIO_UNIXERROR));
        }

        // Check the validity of the header and get the size of the info field
        err = (AudioError) audio_decode_filehdr(getfd(), (unsigned char *)&fhdr,
            &file_type, &ohdr, &infosize);
        if (err != AUDIO_SUCCESS)
                return (RaiseError(err));

        // Allocate and read in the info field
        ibuf = new char[infosize];
        cnt = read(getfd(), ibuf, infosize);
        if (cnt != infosize) {
                delete[] ibuf;
                return (RaiseError(AUDIO_UNIXERROR));
        }
        SetBlocking(saveblock);         // Restore the saved blocking i/o state

        // XXX - convert from libaudio header
        hdr_local = GetHeader();
        hdr_local.sample_rate = ohdr.sample_rate;
        hdr_local.samples_per_unit = ohdr.samples_per_unit;
        hdr_local.bytes_per_unit = ohdr.bytes_per_unit;
        hdr_local.channels = ohdr.channels;
        hdr_local.encoding = (AudioEncoding) ohdr.encoding;
        hdr_local.endian = BIG_ENDIAN; // Files are always written in
                                        // big endian.

        err = SetHeader(hdr_local);
        if (err != AUDIO_SUCCESS) {
                delete[] ibuf;
                return (RaiseError(err));
        }
        SetInfostring(ibuf, infosize);
        delete[] ibuf;

        // Only trust the file size for regular files
        if (S_ISREG(st.st_mode)) {
                setlength(GetHeader().Bytes_to_Time(
                    st.st_size - infosize - sizeof (au_filehdr_t)));

                // Sanity check
                if ((ohdr.data_size != AUDIO_UNKNOWN_SIZE) &&
                    (GetLength() != GetHeader().Bytes_to_Time(ohdr.data_size)))
                        PrintMsg(_MGET_(
                            "AudioUnixfile: header/file size mismatch"));

                // always consider it to be unknown if not reading a real file
                // since there's no real way to verify if the header is
                // correct.
        } else {
                setlength(AUDIO_UNKNOWN_TIME);
        }

        // set flag for opened() test
        filehdrset = TRUE;

        return (AUDIO_SUCCESS);
}

// Write an audio file header
// This routine encodes the audio file header and writes it out.
// XXX - It assumes that the file pointer is set to the start of the file.
//
// This method should be specialized by subclasses that are not files,
// like devices for instance.
//
// XXX - this routine should be rewritten for C++
AudioError AudioUnixfile::
encode_filehdr()
{
        Boolean         saveblock;      // saved state of the blocking i/o flag
        AudioHdr        hdr_local;      // local copy of header
        Audio_hdr       ohdr;           // XXX - old libaudio hdr
        AudioError      err;

        // If fd is not open, or file header already written, skip it
        if (!isfdset() || opened())
                return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));

        // XXX - Set up the libaudio hdr
        hdr_local = GetHeader();
        hdr_local.endian = BIG_ENDIAN; // Files are always written big endian.
        err = SetHeader(hdr_local);
        if (err != AUDIO_SUCCESS) {
                return (RaiseError(err));
        }

        ohdr.sample_rate = hdr_local.sample_rate;
        ohdr.samples_per_unit = hdr_local.samples_per_unit;
        ohdr.bytes_per_unit = hdr_local.bytes_per_unit;
        ohdr.channels = hdr_local.channels;
        ohdr.encoding = hdr_local.encoding;
        if (Undefined(GetLength()))
                ohdr.data_size = AUDIO_UNKNOWN_SIZE;
        else
                ohdr.data_size = (uint_t)GetHeader().Time_to_Bytes(GetLength());

        /* Make sure the file is not set for blocking i/o */
        saveblock = GetBlocking();
        if (!saveblock)
                SetBlocking(TRUE);

        // XXX - Should use C++ output method
        err = (AudioError) audio_write_filehdr(getfd(), &ohdr, FILE_AU,
            infostring, infolength);

        // set flag for opened() test
        if (err == AUDIO_SUCCESS)
                filehdrset = TRUE;

        SetBlocking(saveblock);         // Restore the saved blocking i/o state
        return (RaiseError(err));
}

// Set a file blocking/non-blocking
// This method should be subclassed by objects that always block (eg, files)
void AudioUnixfile::
SetBlocking(
        Boolean         b)                      // FALSE to set non-blocking
{
        int             flag;

        // If the file is open, set blocking/non-blocking now
        if (isfdset()) {
                flag = fcntl(getfd(), F_GETFL, 0);
                if ((flag < 0) && (errno == EOVERFLOW || errno == EINVAL)) {
                        RaiseError(AUDIO_UNIXERROR, Fatal,
                            (char *)"Large File");
                } else if (b) {
                        flag &= ~(O_NDELAY | O_NONBLOCK);       // set blocking
                } else {
                        flag |= O_NONBLOCK;             // set non-blocking
                }
                if (fcntl(getfd(), F_SETFL, flag) < 0) {
                        RaiseError(AUDIO_UNIXERROR, Warning);
                }
        }
        // Set the blocking flag (this may affect the Open() behavior)
        block = b;
}

// Return a pointer to the info string
// XXX - returns a pointer to the string stored in the object
// XXX - assumes ASCII data
char *AudioUnixfile::
GetInfostring(
        int&            len) const              // returned length of string
{
        len = infolength;
        return (infostring);
}

// Set the info string
void AudioUnixfile::
SetInfostring(
        const char      *str,                   // new info string
        int             len)                    // length of string
{
        // If length defaulted, assume an ASCII string
        if (len == -1)
                len = strlen(str) + 1;
        delete infostring;
        infostring = new char[len];
        infolength = len;
        (void) memcpy(infostring, str, len);
}

// Close file
AudioError AudioUnixfile::
Close()
{
        // If the file is open, close it
        if (isfdset()) {
                if (close(getfd()) < 0)
                        return (RaiseError(AUDIO_UNIXERROR));
        } else {
                return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));
        }

        // Init important values, in case the file is reopened
        setfd(-1);
        filehdrset = FALSE;
        (void) SetReadPosition((Double)0., Absolute);
        (void) SetWritePosition((Double)0., Absolute);
        return (AUDIO_SUCCESS);
}

// Read data from underlying file into specified buffer.
// No data format translation takes place.
// The object's read position is not updated (subclasses can change this)
AudioError AudioUnixfile::
ReadData(
        void*           buf,            // destination buffer address
        size_t&         len,            // buffer length (updated)
        Double&         pos)            // start position (updated)
{
        off_t           offset;
        off_t           cnt;
        AudioError      err;

        // Save buffer size and zero transfer count
        cnt = (off_t)len;
        len = 0;

        // Cannot read if file is not open
        if (!opened() || !mode.Readable())
                return (RaiseError(AUDIO_ERR_NOEFFECT));

        // Position must be valid
        if (Undefined(pos) || (pos < 0.) || (cnt < 0))
                return (RaiseError(AUDIO_ERR_BADARG));

        // Position the file pointer to the right place
        err = seekread(pos, offset);
        if (err != AUDIO_SUCCESS)
                return (err);

        // Check for EOF
        if (pos >= GetLength()) {
                err = AUDIO_EOF;
                err.sys = AUDIO_COPY_INPUT_EOF;
                return (err);
        }

        // Zero-length reads are finished
        if (GetHeader().Bytes_to_Bytes(cnt) == 0) {
                err = AUDIO_SUCCESS;
                err.sys = AUDIO_COPY_ZERO_LIMIT;
                return (err);
        }

        // Read as much data as possible
        cnt = read(fd, (char *)buf, (int)cnt);
        if (cnt < 0) {
                if (errno == EOVERFLOW) {
                        perror("read");
                        exit(1);
                } else if ((errno == EINTR) ||
                    (((errno == EWOULDBLOCK) || (errno == EAGAIN)) &&
                    !GetBlocking())) {
                // Is this an interrupted or failed non-blocking request?
                        err = AUDIO_SUCCESS;
                        err.sys = AUDIO_COPY_SHORT_INPUT;
                        return (err);
                }
                return (RaiseError(AUDIO_UNIXERROR));
        }

        // End-of-file?
        if ((cnt == 0) && GetBlocking()) {
                if (isDevice() || isPipe()) {
                        AUDIO_DEBUG((1,
                            "Zero-length blocking device/pipe read?!\n"));
                }
                err = AUDIO_EOF;
                err.sys = AUDIO_COPY_INPUT_EOF;
                return (err);
        }
        err = AUDIO_SUCCESS;
        if (cnt == 0) {
                err.sys = AUDIO_COPY_SHORT_INPUT;
        }

        // Return the updated byte count and position
        len = (size_t)cnt;
        if (GetHeader().Bytes_to_Bytes(cnt) != len) {
                AUDIO_DEBUG((1,
                    "Read returned a partial sample frame?!\n"));
        }
        pos = GetHeader().Bytes_to_Time(offset + len);

        // Check to see if the endian is right.
        coerceEndian((unsigned char *)buf, len, localByteOrder());

        return (err);
}

// Write data to underlying file from specified buffer.
// No data format translation takes place.
// The object's write position is not updated (subclasses can change this)
AudioError AudioUnixfile::
WriteData(
        void*           buf,            // source buffer address
        size_t&         len,            // buffer length (updated)
        Double&         pos)            // start position (updated)
{
        off_t           offset;
        off_t           cnt;
        AudioError      err;

        // Save buffer size and zero transfer count
        cnt = (off_t)len;
        len = 0;

        // Cannot write if file is not open
        if (!opened() || !mode.Writeable())
                return (RaiseError(AUDIO_ERR_NOEFFECT));

        // Position must be valid
        if (Undefined(pos) || (pos < 0.) || (cnt < 0))
                return (RaiseError(AUDIO_ERR_BADARG));

        // Zero-length writes are easy
        if (GetHeader().Bytes_to_Bytes(cnt) == 0) {
                err = AUDIO_SUCCESS;
                err.sys = AUDIO_COPY_ZERO_LIMIT;
                return (err);
        }

        // Position the file pointer to the right place
        err = seekwrite(pos, offset);
        if (err != AUDIO_SUCCESS)
                return (err);

        // Make sure data is in target's endian format before writing.
        // This conversion is done inplace so we need to change back.
        // We assume that the data in buf is in localByteOrder.
        // Only files should have order issues.
        if (localByteOrder() != GetHeader().endian)
                coerceEndian((unsigned char *)buf, (size_t)cnt, SWITCH_ENDIAN);

        // Write as much data as possible
        err = AUDIO_SUCCESS;
        cnt = write(fd, (char *)buf, (int)cnt);
        if (cnt < 0) {
                if (errno == EFBIG) {
                        perror("write");
                        exit(1);
                } else if ((errno == EWOULDBLOCK) || (errno == EAGAIN)) {
                        // Is this a failed non-blocking request?
                        err.sys = AUDIO_COPY_SHORT_OUTPUT;
                        return (err);
                }
                return (RaiseError(AUDIO_UNIXERROR));
        }
        if (cnt == 0)
                err.sys = AUDIO_COPY_SHORT_OUTPUT;

        // Switch the endian back if local order doesn't match target order.
        if (localByteOrder() != GetHeader().endian)
                coerceEndian((unsigned char *)buf, (size_t)cnt, SWITCH_ENDIAN);

        // Return the updated byte count and position
        len = (size_t)cnt;
        pos = GetHeader().Bytes_to_Time(offset + len);

        // If the current position is beyond old EOF, update the size
        if (!Undefined(GetLength()) && (pos > GetLength())) {
                setlength(pos);
        }

        return (AUDIO_SUCCESS);
}

// Seek in input stream
// Ordinary streams (ie, pipes and devices) cannot be rewound.
// A forward seek in them consumes data by reading it.
//
// This method should be specialized by subclasses that can actually seek,
// like regular files for instance.
//
AudioError AudioUnixfile::
seekread(
        Double          pos,            // position to seek to
        off_t&          offset)         // returned byte offset
{
        char            *bufp;          // temporary input buffer
        size_t          bufl;           // input buffer size
        size_t          cnt;            // input byte count
        long            icnt;           // read size
        Boolean         saveblock;      // saved state of the blocking i/o flag
        Double          buflen;
        AudioError      err;

        offset = GetHeader().Time_to_Bytes(pos);
        pos -= ReadPosition();

        // If the seek is backwards, do nothing
        if (pos < 0.)
                return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));

        // If the seek is to the current position, then do nothing.
        icnt = GetHeader().Time_to_Bytes(pos);
        if (icnt == 0)
                return (AUDIO_SUCCESS);

        // The seek is determinate and forward.
        // We'll have to consume data to get there.
        // First allocate a buffer to stuff the data into.
        // Then set the stream for blocking i/o (saving the old state).
        buflen = max(pos, 1.);
        bufl = (size_t)GetHeader().Time_to_Bytes(buflen);
        bufp = new char[bufl];
        if (bufp == 0) {                // allocation error, try a smaller buf
                bufl = (size_t)sysconf(_SC_PAGESIZE);
                bufp = new char[bufl];
                if (bufp == 0)
                        return (RaiseError(AUDIO_UNIXERROR));
        }
        // XXX - May have to realign to partial frame count!

        saveblock = GetBlocking();
        if (!saveblock)
                SetBlocking(TRUE);

        // Loop until the seek is satisfied (or an error occurs).
        do {
                // Limit the read to keep from going too far
                cnt = (icnt >= (long)bufl) ? bufl : (size_t)icnt;
                err = Read(bufp, cnt);
                if (err != AUDIO_SUCCESS)
                        break;
                icnt -= (long)cnt;
        } while (icnt > 0);

        SetBlocking(saveblock);         // Restore the saved blocking i/o state
        delete[] bufp;                  // Free the temporary buffer
        return (RaiseError(err));
}

// Seek in output stream
// Ordinary streams (ie, pipes and devices) cannot be rewound.
// A forward seek in them writes NULL data.
//
// This method should be specialized by subclasses that can actually seek,
// like regular files for instance.
//
AudioError AudioUnixfile::
seekwrite(
        Double          pos,            // position to seek to
        off_t&          offset)         // returned byte offset
{
        char            *bufp;          // temporary output buffer
        size_t          bufl;           // output buffer size
        size_t          cnt;            // output byte count
        long            ocnt;           // write size
        Boolean         saveblock;      // saved state of the blocking i/o flag
        Double          buflen;
        AudioError      err;

        offset = GetHeader().Time_to_Bytes(pos);
        pos -= WritePosition();

        // If the seek is backwards, do nothing
        if (pos < 0.)
                return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));

        // If the seek is to the current position, then do nothing.
        ocnt = GetHeader().Time_to_Bytes(pos);
        if (ocnt == 0)
                return (AUDIO_SUCCESS);

        // The seek is determinate and forward.
        // We'll have to produce NULL data to get there.
        // XXX - not implemented correctly yet
        buflen = max(pos, 1.);
        bufl = (size_t)GetHeader().Time_to_Bytes(buflen);
        bufp = new char[bufl];
        if (bufp == 0) {                // allocation error, try a smaller buf
                bufl = (size_t)sysconf(_SC_PAGESIZE);
                bufp = new char[bufl];
                if (bufp == 0)
                        return (RaiseError(AUDIO_UNIXERROR));
        }

        // XXX - May have to realign to partial frame count!
        saveblock = GetBlocking();
        if (!saveblock)
                SetBlocking(TRUE);

        // Loop until the seek is satisfied (or an error occurs).
        do {
                // Limit the write to keep from going too far
                cnt = (ocnt >= (long)bufl) ? bufl : (size_t)ocnt;
                err = Write(bufp, cnt);
                if (err != AUDIO_SUCCESS)
                        break;
                ocnt -= (long)cnt;
        } while (ocnt > 0);

        SetBlocking(saveblock);         // Restore the saved blocking i/o state
        delete[] bufp;                  // Free the temporary buffer
        return (RaiseError(err));
}