/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mman.h>

#include <AudioFile.h>
#include <AudioLib.h>
#include <AudioDebug.h>
#include <libaudio.h>
#include <audio_hdr.h>

// class AudioFile methods


// Initialize temporary file params
#define TMPDIR          "/tmp"
#define TMPFILE         "/audiotoolXXXXXX"
static char             *tmpdir = NULL;
static const char       *tmpname = "(temporary file)";
static const FileAccess tmpmode = ReadWrite;
static const VMAccess   defaccess = SequentialAccess;

// Initialize default access mode, used when a filename is supplied
const FileAccess        AudioFile::defmode = ReadOnly;

// Default audio file path prefix environment variable
const char *AudioFile::AUDIO_PATH = "AUDIOPATH";


// Constructor with no arguments opens a read/write temporary file
AudioFile::
AudioFile():
        AudioUnixfile(tmpname, tmpmode),
        hdrsize(0), seekpos(0), origlen(0.), mapaddr(0), maplen(0),
        vmaccess(defaccess)
{
}

// Constructor with pathname and optional mode arg
AudioFile::
AudioFile(
        const char              *path,          // filename
        const FileAccess        acc):           // access mode
        AudioUnixfile(path, acc),
        hdrsize(0), seekpos(0), origlen(0.), mapaddr(0), maplen(0),
        vmaccess(defaccess)
{
}

// Destructor must call the local Close() routine
AudioFile::
~AudioFile()
{
        // If the file was open, close it
        if (opened())
                (void) Close();
}

// Set a default temporary file directory
AudioError AudioFile::
SetTempPath(
        const char      *path)
{
        struct stat     st;

        // Verify intended path
        if ((stat(path, &st) < 0) ||
            !S_ISDIR(st.st_mode) ||
            (access(path, W_OK) < 0)) {
                errno = ENOTDIR;
                return (AUDIO_UNIXERROR);
        }

        if (tmpdir != NULL)
                (void) free(tmpdir);
        tmpdir = (char *)malloc(strlen(path) + 1);
        (void) strcpy(tmpdir, path);
        return (AUDIO_SUCCESS);
}


// Create a named file according to the current mode setting
AudioError AudioFile::
createfile(
        const char      *path)                  // pathname or 0
{
        char            *tmpf;
        char            *tmpstr;
        int             openmode;
        int             desc;
        AudioError      err;

        // Convert the open mode to an int argument for open()
        openmode = GetAccess();

        // Was the header properly set?
        if (!hdrset())
                return (RaiseError(AUDIO_ERR_BADHDR));

        // Can't create if already opened or if mode or name not set
        if ((openmode == -1) || opened() || (strlen(path) == 0))
                return (RaiseError(AUDIO_ERR_NOEFFECT));

        // If temporary file, create and unlink it.
        if (strcmp(path, tmpname) == 0) {
                // Construct the temporary file path
                tmpstr = (char *)malloc(1 + strlen(TMPFILE) +
                    strlen((tmpdir == NULL) ? TMPDIR : tmpdir));
                (void) sprintf(tmpstr, "%s%s",
                    (tmpdir == NULL) ? TMPDIR : tmpdir, TMPFILE);
                tmpf = mktemp(tmpstr);

                // Open the temp file and unlink it
                err = createfile(tmpf);
                if ((err == AUDIO_SUCCESS) && (unlink(tmpf) < 0)) {
                        (void) Close();
                        err = RaiseError(AUDIO_UNIXERROR, Warning);
                }
                (void) free(tmpstr);
                return (err);
        }

        // Create the file
        desc = open(path, openmode | O_CREAT | O_TRUNC, 0666);
        if ((desc < 0) && (errno == EOVERFLOW)) {
                return (RaiseError(AUDIO_UNIXERROR, Fatal,
                    (char *)"Large File"));
        } else if (desc < 0) {
                return (RaiseError(AUDIO_UNIXERROR));
        }

        // Set the file descriptor (this marks the file open)
        setfd(desc);

        // Write the file header with current (usually unknown) size
        err = encode_filehdr();
        if (err != AUDIO_SUCCESS) {
                setfd(-1);
                (void) close(desc);             // If error, remove file
                (void) unlink(path);
                return (err);
        }

        // Save the length that got written, then set it to zero
        origlen = GetLength();
        setlength(0.);

        // Set the size of the file header
        hdrsize = lseek(desc, (off_t)0, SEEK_CUR);
        if (hdrsize < 0) {
                setfd(-1);
                (void) close(desc);             // If error, remove file
                (void) unlink(path);
                return (err);
        }
        seekpos = 0;

        return (AUDIO_SUCCESS);
}

