source: trunk/third/audiofile/libaudiofile/setup.c @ 17099

/*
        Audio File Library
        Copyright (C) 2000, Silicon Graphics, Inc.

        This library is free software; you can redistribute it and/or
        modify it under the terms of the GNU Library General Public
        License as published by the Free Software Foundation; either
        version 2 of the License, or (at your option) any later version.

        This library is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        Library General Public License for more details.

        You should have received a copy of the GNU Library General Public
        License along with this library; if not, write to the
        Free Software Foundation, Inc., 59 Temple Place - Suite 330,
        Boston, MA  02111-1307  USA.
*/

/*
        setup.c
*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdlib.h>
#include <string.h>

#include <audiofile.h>

#include "afinternal.h"
#include "pcm.h"
#include "util.h"
#include "units.h"
#include "marker.h"

extern _Unit _af_units[];

_AFfilesetup _af_default_file_setup =
{
        _AF_VALID_FILESETUP,    /* valid */
#if WORDS_BIGENDIAN
        AF_FILE_AIFFC,  /* file format */
#else
        AF_FILE_WAVE,   /* file format */
#endif
        AF_FALSE,       /* trackSet */
        AF_FALSE,       /* instrumentSet */
        AF_FALSE,       /* miscellaneousSet */
        1,              /* trackCount */
        NULL,           /* tracks */
        1,              /* instrumentCount */
        NULL,           /* instruments */
        0,              /* miscellaneousCount */
        NULL            /* miscellaneous */
};

_InstrumentSetup _af_default_instrumentsetup =
{
        0,              /* id */
        2,              /* loopCount */
        NULL,           /* loops */
        AF_FALSE        /* loopSet */
};

_TrackSetup _af_default_tracksetup =
{
        0,
        {
                44100.0,
                AF_SAMPFMT_TWOSCOMP,
                16,
#if WORDS_BIGENDIAN
                AF_BYTEORDER_BIGENDIAN,
#else
                AF_BYTEORDER_LITTLEENDIAN,
#endif
                { SLOPE_INT16, 0, MIN_INT16, MAX_INT16 },
                2,
                AF_COMPRESSION_NONE,
                NULL
        },
        AF_FALSE,       /* rateSet */
        AF_FALSE,       /* sampleFormatSet */
        AF_FALSE,       /* sampleWidthSet */
        AF_FALSE,       /* byteOrderSet */
        AF_FALSE,       /* channelCountSet */
        AF_FALSE,       /* compressionSet */
        AF_FALSE,       /* aesDataSet */
        AF_FALSE,       /* markersSet */
        AF_FALSE,       /* dataOffsetSet */
        AF_FALSE,       /* frameCountSet */

        4,              /* markerCount */
        NULL,           /* markers */
        0,              /* dataOffset */
        0               /* frameCount */
};

_TrackSetup *_af_tracksetup_new (int trackCount)
{
        int             i;
        _TrackSetup     *tracks;

        if (trackCount == 0)
                return NULL;

        tracks = _af_calloc(trackCount, sizeof (_TrackSetup));
        if (tracks == NULL)
                return NULL;

        for (i=0; i<trackCount; i++)
        {
                tracks[i] = _af_default_tracksetup;

                tracks[i].id = AF_DEFAULT_TRACK + i;

                /* XXXmpruett deal with compression */

                _af_set_sample_format(&tracks[i].f, tracks[i].f.sampleFormat,
                        tracks[i].f.sampleWidth);

                if (tracks[i].markerCount == 0)
                        tracks[i].markers = NULL;
                else
                {
                        int     j;
                        tracks[i].markers = _af_calloc(tracks[i].markerCount,
                                sizeof (_MarkerSetup));

                        if (tracks[i].markers == NULL)
                                return NULL;

                        for (j=0; j<tracks[i].markerCount; j++)
                        {
                                tracks[i].markers[j].id = j+1;

                                tracks[i].markers[j].name = _af_strdup("");
                                if (tracks[i].markers[j].name == NULL)
                                        return NULL;

                                tracks[i].markers[j].comment = _af_strdup("");
                                if (tracks[i].markers[j].comment == NULL)
                                        return NULL;
                        }
                }
        }

        return tracks;
}

