/* multiread.c -- read multichannel sound file */

/* CHANGE LOG
 * --------------------------------------------------------------------
 * 28Apr03  dm  changes for portability and fix compiler warnings
 */

#include "stdio.h"
#ifdef UNIX
#include "sys/file.h"
#endif
#ifndef mips
#include "stdlib.h"
#endif
#include "snd.h"
#include "xlisp.h"
#include "sound.h"
#include "falloc.h"
#include "sndread.h"
#include "multiread.h"

/* allocate input buffer space for this many bytes/frame,
 * e.g. 8 allows 2 channels
 * If frames are bigger, then multiple reads will be issued.
 */
#define max_bytes_per_frame 8
#define input_buffer_max (max_sample_block_len * max_bytes_per_frame)

/* multiread_fetch - read samples into multiple channels.  */
/*
 * The susp is shared by all channels.  The susp has backpointers
 * to the tail-most snd_list node of each channels, and it is by
 * extending the list at these nodes that sounds are read in.
 * To avoid a circularity, the reference counts on snd_list nodes
 * do not include the backpointers from this susp.  When a snd_list
 * node refcount goes to zero, the multiread susp's free routine
 * is called.  This must scan the backpointers to find the node that
 * has a zero refcount (the free routine is called before the node
 * is deallocated, so this is safe).  The backpointer is then set
 * to NULL.  When all backpointers are NULL, the susp itself is
 * deallocated, because it can only be referenced through the
 * snd_list nodes to which there are backpointers.
 */