// Create a file whose name is already set, according to the mode setting
AudioError AudioFile::
Create()
{
        return (createfile(GetName()));
}

// Open a file whose name is set
AudioError AudioFile::
Open()
{
        return (OpenPath(NULL));
}

// Open a file, using the specified path prefixes
AudioError AudioFile::
OpenPath(
        const char      *path)
{
        char            *filename;
        int             flen;
        char            *prefix;
        char            *str;
        char            *wrk;
        char            *pathname;
        int             openmode;
        AudioError      err;

        // Convert the open mode to an int argument for open()
        openmode = GetAccess();
        filename = GetName();
        flen = strlen(filename);

        // Can't open if already opened or if mode or name not set
        if ((openmode == -1) || opened() || (strlen(filename) == 0))
                return (RaiseError(AUDIO_ERR_NOEFFECT));

        // Search path:
        //      1) try name: if not found and not readonly:
        //              if Append mode, try creating it
        //      2) if name is a relative pathname, and 'path' is not NULL:
        //              try every path prefix in 'path'

        err = tryopen(filename, openmode);
        if (!err)
                return (AUDIO_SUCCESS);
        if (GetAccess().Writeable() || (filename[0] == '/')) {
                // If file is non-existent and Append mode, try creating it.
                if ((err == AUDIO_UNIXERROR) && (err.sys == ENOENT) &&
                    GetAccess().Append() && hdrset()) {
                        return (Create());
                }
                return (RaiseError(err));
        }

        // Try path as an environment variable name, else assume it is a path
        str = (path == NULL) ? NULL : getenv(path);
        if (str == NULL)
                str = (char *)path;

        if (str != NULL) {
                // Make a copy of the path, to parse it
                wrk = new char[strlen(str) + 1];
                (void) strcpy(wrk, str);
                str = wrk;

                // Try each component as a path prefix
                for (prefix = str;
                    (prefix != NULL) && (prefix[0] != '\0');
                    prefix = str) {
                        str = strchr(str, ':');
                        if (str != NULL)
                                *str++ = '\0';
                        pathname = new char[strlen(prefix) + flen + 2];
                        (void) sprintf(pathname, "%s/%s", prefix, filename);
                        err = tryopen(pathname, openmode);
                        delete[] pathname;
                        switch (err) {
                        case AUDIO_SUCCESS:     // found the file
                                delete[] wrk;
                                return (RaiseError(err));
                        // XXX - if file found but not audio, stop looking??
                        }
                }
                delete[] wrk;
        }
        // Can't find file.  Return the original error condition.
        return (RaiseError(tryopen(filename, openmode)));
}

// Attempt to open the given audio file
AudioError AudioFile::
tryopen(
        const char      *pathname,
        int             openmode)
{
        struct stat     st;
        int             desc;
        AudioError      err;

        // If the name is changing, set the new one
        if (pathname != GetName())
                SetName(pathname);

        // Does the file exist?
        if (stat(pathname, &st) < 0)
                return (AUDIO_UNIXERROR);

        // If not a regular file, stop right there
        if (!S_ISREG(st.st_mode))
                return (AUDIO_ERR_BADFILEHDR);

        // Open the file and check that it's an audio file
        desc = open(GetName(), openmode);
        if ((desc < 0) && (errno == EOVERFLOW)) {
                return (RaiseError(AUDIO_UNIXERROR, Fatal,
                    (char *)"Large File"));
        } else if (desc < 0) {
                return (AUDIO_UNIXERROR);
        }

        // Set the file descriptor (this marks the file open)
        setfd(desc);

        err = decode_filehdr();
        if (err != AUDIO_SUCCESS) {
                (void) close(desc);
                setfd(-1);
                return (err);
        }

        // Save the length of the data and the size of the file header
        origlen = GetLength();
        hdrsize = (off_t)lseek(desc, (off_t)0, SEEK_CUR);
        if (hdrsize < 0) {
                (void) close(desc);
                setfd(-1);
                return (err);
        }
        seekpos = 0;

        // If this is ReadOnly file, mmap() it.  Don't worry if mmap() fails.
        if (!GetAccess().Writeable()) {
                maplen = st.st_size;

                /*
                 * Can't mmap LITTLE_ENDIAN as they are converted in
                 * place.
                 */
                if (localByteOrder() == BIG_ENDIAN) {
                        if ((mapaddr = (caddr_t)mmap(0, (int)maplen, PROT_READ,
                                MAP_SHARED, desc, 0)) != (caddr_t)-1) {
                                // set default access method
                                (void) madvise(mapaddr, (unsigned int)maplen,
                                    (int)GetAccessType());
                        } else {
                                (void) RaiseError(AUDIO_UNIXERROR, Warning,
                                    (char *)"Could not mmap() file");
                                mapaddr = 0;
                                maplen = 0;
                        }
                } else {
                        mapaddr = 0;
                        maplen = 0;
                }
        }
        return (AUDIO_SUCCESS);
}