_InstrumentSetup *_af_instsetup_new (int instrumentCount)
{
        int     i;

        _InstrumentSetup        *instruments;

        if (instrumentCount == 0)
                return NULL;
        instruments = _af_calloc(instrumentCount, sizeof (_InstrumentSetup));
        if (instruments == NULL)
                return NULL;

        for (i=0; i<instrumentCount; i++)
        {
                instruments[i] = _af_default_instrumentsetup;
                instruments[i].id = AF_DEFAULT_INST + i;
                if (instruments[i].loopCount == 0)
                        instruments[i].loops = NULL;
                else
                {
                        int     j;
                        instruments[i].loops = _af_calloc(instruments[i].loopCount, sizeof (_LoopSetup));
                        if (instruments[i].loops == NULL)
                                return NULL;

                        for (j=0; j<instruments[i].loopCount; j++)
                                instruments[i].loops[j].id = j+1;
                }
        }

        return instruments;
}

AFfilesetup afNewFileSetup (void)
{
        AFfilesetup     setup;

        setup = _af_malloc(sizeof (_AFfilesetup));
        if (setup == NULL) return AF_NULL_FILESETUP;

        *setup = _af_default_file_setup;

        setup->tracks = _af_tracksetup_new(setup->trackCount);

        setup->instruments = _af_instsetup_new(setup->instrumentCount);

        if (setup->miscellaneousCount == 0)
                setup->miscellaneous = NULL;
        else
        {
                int     i;

                setup->miscellaneous = _af_calloc(setup->miscellaneousCount,
                        sizeof (_MiscellaneousSetup));
                for (i=0; i<setup->miscellaneousCount; i++)
                {
                        setup->miscellaneous[i].id = i+1;
                        setup->miscellaneous[i].type = 0;
                        setup->miscellaneous[i].size = 0;
                }
        }

        return setup;
}

/*
        Free the specified track's markers and their subfields.
*/
void _af_setup_free_markers (AFfilesetup setup, int trackno)
{
        if (setup->tracks[trackno].markerCount != 0)
        {
                int     i;
                for (i=0; i<setup->tracks[trackno].markerCount; i++)
                {
                        free(setup->tracks[trackno].markers[i].name);
                        free(setup->tracks[trackno].markers[i].comment);
                }

                free(setup->tracks[trackno].markers);
        }

        setup->tracks[trackno].markers = NULL;
        setup->tracks[trackno].markerCount = 0;
}

/*
        Free the specified setup's tracks and their subfields.
*/
void _af_setup_free_tracks (AFfilesetup setup)
{
        int     i;

        if (setup->tracks)
        {
                for (i=0; i<setup->trackCount; i++)
                {
                        _af_setup_free_markers(setup, i);
                }

                free(setup->tracks);
        }

        setup->tracks = NULL;
        setup->trackCount = 0;
}

/*
        Free the specified instrument's loops.
*/
void _af_setup_free_loops (AFfilesetup setup, int instno)
{
        if (setup->instruments[instno].loops)
        {
                free(setup->instruments[instno].loops);
        }

        setup->instruments[instno].loops = NULL;
        setup->instruments[instno].loopCount = 0;
}

/*
        Free the specified setup's instruments and their subfields.
*/
void _af_setup_free_instruments (AFfilesetup setup)
{
        int i;

        if (setup->instruments)
        {
                for (i = 0; i < setup->instrumentCount; i++)
                        _af_setup_free_loops(setup, i);

                free(setup->instruments);
        }

        setup->instruments = NULL;
        setup->instrumentCount = 0;
}

void afFreeFileSetup (AFfilesetup setup)
{
        if (!_af_filesetup_ok(setup))
                return;

        _af_setup_free_tracks(setup);

        _af_setup_free_instruments(setup);

        if (setup->miscellaneousCount)
        {
                free(setup->miscellaneous);
                setup->miscellaneous = NULL;
                setup->miscellaneousCount = 0;
        }

        memset(setup, 0, sizeof (_AFfilesetup));
        free(setup);
}

void afInitFileFormat (AFfilesetup setup, int filefmt)
{
        if (!_af_filesetup_ok(setup))
                return;

        if (filefmt < 0 || filefmt > _AF_NUM_UNITS)
        {
                _af_error(AF_BAD_FILEFMT, "unrecognized file format %d",
                        filefmt);
                return;
        }

        if (_af_units[filefmt].implemented == AF_FALSE)
        {
                _af_error(AF_BAD_NOT_IMPLEMENTED,
                        "%s format not currently supported",
                        _af_units[filefmt].name);
                return;
        }

        setup->fileFormat = filefmt;
}

