/*
 * 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 (c) 1993-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/param.h>

#include <convert.h>

#if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
#endif

const char      *opt_string = "pf:o:i:FTD?";

char            *Stdin;
char            *Stdout;
char            *Suffix = (char *)".AUDCVTMP";

char            *progname; // program name
char            *fake_argv[] = {(char *)"-", NULL}; // stdin with no args

extern char     *optarg;
extern int      optind;

int             Statistics = 0;
int             Debug = 0;

void            init_header(AudioHdr&);
void            usage();

int
main(int argc, char *argv[])
{
        AudioUnixfile*  ifp = NULL;     // input & output audio objects
        AudioUnixfile*  ofp = NULL;
        AudioHdr        ihdr;           // input/output headers
        AudioHdr        ohdr;
        char            *infile = NULL; // input/output file names
        char            *outfile = NULL;
        char            *realfile = NULL;
        char            *out_fmt = NULL;        // output fmt string
        AudioError      err;            // for error msgs
        int             c;              // for getopt
        int             pflag = 0;      // in place flag
        int             fflag = 0;      // ignore header (force conversion)
        int             stdin_seen = 0; // already read stdin
        int             israw = 0;      // once we've seen -i, it's raw data
        format_type     ofmt = F_SUN;   // output format type
        format_type     ifmt = F_SUN;   // expected input format type
        format_type     fmt = F_SUN;    // actual input format type
        off_t           o_offset = 0;   // output offset (ignored)
        off_t           i_offset = 0;   // input offset
        int             i;
        struct stat     st;

        setlocale(LC_ALL, "");
        (void) textdomain(TEXT_DOMAIN);

        // basename of program
        if (progname = strrchr(argv[0], '/')) {
                progname++;
        } else {
                progname = argv[0];
        }
        Stdin = MGET("(stdin)");
        Stdout = MGET("(stdout)");

        // init the input & output headers
        init_header(ihdr);
        init_header(ohdr);

        // some conversions depend on invocation name. we'll create
        // default input/output formats based on argv[0] that
        // can be overridden by -o or -i options.
        if (strcmp(progname, "ulaw2pcm") == 0) {
                (void) parse_format((char *)"ulaw", ihdr, ifmt, i_offset);
                (void) parse_format((char *)"pcm", ohdr, ofmt, o_offset);
        } else if (strcmp(progname, "pcm2ulaw") == 0) {
                (void) parse_format((char *)"pcm", ihdr, ifmt, i_offset);
                (void) parse_format((char *)"ulaw", ohdr, ofmt, o_offset);
        } else if (strcmp(progname, "adpcm_enc") == 0) {
                (void) parse_format((char *)"ulaw", ihdr, ifmt, i_offset);
                (void) parse_format((char *)"g721", ohdr, ofmt, o_offset);
        } else if (strcmp(progname, "adpcm_dec") == 0) {
                (void) parse_format((char *)"g721", ihdr, ifmt, i_offset);
                (void) parse_format((char *)"ulaw", ohdr, ofmt, o_offset);
        } else if (strcmp(progname, "raw2audio") == 0) {
                (void) parse_format((char *)"ulaw", ihdr, ifmt, i_offset);
                (void) parse_format((char *)"ulaw", ohdr, ofmt, o_offset);
                israw++;
                pflag++;
        } else if (argc <= 1) {
                // audioconvert with no arguments
                usage();
        }

        // now parse the rest of the arg's
        while ((c = getopt(argc, argv, opt_string)) != -1) {
                switch (c) {
#ifdef DEBUG
                case 'D':
                        // enable debug messages
                        Debug++;
                        break;
#endif
                case 'p':
                        // convert files in place
                        if (outfile != NULL) {
                                Err(MGET("can't use -p with -o\n"));
                                exit(1);
                        }
                        pflag++;
                        break;
                case 'F':
                        // force treatment of audio files as raw files
                        // (ignore filehdr).
                        fflag++;
                        break;
                case 'f':
                        // save format string to parse later, but verify now
                        out_fmt = optarg;
                        if (parse_format(out_fmt, ohdr, ofmt, o_offset) == -1)
                                exit(1);
                        if (o_offset != 0) {
                                Err(MGET("can't specify an offset with -f\n"));
                                exit(1);
                        }
                        break;
                case 'o':
                        if (pflag) {
                                Err(MGET("can't use -o with -p\n"));
                                exit(1);
                        }
                        outfile = optarg;
                        break;
                case 'i':
                        // if bogus input header, exit ...
                        if (parse_format(optarg, ihdr, ifmt, i_offset) == -1) {
                                exit(1);
                        }
                        israw++;
                        break;
                default:
                case '?':
                        usage();
                }
        }

        // XXX - should check argument consistency here....

        // If no args left, we're taking input from stdin.
        // In this case, make argv point to a fake argv with "-" as a file
        // name, and set optind and argc apropriately so we'll go through
        // the loop below once.
        if (optind >= argc) {
                argv = fake_argv;
                argc = 1;
                optind = 0;
                /*
                 * XXX - we turn off pflag if stdin is the only input file.
                 * this is kind of a hack. if invoked as raw2audio, pflag
                 * it turned on. if no files are given, we want to turn
                 * it off, otherwise we'll complain about using -p with
                 * stdin, which won't make sense if invoked as raw2audio.
                 * instead, just silently ignore. the message is still given
                 * and stdin is ignored if it's specified as one of several
                 * input files.
                 */
                pflag = 0;
        }

        // From this point on we're looking at file names or -i args
        // for input format specs.
        for (; optind < argc; optind++) {
                // new input format spec.
                if (strcmp(argv[optind], "-i") == 0) {
                        init_header(ihdr);
                        i_offset = 0;
                        ifmt = F_SUN;
                        // if bogus input header, exit ...
                        if (parse_format(argv[++optind], ihdr, ifmt, i_offset)
                            == -1) {
                                exit(1);
                        }
                        israw++;
                } else if (strcmp(argv[optind], "-") == 0) {
                        // ignore stdin argument if in place
                        if (pflag) {
                                Err(MGET("can't use %s with -p flag\n"),
                                    Stdin);
                                continue;
                        }

                        if (stdin_seen) {
                                Err(MGET("already used stdin for input\n"));
                                continue;
                        } else {
                                stdin_seen++;
                        }

                        infile = Stdin;
                } else {
                        infile = argv[optind];
                }

                // if no audio object returned, just continue to the next
                // file. if a fatal error occurs, open_input_file()
                // will exit the program.
                ifp =
                    open_input_file(infile, ihdr, israw, fflag, i_offset, fmt);
                if (!ifp) {
                        continue;
                }

                if ((err = ifp->Open()) != AUDIO_SUCCESS) {
                        Err(MGET("open error on input file %s - %s\n"),
                            infile, err.msg());
                        exit(1);
                }
                ifp->Reference();

                // create the output file if not created yet, or if
                // converting in place. ofp will be NULL only the first
                // time through. use the header of the first input file
                // to base the output format on - then create the output
                // header w/the output format spec.
                if ((ofp == NULL) && !pflag) {

                        ohdr = ifp->GetHeader();
                        ohdr = ifp->GetHeader();
                        ofmt = ifmt;
                        // just use input hdr if no output hdr spec
                        if (out_fmt) {
                                if (parse_format(out_fmt, ohdr, ofmt, o_offset)
                                    == -1) {
                                        exit(1);
                                }
                        }

                        // need to check before output is opened ...
                        if (verify_conversion(ifp->GetHeader(), ohdr) == -1) {
                                // XXX - bomb out or skip?
                                exit(3);
                        }

                        // Create the file and set the info string.
                        char            *infoString;
                        int             infoStringLen;
                        infoString = ifp->GetInfostring(infoStringLen);
                        ofp = create_output_file(outfile, ohdr, ofmt,
                                                    infoString);

                } else if (pflag) {

                        // create new output header based on each input file
                        ohdr = ifp->GetHeader();
                        ofmt = ifmt;
                        // just use input hdr if no output hdr spec
                        if (out_fmt) {
                                if (parse_format(out_fmt, ohdr, ofmt, o_offset)
                                    == -1) {
                                        exit(1);
                                }
                        }

                        // get the *real* path of the infile (follow sym-links),
                        // and the stat info.
                        realfile = infile;
                        get_realfile(realfile, &st);

                        // if the file is read-only, give up
                        if (access(realfile, W_OK)) {
                                // XXX - do we really want to exit?
                                perror(infile);
                                Err(MGET("cannot rewrite in place\n"));
                                exit(1);
                        }

                        // this is now the output file.
                        i = strlen(realfile) + strlen(Suffix) + 1;
                        outfile = (char *)malloc((unsigned)i);
                        if (outfile == NULL) {
                                Err(MGET("out of memory\n"));
                                exit(1);
                        }
                        (void) sprintf(outfile, "%s%s", realfile, Suffix);

                        // outfile will get re-assigned to a tmp file
                        if (verify_conversion(ifp->GetHeader(), ohdr) == -1) {
                                // XXX - bomb out or skip?
                                exit(3);
                        }

                        // If no conversion, just skip the file
                        if (noop_conversion(ifp->GetHeader(), ohdr,
                            fmt, ofmt, i_offset, o_offset)) {
                                if (Debug)
                                    Err(MGET(
                                        "%s: no-op conversion...skipping\n"),
                                        infile);
                                continue;
                        }

                        // Get the input info string.
                        char            *infoString;
                        int             infoStringLen;
                        infoString = ifp->GetInfostring(infoStringLen);
                        ofp = create_output_file(outfile, ohdr, ofmt,
                                                    infoString);
                }

                // verify that it's a valid conversion by looking at the
                // file headers. (this will be called twice for the first
                // file if *not* converting in place. that's ok....
                if (!pflag && (verify_conversion(ifp->GetHeader(), ohdr)
                    == -1)) {
                        // XXX - bomb out or skip file if invalid conversion?
                        exit(3);
                }

                // do the conversion, if error, bomb out
                if (do_convert(ifp, ofp) == -1) {
                        exit(4);
                }

                ifp->Close();
                ifp->Dereference();

                // if in place, finish up by renaming the outfile to
                // back to the infile.
                if (pflag) {
                        delete(ofp);    // will close and deref, etc.

                        if (rename(outfile, realfile) < 0) {
                                perror(outfile);
                                Err(MGET("error renaming %s to %s"),
                                    outfile, realfile);
                                exit(1);
                        }
                        /* Set the permissions to match the original */
                        if (chmod(realfile, (int)st.st_mode) < 0) {
                                Err(MGET("WARNING: could not reset mode of"));
                                perror(realfile);
                        }
                }
        }

        if (!pflag) {
                delete(ofp);            // close output file
        }

        return (0);
}