// set VM access hint for mmapped files
AudioError AudioFile::
SetAccessType(VMAccess vmacc)
{
        if (!opened()) {
                return (AUDIO_ERR_NOEFFECT);
        }

        if (mapaddr == 0) {
                return (AUDIO_ERR_NOEFFECT);
        }

        (void) madvise(mapaddr, (unsigned int)maplen, (int)vmacc);
        vmaccess = vmacc;

        return (AUDIO_SUCCESS);
}

// Close the file
AudioError AudioFile::
Close()
{
        AudioError      err;

        if (!opened())
                return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));

        // Rewind the file and rewrite the header with the correct length
        if (GetAccess().Writeable() && (origlen != GetLength())) {

                // sanity check
                if (GetHeader().Time_to_Bytes(GetLength()) !=
                    (lseek(getfd(), (off_t)0, SEEK_END) - hdrsize)) {
                        PrintMsg(_MGET_(
                            "AudioFile:Close()...inconsistent length\n"),
                            Fatal);
                }

                // XXX - should be rewritten in C++
                err = (AudioError) audio_rewrite_filesize(getfd(), FILE_AU,
                    (uint_t)GetHeader().Time_to_Bytes(GetLength()), 0, 0);
        }

        // Call the generic file close routine
        err = AudioUnixfile::Close();

        if (mapaddr) {
                munmap(mapaddr, (int)maplen);
                mapaddr = 0;
                maplen = 0;
        }

        // Init important values, in case the file is reopened
        hdrsize = 0;
        seekpos = 0;
        return (RaiseError(err));
}

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

        // If the file is not mapped, call parent ReadData() and return
        if (mapaddr == 0) {
                // Call the real routine
                err = AudioUnixfile::ReadData(buf, len, pos);
                // Update the cached seek pointer
                seekpos += len;
                return (err);
        }

        // If the file is mmapped, do a memcpy() from the mapaddr

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

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

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

        // Make sure we don't read off the end of file
        offset = GetHeader().Time_to_Bytes(pos);

        if ((offset + hdrsize) >= maplen) {
                // trying to read past EOF
                err = AUDIO_EOF;
                err.sys = AUDIO_COPY_INPUT_EOF;
                return (err);
        } else if ((offset + hdrsize + cnt) > maplen) {
                // re-adjust cnt so it reads up to the end of file
                cnt = (size_t)(maplen - (offset + hdrsize));
        }

        // Zero-length reads are finished
        if (GetHeader().Bytes_to_Bytes(cnt) == 0) {
                err = AUDIO_SUCCESS;
                err.sys = AUDIO_COPY_ZERO_LIMIT;
                return (err);
        } else {
                cp = mapaddr + offset + hdrsize;
                memcpy((void*)buf, (void*)cp, cnt);
        }

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

        // Check to see if the endian is right. Note that special care
        // doesn't need to be taken because of the mmap, since the data
        // is copied into a separate buffer anyway.
        coerceEndian((unsigned char *)buf, len, localByteOrder());

        return (AUDIO_SUCCESS);
}