void afInitChannels (AFfilesetup setup, int trackid, int channels)
{
        _TrackSetup     *track;

        if (!_af_filesetup_ok(setup))
                return;

        if ((track = _af_filesetup_get_tracksetup(setup, trackid)) == NULL)
                return;

        if (channels < 1)
        {
                _af_error(AF_BAD_CHANNELS, "invalid number of channels %d",
                        channels);
                return;
        }

        track->f.channelCount = channels;
        track->channelCountSet = AF_TRUE;
}

void afInitSampleFormat (AFfilesetup setup, int trackid, int sampfmt, int sampwidth)
{
        _TrackSetup     *track;

        if (!_af_filesetup_ok(setup))
                return;

        if ((track = _af_filesetup_get_tracksetup(setup, trackid)) == NULL)
                return;

        _af_set_sample_format(&track->f, sampfmt, sampwidth);

        track->sampleFormatSet = AF_TRUE;
        track->sampleWidthSet = AF_TRUE;
}

void afInitByteOrder (AFfilesetup setup, int trackid, int byteorder)
{
        _TrackSetup     *track;

        if (!_af_filesetup_ok(setup))
                return;

        if ((track = _af_filesetup_get_tracksetup(setup, trackid)) == NULL)
                return;

        if (byteorder != AF_BYTEORDER_BIGENDIAN &&
                byteorder != AF_BYTEORDER_LITTLEENDIAN)
        {
                _af_error(AF_BAD_BYTEORDER, "invalid byte order %d", byteorder);
                return;
        }

        track->f.byteOrder = byteorder;
        track->byteOrderSet = AF_TRUE;
}

void afInitRate (AFfilesetup setup, int trackid, double rate)
{
        _TrackSetup     *track;

        if (!_af_filesetup_ok(setup))
                return;

        if ((track = _af_filesetup_get_tracksetup(setup, trackid)) == NULL)
                return;

        if (rate <= 0.0)
        {
                _af_error(AF_BAD_RATE, "invalid sample rate %.30g", rate);
                return;
        }

        track->f.sampleRate = rate;
        track->rateSet = AF_TRUE;
}

/*
        track data: data offset within the file (initialized for raw reading only)
*/
void afInitDataOffset (AFfilesetup setup, int trackid, AFfileoffset offset)
{
        _TrackSetup     *track;

        if (!_af_filesetup_ok(setup))
                return;

        if ((track = _af_filesetup_get_tracksetup(setup, trackid)) == NULL)
                return;

        if (offset < 0)
        {
                _af_error(AF_BAD_DATAOFFSET, "invalid data offset %d", offset);
                return;
        }

        track->dataOffset = offset;
        track->dataOffsetSet = AF_TRUE;
}

/*
        track data: data offset within the file (initialized for raw reading only)
*/
void afInitFrameCount (AFfilesetup setup, int trackid, AFfileoffset count)
{
        _TrackSetup     *track;

        if (!_af_filesetup_ok(setup))
                return;

        if ((track = _af_filesetup_get_tracksetup(setup, trackid)) == NULL)
                return;

        if (count < 0)
        {
                _af_error(AF_BAD_FRAMECNT, "invalid frame count %d", count);
                return;
        }

        track->frameCount = count;
        track->frameCountSet = AF_TRUE;
}

#define alloccopy(type, n, var, copyfrom) \
{ \
        if (n == 0) \
                var = NULL; \
        else \
        { \
                if ((var = _af_calloc(n, sizeof (type))) == NULL) \
                        goto fail; \
                memcpy((var), (copyfrom), (n) * sizeof (type)); \
        } \
}