// initialize audio hdr to default val's
void
init_header(
        AudioHdr&       hdr)
{
        hdr.encoding = NONE;
        hdr.sample_rate = 0;
        hdr.samples_per_unit = 0;
        hdr.bytes_per_unit = 0;
        hdr.channels = 0;
}

extern "C" { void _doprnt(char *, ...); }

// report a fatal error and exit
void
Err(char *format, ...)
{
        va_list ap;

        va_start(ap, format);
        fprintf(stderr, "%s: ", progname);
        _doprnt(format, ap, stderr);
        fflush(stderr);
        va_end(ap);
}

void
usage()
{
        fprintf(stderr, MGET(
            "Convert between audio file formats and data encodings -- usage:\n"
            "\t%s [-pF] [-f outfmt] [-o outfile] [[-i infmt] [file ...]] ...\n"
            "where:\n"
            "\t-p\tConvert files in place\n"
            "\t-F\tForce interpretation of -i (ignore existing file hdr)\n"
            "\t-f\tOutput format description\n"
            "\t-o\tOutput file (default: stdout)\n"
            "\t-i\tInput format description\n"
            "\tfile\tList of files to convert (default: stdin)\n\n"
            "Format Description:\n"
            "\tkeyword=value[,keyword=value...]\n"
            "where:\n"
            "\tKeywords:\tValues:\n"
            "\trate\t\tSample Rate in samples/second\n"
            "\tchannels\tNumber of interleaved channels\n"
            "\tencoding\tAudio encoding. One of:\n"
            "\t\t\t    ulaw, alaw, g721, g723,\n"
            "\t\t\t    linear8, linear16, linear32\n"
            "\t\t\t    pcm   (same as linear16)\n"
            "\t\t\t    voice (ulaw,mono,rate=8k)\n"
            "\t\t\t    cd    (linear16,stereo,rate=44.1k)\n"
            "\t\t\t    dat   (linear16,stereo,rate=48k)\n"
            "\tformat\t\tFile format. One of:\n"
            "\t\t\t    sun, raw (no format)\n"
            "\toffset\t\tByte offset (raw input only)\n"),
            progname);
        exit(1);
}