// Write data to underlying file from specified buffer.
// No data format translation takes place.
// The object's write position pointer is unaffected.
AudioError AudioFile::
WriteData(
        void*           buf, // source buffer address
        size_t&         len, // buffer length (updated)
        Double&         pos) // start position (updated)
{
        AudioError      err;

        // Call the real routine
        err = AudioUnixfile::WriteData(buf, len, pos);

        // Update the cached seek pointer
        seekpos += len;
        return (err);
}

// Set the Unix file pointer to match a given file position.
AudioError AudioFile::
seekread(
        Double          pos,    // position to seek to
        off_t&          offset) // returned byte offset
{
        offset = GetHeader().Time_to_Bytes(pos);
        if (offset != seekpos) {
                if (lseek(getfd(), (off_t)(hdrsize + offset), SEEK_SET) < 0)
                        return (RaiseError(AUDIO_UNIXERROR, Warning));
                seekpos = offset;
        }
        return (AUDIO_SUCCESS);
}

// Set the Unix file pointer to match a given file position.
// If seek beyond end-of-file, NULL out intervening data.
AudioError AudioFile::
seekwrite(
        Double          pos,    // position to seek to
        off_t&          offset) // returned byte offset
{
        // If append-only, can't seek backwards into file
        if (GetAccess().Append() && (pos < GetLength()))
                return (RaiseError(AUDIO_ERR_NOEFFECT, Warning));

        // If seek beyond eof, fill data
        if (pos > GetLength()) {
                seekwrite(GetLength(), offset); // seek to eof

                // XXX - not implemented yet

                return (AUDIO_SUCCESS);
        }

        offset = GetHeader().Time_to_Bytes(pos);
        if (offset != seekpos) {
                if (lseek(getfd(), (off_t)(hdrsize + offset), SEEK_SET) < 0)
                        return (RaiseError(AUDIO_UNIXERROR, Warning));
                seekpos = offset;
        }
        return (AUDIO_SUCCESS);
}

// Copy routine that handles mapped files
AudioError AudioFile::
AsyncCopy(
        Audio*          to,                     // audio object to copy to
        Double&         frompos,
        Double&         topos,
        Double&         limit)
{
        caddr_t         bptr;
        size_t          offset;
        size_t          cnt;
        size_t          svlim;
        Double          svfrom;
        Double          svto;
        AudioHdr        tohdr;
        AudioError      err;

        // If this is NOT mmapped, or the destination is an AudioBuffer,
        // use the default routine
        if ((mapaddr == 0) || to->isBuffer()) {
                return (Audio::AsyncCopy(to, frompos, topos, limit));
        }

        tohdr = to->GetHeader();
        err = tohdr.Validate();
        if (err != AUDIO_SUCCESS)
                return (err);
        if (limit < 0.)
                return (RaiseError(AUDIO_ERR_BADARG));
        svlim = (size_t)tohdr.Time_to_Bytes(limit);

        // Get maximum possible copy length
        svfrom = GetLength();
        if ((frompos >= svfrom) || ((cnt = (size_t)
            GetHeader().Time_to_Bytes(svfrom - frompos)) == 0)) {
                limit = 0.;
                err = AUDIO_EOF;
                err.sys = AUDIO_COPY_INPUT_EOF;
                return (err);
        }
        if (!Undefined(limit) && (svlim < cnt))
                cnt = svlim;

        limit = 0.;

        offset = (size_t)GetHeader().Time_to_Bytes(frompos);
        if ((offset + hdrsize) >= maplen) {
                // trying to read past EOF
                err = AUDIO_EOF;
                err.sys = AUDIO_COPY_INPUT_EOF;
                return (err);
        } else if ((offset + hdrsize + cnt) > maplen) {
                // re-adjust cnt so it reads up to the end of file
                cnt = (size_t)(maplen - (offset + hdrsize));
        }

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

        // Write the data to the destination and update pointers/ctrs
        svfrom = frompos;
        svto = topos;
        svlim = cnt;
        bptr = mapaddr + hdrsize + offset;
        err = to->WriteData(bptr, cnt, topos);
        limit = topos - svto;
        frompos = svfrom + limit;

        // Report short writes
        if (!err && (cnt < svlim))
                err.sys = AUDIO_COPY_SHORT_OUTPUT;
        return (err);
}