/*====================================================================
 * sl.c
 *
 * Synopsis:
 *  Sound library global routines
 *
 * Copyright 1993, Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics,
 * Inc.; the contents of this file may not be disclosed to third
 * parties, copied or duplicated in any form, in whole or in part,
 * without the prior written permission of Silicon Graphics, Inc.
 *
 * RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to
 * restrictions as set forth in subdivision (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS
 * 252.227-7013, and/or in similar or successor clauses in the FAR,
 * DOD or NASA FAR Supplement. Unpublished - rights reserved under the
 * Copyright Laws of the United States.
 *====================================================================*/

#include <libaudio.h>

ALGlobals *slg=0;
void alErrFunc(ALError type, char *msg);

void alInit(ALGlobals *g, ALSynConfig *c)
{
    if (!slg) { /* already initialized? */
        slg = g;
        alSynNew(&slg->drvr, c);
        slg->errFunc = alErrFunc;
    }
}

void alClose(ALGlobals *glob)
{
    alSynDelete(&glob->drvr);
    slg = 0;
}

/* might want to make these macros */
void alLink(ALLink *a, ALLink *b)
{					
    ALLink *ln = (ALLink *) a; 
    ALLink *to = (ALLink *) b; 
    ln->next = to->next;     
    ln->prev = to;           
    if (to->next)            
        to->next->prev = ln; 
    to->next = ln;           
}

void alUnlink(ALLink *a)			
{					
    ALLink *ln = (ALLink *) a; 	
    if (ln->next)                   
        ln->next->prev = ln->prev;  
    if (ln->prev)                   
        ln->prev->next = ln->next;  
}

void alCopy(void *src, void *dest, int len)
{
    int  i;
    char *s = (char *)src;
    char *d = (char *)dest;

    for (i = 0; i < len; i++){
        *d++ = *s++;
    }
}

/***********************************************************************
  Heap Stuff
  ***********************************************************************/
typedef struct {
    int         magic;  /* check structure integrety                    */
    int         size;   /* size of this allocated block                 */
    char        *file;  /* file that this alloc was called from         */
    int         line;   /* line that it was called from                 */
    int         count;  /* heap call number                             */
    int         pad;
} HeapInfo;

void alHeapInit(ALHeap *hp, char *base, int len)
{
    hp->base = base;
    hp->len  = len;
    hp->cur  = base;
    hp->count = 0;
}

void *alHeapDBAlloc(char *file, int line, ALHeap *hp, int num, int size)
{
    int bytes;
    char *ptr = 0;

    bytes = (num*size +7) & ~7;
    
#ifdef AL_DEBUG    
    alHeapCheck(hp);    
    hp->count++;    
    bytes += sizeof(HeapInfo);
#endif
    
    if ((hp->cur + bytes) <= (hp->base + hp->len)) {

        ptr = hp->cur;
        hp->cur += bytes;

#ifdef AL_DEBUG    
        ((HeapInfo *)ptr)->magic = AL_HEAP_MAGIC;
        ((HeapInfo *)ptr)->size  = bytes;
        ((HeapInfo *)ptr)->count = hp->count;
        if (file) {
            ((HeapInfo *)ptr)->file  = file;
            ((HeapInfo *)ptr)->line  = line;
        } else {
            ((HeapInfo *)ptr)->file  = "unknown";
            ((HeapInfo *)ptr)->line  = 0;
        }
        
        ptr += sizeof(HeapInfo);

#endif

    } else {
        emPrintf("alHeapAlloc: file %s, line %d can't allocate %d bytes\n",
                 file, line, size);
        emPrintf("           : need %d bytes\n",
                 (hp->cur + bytes - hp->base - hp->len));
    }

    return ptr;
}

int alHeapSize(int num, int size)
{
    int bytes = num*size;

#ifdef AL_DEBUG    
    bytes += sizeof(HeapInfo);
#endif

    return bytes;
}

int alHeapCheck(ALHeap *hp)
{
    int         rv = 0;
    HeapInfo    *hi;
    HeapInfo    *last = 0;
    char        *ptr;
    
#ifdef AL_DEBUG    
    for (ptr = hp->base; ptr < hp->cur; ptr += hi->size){

        hi = (HeapInfo *)ptr;

        if ( hi->magic != AL_HEAP_MAGIC) {      
            emPrintf("warning: ---------- heap corrupted ----------\n");
            if (last) {
                emPrintf("this *PROBABLY* occurred at %d calls to \n",
                         last->count);     
                emPrintf("alHeapAlloc, file %s, line %d \n", last->file,
                         last->line);
            } else {
                emPrintf("the first block is bad\n");
            }
            
            rv = 1;
            return rv;
        }

        last = hi;

    }
#endif
    return rv;
}

void alErrFunc(ALError type, char *msg)
{
    if (msg) {
        emPrintf("audio error: %d %s\n", type, msg);
    } else {
        emPrintf("audio error: %d\n", type);
    }
}