AFfilesetup _af_filesetup_copy (AFfilesetup setup, AFfilesetup defaultSetup,
        bool copyMarks)
{
        AFfilesetup     newsetup;
        int             i;
        int             instrumentCount, miscellaneousCount, trackCount;

        newsetup = _af_malloc(sizeof (_AFfilesetup));
        if (newsetup == AF_NULL_FILESETUP)
                return AF_NULL_FILESETUP;

#ifdef DEBUG
        printf("default: trackset=%d instset=%d miscset=%d\n",
                defaultSetup->trackSet, defaultSetup->instrumentSet,
                defaultSetup->miscellaneousSet);
        printf("setup: trackset=%d instset=%d miscset=%d\n",
                setup->trackSet, setup->instrumentSet, setup->miscellaneousSet);
#endif

        *newsetup = *defaultSetup;

        newsetup->tracks = NULL;
        newsetup->instruments = NULL;
        newsetup->miscellaneous = NULL;

        /* Copy tracks. */
        trackCount = setup->trackSet ? setup->trackCount :
                newsetup->trackSet ? newsetup->trackCount : 0;
        alloccopy(_TrackSetup, trackCount, newsetup->tracks, setup->tracks);
        newsetup->trackCount = trackCount;

        /* Copy instruments. */
        instrumentCount = setup->instrumentSet ? setup->instrumentCount :
                newsetup->instrumentSet ? newsetup->instrumentCount : 0;
        alloccopy(_InstrumentSetup, instrumentCount, newsetup->instruments, setup->instruments);
        newsetup->instrumentCount = instrumentCount;

        /* Copy miscellaneous information. */
        miscellaneousCount = setup->miscellaneousSet ? setup->miscellaneousCount :
                newsetup->miscellaneousSet ? newsetup->miscellaneousCount : 0;
        alloccopy(_MiscellaneousSetup, miscellaneousCount, newsetup->miscellaneous, setup->miscellaneous);
        newsetup->miscellaneousCount = miscellaneousCount;

        for (i=0; i<setup->trackCount; i++)
        {
                int     j;
                _TrackSetup     *track = &newsetup->tracks[i];

                /* XXXmpruett set compression information */

                if (setup->tracks[i].markersSet == AF_FALSE &&
                        copyMarks == AF_FALSE)
                {
                        track->markers = NULL;
                        track->markerCount = 0;
                        continue;
                }

                alloccopy(_MarkerSetup, setup->tracks[i].markerCount,
                        track->markers, setup->tracks[i].markers);
                track->markerCount = setup->tracks[i].markerCount;

                for (j=0; j<setup->tracks[i].markerCount; j++)
                {
                        track->markers[j].name =
                                _af_strdup(setup->tracks[i].markers[j].name);
                        if (track->markers[j].name == NULL)
                                goto fail;

                        track->markers[j].comment =
                                _af_strdup(setup->tracks[i].markers[j].comment);
                        if (track->markers[j].comment == NULL)
                                goto fail;
                }
        }

        for (i=0; i<newsetup->instrumentCount; i++)
        {
                _InstrumentSetup        *instrument = &newsetup->instruments[i];
                alloccopy(_LoopSetup, setup->instruments[i].loopCount,
                        instrument->loops, setup->instruments[i].loops);
        }

        return newsetup;

        fail:
                if (newsetup->miscellaneous)
                        free(newsetup->miscellaneous);
                if (newsetup->instruments)
                        free(newsetup->instruments);
                if (newsetup->tracks)
                        free(newsetup->tracks);
                if (newsetup)
                        free(newsetup);

        return AF_NULL_FILESETUP;
}

/*
        Do all the non-file-format dependent things necessary to "convert"
        a filesetup into a filehandle.

        This function assumes that the track count, instrument count,
        etc. of given filesetup is okay for the file format.

        Called from write.init and raw read.init unit functions.

        This function does NOT SET ALL THE FIELDS of the filesetup.
        You must be careful when writing a unit to set the fields
        you are supposed to (described below).

        These fields are not set here, so are somebody else's problem:
        - handle: valid, fd, access, filename, fileFormat, seekok (set in afOpenFile)
        - handle: formatSpecific (UNIT MUST SET! (set to NULL if no data))

        - track: virtual format v, modulesdirty, nmodules, module, chunk,
        (buffers), totalvframes, nextvframe, channelmatrix, frames2ignore
        (these are handled by _AFinitmodules and _AFsetupmodules)

        - track: totalfframes, nextfframe, fpos_first_frame,
        fpos_next_frame, data_size (UNIT MUST SET!)

        - mark: fpos_position (UNIT MUST SET!)
*/