void multiread_fetch(susp, snd_list)
  register read_susp_type susp;
  snd_list_type snd_list;
{
    int i, j;
    int frames_read = 0; /* total frames read in this call to fetch */
    int n;
    sample_block_type out;
    char input_buffer[input_buffer_max];
    float *float_ptr;
    int buff_frame_size;
    int file_frame_size;

    /* when we are called, the caller (SND_get_first) will insert a new
     * snd_list node.  We need to do this here for all other channels.
     */
    for (j = 0; j < susp->snd.format.channels; j++) {

/*        nyquist_printf("multiread_fetch: chan[%d] = ", j);
        print_snd_list_type(susp->chan[j]);
        stdputstr("\n");
 */
        if (!susp->chan[j]) {   /* ignore non-existent channels */
/*          nyquist_printf("multiread_fetch: ignore channel %d\n", j);*/
            continue;
        }
        falloc_sample_block(out, "multiread_fetch");
/*      nyquist_printf("multiread: allocated block %x\n", out); */
        /* Since susp->chan[i] exists, we want to append a block of samples.
         * The block, out, has been allocated.  Before we insert the block,
         * we must figure out whether to insert a new snd_list_type node for
         * the block.  Recall that before SND_get_next is called, the last
         * snd_list_type in the list will have a null block pointer, and the
         * snd_list_type's susp field points to the suspension (in this case,
         * susp).  When SND_get_next (in sound.c) is called, it appends a new
         * snd_list_type and points the previous one to internal_zero_block 
         * before calling this fetch routine.  On the other hand, since 
         * SND_get_next is only going to be called on one of the channels, the
         * other channels will not have had a snd_list_type appended.
         * SND_get_next does not tell us directly which channel it wants (it
         * doesn't know), but we can test by looking for a non-null block in the
         * snd_list_type pointed to by our back-pointers in susp->chan[].  If
         * the block is null, the channel was untouched by SND_get_next, and
         * we should append a snd_list_type.  If it is non-null, then it
         * points to internal_zero_block (the block inserted by SND_get_next)
         * and a new snd_list_type has already been appended.
         */
        /* Before proceeding, it may be that garbage collection ran when we
         * allocated out, so check again to see if susp->chan[j] is Null:
         */
        if (!susp->chan[j]) {
            ffree_sample_block(out, "multiread_fetch");
            continue;
        }
        if (!susp->chan[j]->block) {
            snd_list_type snd_list = snd_list_create((snd_susp_type) susp);
            /* Now we have a snd_list to append to the channel, but a very
             * interesting thing can happen here.  snd_list_create, which
             * we just called, MAY have invoked the garbage collector, and
             * the GC MAY have freed all references to this channel, in which
             * case multread_free(susp) will have been called, and susp->chan[j]
             * will now be NULL!
             */
            if (!susp->chan[j]) {
                nyquist_printf("susp %p Channel %d disappeared!\n", susp, j);
                ffree_snd_list(snd_list, "multiread_fetch");
            } else {
                susp->chan[j]->u.next = snd_list;
            }
        }
        /* see the note above: we don't know if susp->chan still exists */
        /* Note: We DO know that susp still exists because even if we lost
         * some channels in a GC, someone is still calling SND_get_next on
         * some channel.  I suppose that there might be some very pathological
         * code that could free a global reference to a sound that is in the
         * midst of being computed, perhaps by doing something bizarre in the
         * closure that snd_seq activates at the logical stop time of its first
         * sound, but I haven't thought that one through.
         */
        if (susp->chan[j]) {
            susp->chan[j]->block = out;
            /* check some assertions */
            if (susp->chan[j]->u.next->u.susp != (snd_susp_type) susp) {
                nyquist_printf("didn't find susp at end of list for chan %d\n", j);
            }
        } else { /* we allocated out, but don't need it anymore due to GC */
            ffree_sample_block(out, "multiread_fetch");
        }
    }

    file_frame_size = susp->snd.format.channels * susp->bytes_per_sample;
    buff_frame_size = susp->snd.format.channels * sizeof(float);
    /* now fill sample blocks with frames from the file 
       until eof or end of blocks */
    while (true) {

        /* compute how many frames to read to fill sample blocks */
        long frame_count = max_sample_block_len - frames_read;
        long byte_count;    /* how many bytes to read */
        long actual;         /* how many frames actually read */
        float peak;

        /* make sure frames will fit in buffer */
        /* assume buff_frame_size >= file_frame_size, i.e. the limiting
           factor will be the number of floats we can fit in the buffer */
        if (frame_count * buff_frame_size > input_buffer_max) {
            frame_count = input_buffer_max / buff_frame_size;
        }

        byte_count = frame_count * file_frame_size;

        /* put samples at end of buffer so we can 
           overwrite buffer with converted samples */
        actual = snd_read(&susp->snd,  
                          input_buffer + input_buffer_max - byte_count, 
                          frame_count);

        n = actual;  

        /* don't read too many */
        if (n > (susp->cnt - susp->susp.current)) {
            n = susp->cnt - susp->susp.current;
        }

        /* we want n frames, convert data to floats */
        (*susp->cvtfn)((void *) input_buffer, 
                       (void *) (input_buffer + input_buffer_max - byte_count), 
                       n * susp->snd.format.channels, 1.0F, &peak);

        /* process one channel at a time, multiple passes through input */
        for (j = 0; j < susp->snd.format.channels; j++) {
            register sample_block_values_type out_ptr;
            /* offset by channel number: */
            float_ptr = ((float *) input_buffer) + j;

            /* ignore nonexistent channels */
            if (!susp->chan[j]) continue;

            /* find pointer to sample buffer */
            out_ptr = susp->chan[j]->block->samples + frames_read;

            /* copy samples */
            for (i = 0; i < n; i++) {
                *out_ptr++ = *float_ptr;
                float_ptr += susp->snd.format.channels;
            }
            susp->chan[j]->block_len = frames_read + n;
        }

        frames_read += n;
        susp->susp.current += n;

        if (frames_read == 0) {
            /* we didn't read anything, but can't return length zero, so
             * convert snd_list's to pointer to zero block.  This loop
             * will free the susp via snd_list_unref().
             */
            for (j = 0; j < susp->snd.format.channels; j++) {
                if (susp->chan[j]) {
                    snd_list_type the_snd_list = susp->chan[j];
                    /* this is done so that multiread_free works right: */
                    susp->chan[j] = susp->chan[j]->u.next;
                    /* nyquist_printf("end of file, terminating channel %d\n", j); */
                    /* this fixes up the tail of channel j */
                    snd_list_terminate(the_snd_list);
                }
            }
            return;
        } else if (susp->cnt == susp->susp.current || actual < frame_count) {
            /* we've read the requested number of frames or we
             * reached end of file
             * last iteration will close file and free susp:
             */
            for (j = 0; j < susp->snd.format.channels; j++) {
                snd_list_type the_snd_list = susp->chan[j];
                /* nyquist_printf("reached susp->cnt, terminating chan %d\n", j); */
                if (the_snd_list) {
                    /* assert: */
                    if (the_snd_list->u.next->u.susp != (snd_susp_type) susp) {
                        stdputstr("assertion violation");
                    }
                    /* this is done so that multiread_free works right: */
                    susp->chan[j] = the_snd_list->u.next;
                    snd_list_unref(the_snd_list->u.next);
                    /* terminate by pointing to zero block */
                    the_snd_list->u.next = zero_snd_list;
                }
            }
            return;
        } else if (frames_read >= max_sample_block_len) {
            /* move pointer to next list node */
            for (j = 0; j < susp->snd.format.channels; j++) {
                if (susp->chan[j]) susp->chan[j] = susp->chan[j]->u.next;
            }
            return;
        }
    }
} /* multiread__fetch */
  

void multiread_free(read_susp_type susp)
{
    int j;
    boolean active = false;
/*    stdputstr("multiread_free: "); */
    for (j = 0; j < susp->snd.format.channels; j++) {
        if (susp->chan[j]) {
            if (susp->chan[j]->refcnt) active = true;
            else {
                susp->chan[j] = NULL;
                /* nyquist_printf("deactivating channel %d\n", j); */
            }
        }
    }
    if (!active) {
/*      stdputstr("all channels freed, freeing susp now\n"); */
        read_free(susp);
    }
}


LVAL multiread_create(susp)
  read_susp_type susp;
{
    LVAL result;
    int j;

    xlsave1(result);

    result = newvector(susp->snd.format.channels);      /* create array for sounds */
    falloc_generic_n(susp->chan, snd_list_type, susp->snd.format.channels, 
                     "multiread_create");
    /* create sounds to return */
    for (j = 0; j < susp->snd.format.channels; j++) {
        sound_type snd = sound_create((snd_susp_type)susp, 
                                      susp->susp.t0, susp->susp.sr, 1.0);
        LVAL snd_lval = cvsound(snd);
/*      nyquist_printf("multiread_create: sound %d is %x, LVAL %x\n", j, snd, snd_lval); */
        setelement(result, j, snd_lval);
        susp->chan[j] = snd->list;
    }
    xlpop();
    return result;
}