status _af_filesetup_make_handle (AFfilesetup setup, AFfilehandle handle)
{
        int     i;

        handle->valid = _AF_VALID_FILEHANDLE;

        if ((handle->trackCount = setup->trackCount) == 0)
                handle->tracks = NULL;
        else
        {
                handle->tracks = _af_calloc(handle->trackCount, sizeof (_Track));
                if (handle->tracks == NULL)
                        return AF_FAIL;

                for (i=0; i<handle->trackCount; i++)
                {
                        _Track          *track = &handle->tracks[i];
                        _TrackSetup     *tracksetup = &setup->tracks[i];

                        track->id = tracksetup->id;

                        track->f = tracksetup->f;
                        track->channelMatrix = NULL;

                        /* XXXmpruett copy compression stuff too */

                        if ((track->markerCount = tracksetup->markerCount) == 0)
                                track->markers = NULL;
                        else
                        {
                                int     j;

                                track->markers = _af_marker_new(track->markerCount);
                                if (track->markers == NULL)
                                        return AF_FAIL;
                                for (j=0; j<track->markerCount; j++)
                                {
                                        track->markers[j].id = tracksetup->markers[j].id;
                                        track->markers[j].name =
                                                _af_strdup(tracksetup->markers[j].name);
                                        if (track->markers[j].name == NULL)
                                                return AF_FAIL;

                                        track->markers[j].comment =
                                                _af_strdup(tracksetup->markers[j].comment);
                                        if (track->markers[j].comment == NULL)
                                                return AF_FAIL;
                                        track->markers[j].position = 0;
                                }
                        }

                        track->hasAESData = tracksetup->aesDataSet;

                        track->ms.modulesdirty = AF_TRUE;
                        track->ms.nmodules = 0;
                        track->ms.chunk = NULL;
                        track->ms.module = NULL;
                        track->ms.buffer = NULL;

                        track->ms.filemodinst.valid = AF_FALSE;
                        track->ms.filemod_rebufferinst.valid = AF_FALSE;
                        track->ms.rateconvertinst.valid = AF_FALSE;
                        track->ms.rateconvert_rebufferinst.valid = AF_FALSE;
                }
        }

        /* Copy instrument data. */
        if ((handle->instrumentCount = setup->instrumentCount) == 0)
                handle->instruments = NULL;
        else
        {
                handle->instruments = _af_calloc(handle->instrumentCount,
                        sizeof (_Instrument));
                if (handle->instruments == NULL)
                        return AF_FAIL;

                for (i=0; i<handle->instrumentCount; i++)
                {
                        int     instParamCount;

                        handle->instruments[i].id = setup->instruments[i].id;

                        /* Copy loops. */
                        if ((handle->instruments[i].loopCount =
                                setup->instruments[i].loopCount) == 0)
                                handle->instruments[i].loops = NULL;
                        else
                        {
                                int     j;

                                handle->instruments[i].loops = _af_calloc(handle->instruments[i].loopCount, sizeof (_Loop));
                                if (handle->instruments[i].loops == NULL)
                                        return AF_FAIL;
                                for (j=0; j<handle->instruments[i].loopCount; j++)
                                {
                                        _Loop   *loop;
                                        loop = &handle->instruments[i].loops[j];
                                        loop->id = setup->instruments[i].loops[j].id;
                                        loop->mode = AF_LOOP_MODE_NOLOOP;
                                        loop->count = 0;
                                        loop->trackid = AF_DEFAULT_TRACK;
                                        loop->beginMarker = 1 + (2*j);
                                        loop->endMarker = 2 + (2*j);
                                }
                        }

                        /* Copy instrument parameters. */
                        if ((instParamCount = _af_units[setup->fileFormat].instrumentParameterCount) == 0)
                                handle->instruments[i].values = NULL;
                        else
                        {
                                int     j;
                                handle->instruments[i].values = _af_calloc(instParamCount, sizeof (AFPVu));
                                if (handle->instruments[i].values == NULL)
                                        return AF_FAIL;
                                for (j=0; j<instParamCount; j++)
                                {
                                        handle->instruments[i].values[j] =
                                                _af_units[setup->fileFormat].instrumentParameters[j].defaultValue;
                                }
                        }
                }
        }

        /* Copy miscellaneous information. */

        if ((handle->miscellaneousCount = setup->miscellaneousCount) == 0)
                handle->miscellaneous = NULL;
        else
        {
                handle->miscellaneous = _af_calloc(handle->miscellaneousCount,
                        sizeof (_Miscellaneous));
                if (handle->miscellaneous == NULL)
                        return AF_FAIL;
                for (i=0; i<handle->miscellaneousCount; i++)
                {
                        handle->miscellaneous[i].id = setup->miscellaneous[i].id;
                        handle->miscellaneous[i].type = setup->miscellaneous[i].type;
                        handle->miscellaneous[i].size = setup->miscellaneous[i].size;
                        handle->miscellaneous[i].position = 0;
                        handle->miscellaneous[i].buffer = NULL;
                }
        }

        return AF_SUCCEED;
}