Mac Magazin/MacEasy 43/Mac Magazin and MacEasy Magazine CD - Issue 43.iso/Software/Multimedia/Sound/PlayerPRO 4.6 Dev.Kit/MADH Library 4.6/MADLibrary Source/MainDriver.c

Text File | 1998-02-12 | 68.0 KB | 3,147 lines | [TEXT/CWIE]

/********************                        ***********************/
//
//    Player PRO 4.6 - DRIVER SOURCE CODE -
//
//    Library Version 4.6
//
//    To use with MAD Library for Mac: Symantec, CodeWarrior and MPW
//
//    Antoine ROSSET
//    16 Tranchees
//    1206 GENEVA
//    SWITZERLAND
//
//    COPYRIGHT ANTOINE ROSSET 1996, 1997, 1998
//
//    Thank you for your interest in PlayerPRO !
//
//    FAX:            ([phone]
//    PHONE:             ([phone]
//    Internet:         [e-mail] or [e-mail]
//
/********************                        ***********************/

#include "RDriver.h"
#include "RDriverInt.h"
#include "AWACDriver.h"
#include "FileUtils.h"
#include "string.h"

#ifdef _MAC_H
#include "OMS.h"
#include <Sound.h>
#include <SoundInput.h>
#include <SoundComponents.h>

#if defined(powerc) || defined (__powerc)
    void    pascal MODPlay (VBLTaskPtr theVBLTask);
#else
    void    MODPlay( void);
#endif

#endif

///////////////////////////////
///////////////////////////////
static        MADLibrary            *MLibrary = (MADLibrary*) 0L;
///////////////////////////////
///////////////////////////////

#define  NO_ASM

#define rate5khz    0x15BB9B5CUL
#define rate16khz    0x4132DDF2UL
#define rate48khz    0xBB800000UL

enum {
    FileType = 1,
    RsrcType = 2,
    PtrType = 3
};
/*
void CreateFreeMADH()
{
    MADSpec        *MADH;
    short        i, x, z;
    FSSpec        aSpec;
    Cmd            *aCmd;

    // ******* HEADER *********

    MADH = (MADSpec*) MADNewPtrClear( sizeof( MADSpec));

    MADH->MAD                    = 'MADH';
    MADH->numPat                = 1;
    MADH->numPointers            = 1;
    MADH->numChn                = 4;
    MADH->speed                    = 6;
    MADH->tempo                    = 125;

    MDriver->header    = MADH;

    // ******* INSTRUMENTS *********

    for( i = 0; i < MAXINSTRU; i++)
    {
        for( x = 0; x < MAXSAMPLE; x++)
        {
            MDriver->sample[ i][ x] = 0L;
        }
    }

    // ******* PARTITION *********

    for(i=0; i< MADH->numPat; i++)
    {
        MDriver->partition[ i] = (PatData*) MADNewPtrClear( sizeof( PatData) + MADH->numChn * 64L * sizeof( Cmd));

        MDriver->partition[ i]->header.size         = 64L;
        MDriver->partition[ i]->header.compMode     = 'NONE';
        MDriver->partition[ i]->header.patBytes     = 0L;
        MDriver->partition[ i]->header.unused2     = 0L;

        for( x = 0; x < 64; x++)
        {
            for( z = 0; z < MDriver->header->numChn; z++)
            {
                aCmd = GetMADCommand(  x,  z, MDriver->partition[ i]);

                MADKillCmd( aCmd);
            }
        }
    }
    for( i = MDriver->header->numPat; i < MAXPATTERN ; i++) MDriver->partition[ i] = 0L;

    HGetVol( 0L, &aSpec.vRefNum, &aSpec.parID);
    pStrcpy( aSpec.name, "\pMADH");

    ExportFile( 'MADH', &aSpec);
}*/

/*
void WriteMADHFile( FSSpec *newFile)
{
    short    fRefNum;
    OSErr    iErr;
    long    inOutCount;

    iErr = FSOpen( newFile->name, 0, &fRefNum);

    if( iErr != noErr)
    {
        iErr = Create( newFile->name, 0, 'SNPL', theType);
        iErr = FSOpen( newFile->name, 0, &fRefNum);
    }

    inOutCount = sizeof( MADSpec);
    iErr = FSWrite( fRefNum, &inOutCount, MDriver->header);

    for( i = 0; i < MDriver->header->numPat ; i++)
    {
        if( thePrefs.MADCompression) MDriver->partition[ i]->header.compMode = 'MAD1';

        if( MDriver->partition[ i]->header.compMode == 'MAD1')
        {
            PatMAD = CompressPartitionMAD1( MDriver->partition[ i]);
            inOutCount = PatMAD->header.PatBytes + sizeof( PatHeader);

            iErr = FSWrite( fRefNum, &inOutCount, PatMAD);

            MyDisposPtr( (Ptr*) &PatMAD);
        }
        else
        {
            inOutCount = sizeof( PatHeader);
            inOutCount += MDriver->header->numChn * MDriver->partition[ i]->header.size * sizeof( Cmd);

            iErr = FSWrite( fRefNum, &inOutCount, MDriver->partition[ i]);
        }
    }

    for( i = 0; i < MAXINSTRU ; i++)
    {
        inOutCount = MDriver->header->fid[i].size;
        if( inOutCount > 0)
        {
            iErr = FSWrite( fRefNum, &inOutCount, MDriver->instrument[i]);
        }
    }
    GetFPos( fRefNum, &tt);
    SetEOF( fRefNum, tt);
    FSClose( fRefNum);
}
*/

long MADGetMusicSize( MADMusic    *music)
{
    short i, x;
    long fileSize;

    if( music->header == 0L) return 0L;

    fileSize = sizeof( MADSpec);
    for( i = 0; i < music->header->numPat; i++) fileSize += sizeof( PatHeader) + music->header->numChn * music->partition[ i]->header.size * sizeof( Cmd);
    for( i = 0; i < MAXINSTRU ; i++)
    {
        for( x = 0; x < music->header->fid[ i].numSamples ; x++)
        {
            sData    *curData = music->sample[ i][ x];

            fileSize += sizeof( sData);
            fileSize += curData->size;
        }
    }

    return fileSize;
}

#ifdef _MAC_H
void ConvertTo64Rows( MADMusic *music)
{
    long        i, x, z;
    Boolean        IsReading;

    if( music->header == 0L) return;

    IsReading = music->musicUnderModification;
    music->musicUnderModification = true;

    for( i = 0; i < music->header->numPat; i++)
    {
        // Resize pattern to 64 rows and put a pattern break

        long        newSize;
        PatData        *newPat;

        newSize = sizeof( PatData) + music->header->numChn * 64L * sizeof( Cmd);

        if( music->partition[ i]->header.size < 64)
        {
            Cmd        *srccmd, *dstcmd;
            long    patsize;

            newPat = ( PatData*) NewPtrClear( newSize);

            newPat->header.size         = 64L;
            newPat->header.compMode     = 'NONE';
            newPat->header.patBytes     = 0L;
            newPat->header.unused2         = 0;

            BlockMove( music->partition[ i]->header.name, newPat->header.name, 32);

            // Upgrade length to 64

            for( x = 0, patsize = 0; x < 64; x++, patsize++)
            {
                for( z = 0; z < music->header->numChn; z++)
                {
                    if( x < music->partition[ i]->header.size)
                    {
                        // src
                        srccmd = GetMADCommand( patsize, z, music->partition[ i]);

                        // dst
                        dstcmd = GetMADCommand( x, z, newPat);

                        *dstcmd = *srccmd;
                    }
                    else
                    {
                        dstcmd = GetMADCommand( x, z, newPat);

                        MADKillCmd( dstcmd);
                    }
                }
            }

            // dst
            dstcmd = GetMADCommand( music->partition[ i]->header.size-1, 0, newPat);        // Pose le pattern break

            MADKillCmd( dstcmd);

            dstcmd->cmd = skipE;
            dstcmd->arg = 0;

            // Replace old pattern

            DisposePtr( ( Ptr) music->partition[ i]);
            music->partition[ i] = 0L;

            music->partition[ i] = newPat;
        }
        else if( music->partition[ i]->header.size > 64)
        {
            long        patID = i;
            long         patsize = 0;
            PatData*    srcPat = music->partition[ i];

            while( patsize < srcPat->header.size)
            {
                newPat = ( PatData*) NewPtrClear( newSize);

                newPat->header.size         = 64L;
                newPat->header.compMode     = 'NONE';
                newPat->header.patBytes     = 0L;
                newPat->header.unused2         = 0;

                BlockMove( srcPat->header.name, newPat->header.name, 32);

                for( x = 0; x < 64; x++, patsize++)
                {
                    for( z = 0; z < music->header->numChn; z++)
                    {
                        Cmd        *srccmd, *dstcmd;

                        if( patsize < srcPat->header.size)
                        {
                            // src
                            srccmd = GetMADCommand( patsize, z, srcPat);

                            // dst
                            dstcmd = GetMADCommand( x, z, newPat);

                            *dstcmd = *srccmd;
                        }
                        else
                        {
                            dstcmd = GetMADCommand( x, z, newPat);
                            MADKillCmd( dstcmd);
                        }
                    }
                }

                // Update patterns list & partition

                if( patID != i)
                {
                    for( x = music->header->numPat; x > patID ; x--)
                    {
                        music->partition[ x] = music->partition[ x - 1];
                    }
                    music->header->numPat++;
                }

                for( x = music->header->numPat; x < MAXPATTERN; x++) music->partition[ x] = 0L;

                music->partition[ patID] = newPat;

                patID++;
            }

            // Do we need a pattern break ?

            if( (srcPat->header.size / 64) * 64 != srcPat->header.size)
            {
                short    breakpos;
                Cmd        *dstcmd;

                breakpos = srcPat->header.size - (srcPat->header.size / 64) * 64;

                dstcmd = GetMADCommand( breakpos-1, 0, newPat);
                MADKillCmd( dstcmd);

                dstcmd->cmd = skipE;
                dstcmd->arg = 0;
            }

            // Update la partition list

            for( x = 0; x < music->header->numPointers; x++)
            {
                if( music->header->oPointers[ x] > patID) music->header->oPointers[ x] += patID - i;
                else if( music->header->oPointers[ x] == i)
                {
                    // Avance le reste de la partition

                    for( z = x; z < 256; z++)
                    {
                        if( x + patID - i - 1 < 256)
                        {
                            music->header->oPointers[ x + patID - i - 1] = music->header->oPointers[ x];
                        }
                    }

                    for( z = i; z < patID; z++)
                    {
                        music->header->oPointers[ x] = z;

                        x++;
                    }
                    x--;

                    music->header->numPointers += patID - i - 1;
                }
            }

            DisposePtr( ( Ptr) srcPat);
        }
    }

    music->musicUnderModification = IsReading;
}

long MADMinimize( MADMusic *music)
{
    short         i, x, z;
    Boolean        remove, IsReading;
    Boolean        inst[ MAXINSTRU];
     long        before, after;

     if( music->header == 0L) return 0L;

    IsReading = music->musicUnderModification;
    music->musicUnderModification = true;

    // Check size before

    before = MADGetMusicSize( music);

    // Check for unused patterns

    if( music->header->numPat > 1)
    {
        for( i = 0; i < music->header->numPat; i++)
        {
            remove = true;
            for( x = 0; x < music->header->numPointers; x++)
            {
                if( music->header->oPointers[ x] == i)
                {
                    remove = false;
                    break;
                }
            }

            if( remove)
            {
                music->header->numPat--;

                DisposePtr( ( Ptr) music->partition[ i]);
                music->partition[ i] = 0L;

                for( x = i; x < music->header->numPat; x++)
                {
                    music->partition[ x] = music->partition[ x + 1];
                }
                for( x = music->header->numPat; x < MAXPATTERN; x++) music->partition[ x] = 0L;

                /***** Update la partition list ******/

                for( x = 0; x < 128; x++)
                {
                    if( music->header->oPointers[ x] > i) music->header->oPointers[ x]--;
                    else if( music->header->oPointers[ x] == i) music->header->oPointers[ x] = 0;
                }

                if( i > 0) i--;
            }
        }
    }

    // Check for unused instruments
    for( i = 0; i < 32 ; i++) inst[ i] = false;

    for( i = 0; i < music->header->numPat; i++)
    {
        for( x = 0; x < music->partition[ i]->header.size; x++)
        {
            for( z = 0; z < music->header->numChn; z++)
            {
                Cmd        *cmd;

                cmd = GetMADCommand( x, z, music->partition[ i]);

                if( cmd->ins > 0) inst[ cmd->ins-1] = true;
            }
        }
    }

    for( i = 0; i < MAXINSTRU; i++)
    {
        if( inst[ i] == false) MADKillInstrument( music, i);
    }

    // Check for after loop data
    for( i = 0; i < MAXINSTRU; i++)
    {
        for( x = 0; x < music->header->fid[ i].numSamples; x++)
        {
            sData    *curData = music->sample[ i][ x];

            if( curData->loopSize > 2)
            {
                if( curData->size > curData->loopBeg + curData->loopSize)
                {
                    SetPtrSize( curData->data, curData->loopBeg + curData->loopSize);

                    curData->size = curData->loopBeg + curData->loopSize;
                }
            }
        }
    }

    music->musicUnderModification = IsReading;

    after = MADGetMusicSize( music);

    return before - after;
}
#endif

Ptr MADNewPtr( long size, MADLibrary* init)
{
    if( init->sysMemory) return NewPtrSys( size);
    else return NewPtr( size);
}

Ptr MADNewPtrClear( long size, MADLibrary* init)
{
    if( init->sysMemory) return NewPtrSysClear( size);
    else return NewPtrClear( size);
}

void MADGetBestDriver( MADDriverSettings    *Init)
{
#ifdef _MAC_H
long                gestaltAnswer;
short                myBit;
NumVersion    nVers;
Boolean            Stereo, StereoMixing, NewSoundManager, NewSoundManager31, hasASC, Audio16;

/***************                    ****************/
/****** HARDWARE IDENTIFICATION AND CHECK **********/
/***************                    ****************/

/****************/
/** ASC CHIP ? **/
/****************/

    Gestalt( kSoundOutputDeviceType, &gestaltAnswer);
    if( gestaltAnswer == kASCSubType) hasASC = true;
    else hasASC = false;

/**************/
/** STEREO ? **/
/**************/

    Gestalt( gestaltSoundAttr, &gestaltAnswer);
    myBit = gestaltStereoCapability;
    Stereo = BitTst( &gestaltAnswer, 31-myBit);

/******************************/
/** INTERNAL STEREO MIXING ? **/
/******************************/

    myBit = gestaltStereoMixing;
    StereoMixing = BitTst( &gestaltAnswer, 31-myBit);

/***********************/
/** 16 BITS SUPPORT ? **/
/***********************/

    myBit = gestalt16BitSoundIO;
    Audio16 = BitTst( &gestaltAnswer, 31-myBit);

/****************************/
/** SOUND MANAGER >= 3.0 ? **/
/****************************/

    nVers = SndSoundManagerVersion();
    NewSoundManager31 = false;    NewSoundManager = false;
    if( nVers.majorRev >= 3 && nVers.minorAndBugRev >= 0x10)
    {
        NewSoundManager31 = true;
        NewSoundManager = true;
    }
    else if( nVers.majorRev >= 3) NewSoundManager = true;

    Init->numChn            = 4;
    Init->antiAliasing        = false;
    Init->surround            = false;
    Init->repeatMusic        = true;
    Init->sysMemory            = false;
    Init->Interpolation        = false;
    Init->MicroDelay        = false;
    Init->MicroDelaySize     = 30;
    Init->Reverb            = false;
    Init->ReverbSize        = 100;
    Init->ReverbStrength    = 20;

    // STEREO OR MONO ?

    if( Stereo == true && StereoMixing == true) Init->outPutMode = DeluxeStereoOutPut;
    else Init->outPutMode = MonoOutPut;


    // RATE AND SIZE

    if( NewSoundManager == true)
    {
        Init->driverMode = SoundManagerDriver;

        ////////

        #if !TARGET_RT_MAC_CFM
        if( NewSoundManager31)
        {
            OSErr    iErr;

            iErr = GetSoundOutputInfo( 0L, siSampleRate, &Init->outPutRate);            if(iErr) goto oldWay;
            iErr = GetSoundOutputInfo( 0L, siSampleSize, (void*) &Init->outPutBits);    if(iErr) goto oldWay;
        }
        else
        #endif
        {
             oldWay:;

            if( Audio16)            {    Init->outPutBits = 16;    Init->outPutRate = rate44khz;}
            else                    {    Init->outPutBits = 8;    Init->outPutRate = rate22khz;}
        }
    }
    else if( hasASC == true)
    {
        Init->driverMode = ASCSoundDriver;

        ////////

        Init->outPutBits = 8;
        Init->outPutRate = rate22khz;
    }
    else
    {
        Init->driverMode = SoundManagerDriver;

        Init->outPutBits = 8;
        Init->outPutRate = rate22khz;
    }
    #else

    #endif
}

OSErr MADCreateMicroDelay( MADDriverRec *intDriver)
{
    intDriver->MDelay = (intDriver->DriverSettings.MicroDelaySize * ( intDriver->DriverSettings.outPutRate >> 16)) / 1000;

    return noErr;
}

void MADDisposeReverb( MADDriverRec *intDriver)
{
    if( intDriver->DriverSettings.Reverb) DisposePtr( intDriver->ReverbPtr);
    intDriver->ReverbPtr = 0L;
}

OSErr MADCreateReverb( MADDriverRec *intDriver)
{
    long i;

    if( intDriver->DriverSettings.Reverb)
    {
        intDriver->RDelay = (intDriver->DriverSettings.ReverbSize * ( intDriver->DriverSettings.outPutRate >> 16L)) / 1000L;

        switch( intDriver->DriverSettings.outPutBits)
        {
            case 8:
                intDriver->ReverbPtr = NewPtr( intDriver->RDelay * 2L);
                if( intDriver->ReverbPtr == 0L) return MADNeedMemory;
                for( i = 0; i < intDriver->RDelay * 2L; i++) intDriver->ReverbPtr[ i] = 0x80;
            break;

            case 16:
                intDriver->ReverbPtr = NewPtrClear( intDriver->RDelay * 4L);
                if( intDriver->ReverbPtr == 0L) return MADNeedMemory;
            break;
        }
    }

    return noErr;
}

void MADDisposeDriverBuffer( MADDriverRec *intDriver)
{
    if( intDriver->IntDataPtr != 0L)    DisposePtr( intDriver->IntDataPtr);
    intDriver->IntDataPtr = 0L;
}

OSErr MADCreateDriverBuffer( MADDriverRec *intDriver)
{
    long BufSize = intDriver->ASCBUFFER;

    switch( intDriver->DriverSettings.outPutMode)
    {
        case MonoOutPut:                    BufSize = BufSize;            break;
        case StereoOutPut:                BufSize = BufSize*2L;        break;
        case DeluxeStereoOutPut:    BufSize = BufSize*2L;        break;
    }

    switch( intDriver->DriverSettings.outPutBits)
    {
        case 16:                                    BufSize = BufSize*2L;        break;
    }

    intDriver->IntDataPtr = MADNewPtr( BufSize, MLibrary);
    if( intDriver->IntDataPtr == 0L) return MADNeedMemory;

    intDriver->BufSize                = BufSize;
    intDriver->OscilloWavePtr    = intDriver->IntDataPtr;

    return noErr;
}

OSErr MADCreateTiming( MADDriverRec *intDriver)
{
    /*************************/
    /**     Rate table      **/
    /*************************/

    intDriver->VSYNC    = ((intDriver->DriverSettings.outPutRate>>16) * 125L) / (50L);
    intDriver->trackDiv = intDriver->DriverSettings.numChn;
    if( intDriver->DriverSettings.outPutMode == StereoOutPut) intDriver->trackDiv /= 2;

    return noErr;
}


OSErr MADChangeDriverSettings( MADDriverSettings    *DriverInitParam, MADDriverRec** returnDriver)
{
    MADMusic    *music;
    Boolean        playing;
    OSErr        err;
    long        fullTime, curTime;

    music = (*returnDriver)->curMusic;
    playing = (*returnDriver)->Reading;

    MADGetMusicStatus( *returnDriver, &fullTime, &curTime);

    if( (err = MADStopDriver( *returnDriver)) != noErr) return err;
    if( (err = MADDisposeDriver( *returnDriver)) != noErr) return err;

    if( (err = MADCreateDriver( DriverInitParam, returnDriver)) != noErr) return err;

    if( (err = MADStartDriver( *returnDriver)) != noErr) return err;

    if( music)
    {
        MADAttachDriverToMusic( *returnDriver, music);

        MADSetMusicStatus( *returnDriver, 0, fullTime, curTime);

        if( playing) MADPlayMusic( *returnDriver);
    }

    return noErr;
}

OSErr MADCreateDriver( MADDriverSettings    *DriverInitParam, MADDriverRec** returnDriver)
{
    OSErr                     theErr;
    long                    i;
    MADDriverRec*            MDriver;

    *returnDriver = 0L;

    if( MLibrary == 0L) return MADNeedMemory;

    if( MLibrary->sysMemory) MDriver = (MADDriverRec*) NewPtrSysClear( sizeof( MADDriverRec));
    else MDriver = (MADDriverRec*) NewPtrClear( sizeof( MADDriverRec));

    /*************************/
    /** Paramaters checking **/
    /*************************/

    if( DriverInitParam->numChn % 2 != 0)
    {
        DriverInitParam->numChn /= 2;
        DriverInitParam->numChn *= 2;
    //    DriverInitParam->numChn++;
    }
    if( DriverInitParam->numChn < 2) return MADParametersErr;
    if( DriverInitParam->numChn > MAXTRACK) return MADParametersErr;

    if( DriverInitParam->outPutBits != 8 && DriverInitParam->outPutBits != 16) return MADParametersErr;

    if( DriverInitParam->outPutRate < rate5khz) return MADParametersErr;
    if( DriverInitParam->outPutRate > rate48khz) return MADParametersErr;

    if( DriverInitParam->outPutMode != MonoOutPut &&
        DriverInitParam->outPutMode != StereoOutPut &&
        DriverInitParam->outPutMode != DeluxeStereoOutPut &&
        DriverInitParam->outPutMode != PolyPhonic &&
        DriverInitParam->outPutMode != MultiFiles) return MADParametersErr;

    if( DriverInitParam->driverMode != ASCSoundDriver &&
        DriverInitParam->driverMode != AWACSoundDriver &&
        DriverInitParam->driverMode != SoundManagerDriver &&
        DriverInitParam->driverMode != MIDISoundDriver &&
        DriverInitParam->driverMode != BeOSSoundDriver &&
        DriverInitParam->driverMode != DirectSound95NT &&
        DriverInitParam->driverMode != Wave95NT &&
        DriverInitParam->driverMode != NoHardwareDriver) return MADParametersErr;

    if( DriverInitParam->MicroDelay)
    {
        if( DriverInitParam->MicroDelaySize < 0)         return MADParametersErr;
        if( DriverInitParam->MicroDelaySize > 1000)     return MADParametersErr;
    }

    if( DriverInitParam->Reverb)
    {
        if( DriverInitParam->ReverbSize < 25)             return MADParametersErr;
        if( DriverInitParam->ReverbSize > 1000)         return MADParametersErr;

        if( DriverInitParam->ReverbStrength < 0)         return MADParametersErr;
        if( DriverInitParam->ReverbStrength > 70)         return MADParametersErr;
    }

    /*************************/

    if( !MLibrary) return -45;

    MDriver->lib = MLibrary;
    MDriver->curMusic = 0L;

    MDriver->Reading = false;

    theErr = MADStopDriver( MDriver);
    if( theErr != noErr) return theErr;

    theErr = MADDisposeDriver( MDriver);
    if( theErr != noErr) return theErr;

    theErr = MADCreateVibrato( MDriver);
    if( theErr != noErr) return theErr;

    for( i = 0; i < MAXTRACK; i++)
    {
        MDriver->VolExt[ i] = 64;
        if( i % 2 == 0) MDriver->LeftRight[ i] = 30;
        else MDriver->LeftRight[ i] = 70;
    }

    MDriver->DriverSettings        = *DriverInitParam;
    MDriver->musicEnd                = false;
    MDriver->Reading                = false;
    MDriver->JumpToNextPattern    = true;
    MDriver->smallcounter            = 128;            // Start immediately
    MDriver->BufCounter            = 0;
    MDriver->BytesToGenerate        = 0;
    MDriver->speed                = 6;
    MDriver->finespeed            = 125;
    MDriver->VExt                    = 80;
    MDriver->FreqExt                = 80;
    MDriver->VolGlobal            = 64;

    MDriver->MIN_PITCH            = GetOldPeriod( NUMBER_NOTES-1, NOFINETUNE, MDriver);
    MDriver->MAX_PITCH            = GetOldPeriod( 0, NOFINETUNE, MDriver);

    MADCleanDriver( MDriver);

    /*************************/
    /**     Driver MODE        **/
    /*************************/

    switch( MDriver->DriverSettings.driverMode)
    {
        #ifdef _MAC_H
        case ASCSoundDriver:
            MDriver->pseudoChanAWAC = 0L;
            SndNewChannel( &MDriver->pseudoChanAWAC, 0, 0, 0L);

            MDriver->ASCBUFFER                                        = 370;
            MDriver->DriverSettings.outPutBits        = 8;
            MDriver->DriverSettings.outPutRate        = rate22khz;
        break;

        case AWACSoundDriver:
            MDriver->pseudoChanAWAC = 0L;
            SndNewChannel( &MDriver->pseudoChanAWAC, 0, 0, 0L);

            MDriver->ASCBUFFER                                        = 1024;
            MDriver->DriverSettings.outPutBits        = 16;
            MDriver->DriverSettings.outPutRate        = rate44khz;

            if(    MDriver->DriverSettings.outPutMode == MonoOutPut) MDriver->DriverSettings.outPutMode = StereoOutPut;
        break;

        case MIDISoundDriver:
            MDriver->pseudoChanAWAC = 0L;
            SndNewChannel( &MDriver->pseudoChanAWAC, 0, 0, 0L);

            MDriver->ASCBUFFER                                        = 370;
            MDriver->DriverSettings.outPutBits        = 8;
            MDriver->DriverSettings.outPutRate        = rate22khz;
        break;

        #endif

        case SoundManagerDriver:
            MDriver->ASCBUFFER = 370;
            MDriver->ASCBUFFER = (MDriver->ASCBUFFER * (MDriver->DriverSettings.outPutRate>>16L)) / 22254L;
            MDriver->ASCBUFFER /= 2;
            MDriver->ASCBUFFER *= 2;
            if( MDriver->ASCBUFFER < 370) MDriver->ASCBUFFER = 370;
        break;

        case NoHardwareDriver:
            MDriver->ASCBUFFER = 1024;
        break;

        case BeOSSoundDriver:
            MDriver->ASCBUFFER = 1024L;

            if( MDriver->DriverSettings.outPutBits == 8) MDriver->ASCBUFFER *= 2L;
        break;

        case DirectSound95NT:
            MDriver->ASCBUFFER = 7500L;
        break;

        case Wave95NT:
            MDriver->ASCBUFFER = 7500L;
        break;

        default:
            return MADParametersErr;
        break;
    }


    theErr = MADCreateDriverBuffer( MDriver);        if( theErr != noErr) return theErr;
    theErr = MADCreateTiming( MDriver);                    if( theErr != noErr) return theErr;
    theErr = MADCreateReverb( MDriver);                    if( theErr != noErr) return theErr;
    theErr = MADCreateVolumeTable(    MDriver);        if( theErr != noErr) return theErr;


    /**********************************************/
    /**    Interruption - Hardware Support       **/
    /**********************************************/

    switch( MDriver->DriverSettings.driverMode)
    {
        #ifdef _MAC_H
        case ASCSoundDriver:
            InstallMODVBL( MDriver);
        break;

        case AWACSoundDriver:
            InstallDMAVBL( MDriver);
        break;

        case MIDISoundDriver:
            InstallMODVBL( MDriver);

            MDriver->gOutNodeRefNum = -1;

            #if defined(__MWERKS__)
            OMSAddPort( 'SNPL', 'out ', omsPortTypeOutput, NULL, 0L, &MDriver->MIDIPortRefNum);
            #endif
        break;

        case SoundManagerDriver:
            if( MDriver->DriverSettings.outPutMode == MonoOutPut) theErr = InitDBSoundManager( MDriver, initMono);
            else theErr = InitDBSoundManager( MDriver, initStereo);

            if( theErr != noErr) return theErr;
        break;
        #endif

        #ifdef _INTEL_H
        case DirectSound95NT:

            if( !DirectSoundInit( MDriver)) theErr = MADUnknowErr;
            if( theErr != noErr) return theErr;

        break;

        case Wave95NT:
            if( !W95_Init( MDriver)) theErr = MADUnknowErr;
            if( theErr != noErr) return theErr;
        break;
        #endif

        case BeOSSoundDriver:

        break;

        case NoHardwareDriver:

        break;
    }

    *returnDriver = MDriver;

    return noErr;
}

OSErr MADDisposeDriver( MADDriverRec* MDriver)
{
    if( MDriver->IntDataPtr == 0L) return noErr;

    MDriver->Reading = false;

    MADCleanDriver( MDriver);

    switch( MDriver->DriverSettings.driverMode)
    {
        #ifdef _MAC_H
        case MIDISoundDriver:
            RemoveMODVBL( MDriver);
            //MIDIRemovePort( MDriver->MIDIPortRefNum);
        break;

        case ASCSoundDriver:
            RemoveMODVBL( MDriver);
            SndDisposeChannel( MDriver->pseudoChanAWAC, true);
            MDriver->pseudoChanAWAC = 0L;
        break;

        case AWACSoundDriver:
            RemoveDMAVBL();
            SndDisposeChannel( MDriver->pseudoChanAWAC, true);
            MDriver->pseudoChanAWAC = 0L;
        break;

        case SoundManagerDriver:
            DBSndClose( MDriver);
        break;
        #endif

        #ifdef _INTEL_H
        case DirectSound95NT:
            DirectSoundClose( MDriver);
        break;

        case Wave95NT:
            W95_Exit( MDriver);
        break;
        #endif
    }

    MADDisposeDriverBuffer( MDriver);            if( MemError()) return MADUnknowErr;
    MADDisposeVolumeTable( MDriver);            if( MemError()) return MADUnknowErr;
    MADDisposeReverb( MDriver);                    if( MemError()) return MADUnknowErr;

    DisposePtr( (Ptr) MDriver);

    return noErr;
}

OSErr MADInitLibrary( char *PlugsFolderName, Boolean sysMemory)
{
    long     i, mytab[ 12] =
    {
        1712L*16L,1616L*16L,1524L*16L,1440L*16L,1356L*16L,1280L*16L,
        1208L*16L,1140L*16L,1076L*16L,1016L*16L,960L*16L,907L*16L
    };

    if( sysMemory) MLibrary = (MADLibrary*) NewPtrSysClear( sizeof( MADLibrary));
    else MLibrary = (MADLibrary*) NewPtrClear( sizeof( MADLibrary));

    if( MLibrary == 0L) return MADNeedMemory;

    MLibrary->IDType = 'MADD';
    MLibrary->sysMemory = sysMemory;

    for( i = 0; i < 12; i++)
    {
        MLibrary->mytab[ i] = mytab[ i];
    }

    MInitImportPlug( PlugsFolderName);

    return noErr;
}

OSErr MADDisposeLibrary()
{
    if( MLibrary != 0L)
    {
        CloseImportPlug();
        MLibrary->IDType = 'XXXX';

        DisposePtr( (Ptr) MLibrary);
        MLibrary = 0L;
    }
    return noErr;
}

OSErr MADAttachDriverToMusic( MADDriverRec *driver, MADMusic *music)
{
    if( !driver) return -1;
    if( !music) return -1;

    driver->curMusic = music;

    MADReset( driver);
    UpdateTracksNumber( driver);

    return noErr;
}

#ifdef _MAC_H
OSErr MADLoadMusicRsrc( MADMusic **music, OSType IDName, short    IDNo)
{
    Handle    theRsrc;
    OSErr    theErr;

//    MADDisposeMusic( music);

    SetResLoad( false);
    theRsrc = GetResource( IDName, IDNo);
    if( theRsrc == 0L) return MADReadingErr;

    theErr = MADReadMAD( music, 0, RsrcType, theRsrc, 0L);
    if( theErr != noErr)
    {
        ReleaseResource( theRsrc);
        SetResLoad( true);

        MADDisposeMusic( music);
        return theErr;
    }

    ReleaseResource( theRsrc);
    SetResLoad( true);

    return noErr;
}
#endif

OSErr MADLoadMusicPtr( MADMusic **music, Ptr myPtr)
{
    OSErr    theErr;

//    MADDisposeMusic( music);

    theErr = MADReadMAD( music, 0, PtrType, 0L, myPtr);
    if( theErr != noErr) return theErr;

    return noErr;
}

OSErr MADLoadMADFileCString( MADMusic **music, Ptr fName)
{
OSErr        theErr;
UNFILE    srcFile;

//    MADDisposeMusic( music);

    srcFile = iFileOpen( fName);
    if( srcFile == 0L) return MADReadingErr;

    theErr = MADReadMAD( music, srcFile, FileType, 0L, 0L);
    if( theErr != noErr)
    {
        iClose( srcFile);
        MADDisposeMusic( music);
        return theErr;
    }

    iClose( srcFile);

    return( noErr);
}

#ifdef _MAC_H
OSErr MADSetHardwareVolume( long vol)
{
Point            tempL;
long            *tL;
NumVersion        nVers;
Boolean            NewSoundManager;

    if(vol > 64) vol = 64;
    if(vol < 0) vol = 0;

    nVers = SndSoundManagerVersion();
//    BlockMove( &tt, &nVers, 4);
    if( nVers.majorRev >= 3) NewSoundManager = true;
    else NewSoundManager = false;

    if( vol > 0)
    {
        if( NewSoundManager)
        {
            tempL.v = vol * 4;
            tempL.h = vol * 4;

            tL = (long*) &tempL;

            SetDefaultOutputVolume( *tL);
        }
        #if defined(powerc) || defined (__powerc)
        #else
        else
        {
        /*    #if GENERATINGCFM
            #else
            vol = (vol * 7L) / 64L;
            SetSoundVol( vol);
            #endif    */
        }
        #endif
    }

    return noErr;
}

long MADGetHardwareVolume()
{
Point            tempL;
NumVersion        nVers;
Boolean            NewSoundManager;
long            vol;

    nVers = SndSoundManagerVersion();
//    BlockMove( &tt, &nVers, 4);
    if( nVers.majorRev >= 3) NewSoundManager = true;
    else NewSoundManager = false;

    if( NewSoundManager)
    {
        GetDefaultOutputVolume( (long*) &tempL);

        vol = tempL.v / 4L;
    }
    #if defined(powerc) || defined (__powerc)
    #else
    else
    {
    /*    #if GENERATINGCFM
        #else
        short shortVol;

        GetSoundVol( &shortVol);

        vol = shortVol;
        vol = (64L * vol) / 7L;
        #endif*/
    }
    #endif

    if(vol > 64) vol = 64;
    if(vol < 0) vol = 0;

    return vol;
}

OSErr MADLoadMusicFSpFile( MADMusic **music, char *plugType, FSSpec *theSpec)
{
OSErr                        iErr;
FSSpec                    saved;

    HGetVol( 0L, &saved.vRefNum, &saved.parID);
    HSetVol( 0L, theSpec->vRefNum , theSpec->parID);
    p2cstr( theSpec->name);

    if( !MADstrcmp( "MADH", plugType))     iErr = MADLoadMADFileCString( music, (Ptr) theSpec->name);
    else                                iErr = MADLoadMusicFileCString( music, plugType, (Ptr) theSpec->name);

    c2pstr( (Ptr) theSpec->name);
    HSetVol( 0L, saved.vRefNum , saved.parID);

    return iErr;
}

OSErr MADLoadMusicFilePString( MADMusic **music, char *plugType, Str255 fName)
{
OSErr                iErr;

    p2cstr( fName);

    if( !MADstrcmp( "MADH", plugType))     iErr = MADLoadMADFileCString(  music, (Ptr) fName);
    else                                iErr = MADLoadMusicFileCString(  music, plugType, (Ptr) fName);

    c2pstr( (Ptr) fName);

    return iErr;
}

/*
OSErr MADCopyCurrentPartition( MADMusic *aPartition)
{
    long    i, x;

    if( MDriver->header == 0L) return -1;
    if( aPartition == 0L) return -1;

    aPartition->header = (MADSpec*) MADNewPtr( sizeof( MADSpec), &MDriver->DriverSettings);
    if( aPartition->header == 0L) return -1;

    BlockMoveData( MDriver->header, aPartition->header, sizeof( MADSpec));

    for( i = 0; i < MDriver->header->numPat ; i++)
    {
        aPartition->partition[ i] = (PatData*) MADNewPtr( GetPtrSize( (Ptr) MDriver->partition[ i]), &MDriver->DriverSettings);
        if( aPartition->partition[ i] == 0L) return -1;

        BlockMoveData( MDriver->partition[ i], aPartition->partition[ i], GetPtrSize( (Ptr) MDriver->partition[ i]));
    }
    for( i = MDriver->header->numPat; i < MAXPATTERN ; i++) aPartition->partition[ i] = 0L;

    for( i = 0; i < MAXINSTRU ; i++)
    {
        for( x = 0; x < MDriver->header->fid[i].numSamples; x++)
        {
            sData    *dstData, *srcData = MDriver->sample[ i][ x];

            aPartition->sample[ i][ x] = dstData = (sData*) MADNewPtr( sizeof( sData), &MDriver->DriverSettings);
            if( dstData == 0L) return -1;

            BlockMoveData( srcData, dstData, sizeof( sData));

            dstData->data = MADNewPtr( srcData->size, &MDriver->DriverSettings);
            if( dstData->data == 0L) return -1;

            BlockMoveData( srcData->data, dstData->data, srcData->size);
        }
    }

    return noErr;
}*/

OSErr    MADMusicIdentifyFSp( char *type, FSSpec *theSpec)
{
    FSSpec    saved;
    OSErr        err;

    HGetVol( 0L, &saved.vRefNum, &saved.parID);
    HSetVol( 0L, theSpec->vRefNum, theSpec->parID);
    p2cstr( theSpec->name);

    err =  PPIdentifyFile( type, (Ptr) theSpec->name);

    c2pstr( (Ptr) theSpec->name);
    HSetVol( 0L, saved.vRefNum, saved.parID);

    return err;
}

OSErr    MADMusicIdentifyPString( char *type, Str255 fName)
{
    OSErr    err;

    p2cstr( fName);
    err = PPIdentifyFile( type, (Ptr) fName);
    c2pstr( (Ptr) fName);

    return err;
}
#endif

OSErr    MADMusicIdentifyCString( char *type, Ptr fName)
{
    OSErr    err;

    err = PPIdentifyFile( type, fName);

    return err;
}

OSErr MADLoadMusicFileCString( MADMusic **music, char *plugType, Ptr fName)
{
//MADMusic        *aPartition;
OSErr            iErr;

    if( !MADstrcmp( "MADH", plugType)) iErr = MADLoadMADFileCString( music, fName);
    else
    {
//        MADDisposeMusic( music);

        iErr = PPImportFile( plugType, fName, music);
    }

    return iErr;
}

/*
OSErr MADLoadMusicPartition( MADMusic *aPartition)
{
short        i, x;
Boolean        read = MDriver->Reading;

    MADDisposeMusic();

    MDriver->Reading = false;

    MADReset();

    MDriver->BufCounter = 0;        MDriver->BytesToGenerate = 0;
    MDriver->smallcounter         = 128;

    MDriver->header                    = aPartition->header;
    for( i = 0; i < MAXPATTERN; i++) MDriver->partition[ i]        = aPartition->partition[ i];
    for( i = 0; i < MAXINSTRU; i++)
    {
        for( x = 0; x < MAXSAMPLE; x++) MDriver->sample[ i][ x]    = aPartition->sample[ i][ x];
    }
    MADReset();            // Important pour PL, PartitionReader et Pat !!!!!

    UpdateTracksNumber();

    MDriver->Reading = read;

    return noErr;
}*/

/*OSErr MADSetMusicStatus( long minV, long maxV, long curV)
{
short                newPL, newPat, newPartitionReader, i;
long                tempLong, max, val;
Boolean            ReadingCopy;

    if( MDriver == 0L) return -1;
    if( MDriver->header == 0L) return -1;

    max = 0;
    for( i = 0; i < MDriver->header->numPointers; i++)
    {
        max += MDriver->partition[ MDriver->header->oPointers[ i]]->header.size;
    }
    if( max < 1) max = 1;

    val = (1000L * (curV - minV)) / (maxV - minV);
    tempLong = (max * val) / 1000L;

    ReadingCopy = MDriver->Reading;
    MDriver->Reading = false;

    i = 0;
    newPL = 0;
    while( i < tempLong && newPL < MDriver->header->numPointers)
    {
        i += MDriver->partition[ MDriver->header->oPointers[ newPL]]->header.size;
        newPL++;
    }
    newPL--;
    if( newPL < 0) newPL = 0;
    else i -= MDriver->partition[ MDriver->header->oPointers[ newPL]]->header.size;
    //    newPL--;

    if( newPL >= MDriver->header->numPointers)
    {
        Last:

        newPat = MDriver->header->oPointers[ MDriver->header->numPointers - 1];
        newPartitionReader = MDriver->partition[ newPat]->header.size-1;
    }
    else
    {
        newPat = (MDriver->header)->oPointers[ newPL];
        newPartitionReader = tempLong - i;

        if( newPartitionReader >= MDriver->partition[ newPat]->header.size) goto Last;
    }

    MDriver->PL = newPL;
    MDriver->PartitionReader = newPartitionReader;
    MDriver->Pat = newPat;

    MADCheckSpeed( curMusic, MDriver);

    MADPurgeTrack( MDriver);

    MDriver->Reading = ReadingCopy;

    return noErr;
}*/

OSErr MADSetMusicStatus( MADDriverRec *MDriver, long minV, long maxV, long curV)
{
    short            i, x, y;
    Cmd                *aCmd;

    float            timeResult;
    long            time;
    long            speed, finespeed, fullTime, curTime;
    long            dstTime;

    if( MDriver == 0L)
    {
        return -1;
    }

    if( MDriver->curMusic == 0L)
    {
        return -1;
    }

    if( MDriver->curMusic->header == 0L)
    {
        return -1;
    }

    MADGetMusicStatus( MDriver, &fullTime, &curTime);

    curV -= minV;
    maxV -= minV;

    dstTime            = (curV * fullTime)/maxV;
    timeResult        = 0;
    time            = 0;
    speed            = MDriver->curMusic->header->speed;
    finespeed        = MDriver->curMusic->header->tempo;

    for( i = 0; i < MDriver->curMusic->header->numPointers; i++)
    {
        for( x = 0; x < MDriver->curMusic->partition[ MDriver->curMusic->header->oPointers[ i]]->header.size; x++)
        {
            time ++;

            if( dstTime <= timeResult + ((float) (time * 125L * speed * 60L)) / ((float) (50L * finespeed)))
            {
                MDriver->PL = i;
                MDriver->PartitionReader = x;
                MDriver->Pat = MDriver->curMusic->header->oPointers[ i];

                MADCheckSpeed( MDriver->curMusic, MDriver);

                MADPurgeTrack( MDriver);

                return noErr;
            }

            for( y = 0; y <  MDriver->curMusic->header->numChn; y++)
            {
                aCmd = GetMADCommand( x, y, MDriver->curMusic->partition[ MDriver->curMusic->header->oPointers[ i]]);

                /** SpeedE **/

                if( aCmd->cmd == speedE)
                {
                    /** Compute time for this interval **/

                    timeResult += ((float) (time * 125L * speed * 60L)) / ((float) (50L * finespeed));
                    time = 0;

                    /************************************/

                    if( aCmd->arg < 32)
                    {
                        if( aCmd->arg != 0) speed = aCmd->arg;
                    }
                    else
                    {
                        if( aCmd->arg != 0) finespeed = aCmd->arg;
                    }
                }

                /** SkipE **/

                if( aCmd->cmd == skipE)
                {
                    for( ; x < MDriver->curMusic->partition[ MDriver->curMusic->header->oPointers[ i]]->header.size; x++)
                    {
                    }
                }
            }
        }
    }

    return -1;
}

OSErr MADGetMusicStatus( MADDriverRec *MDriver, long *fullTime, long *curTime)
{
    short            i, x, y;
    Cmd                *aCmd;

    float            timeResult;
    long            time;
    long            speed, finespeed;

    if( MDriver == 0L)
    {
        *curTime = 0;
        *fullTime = 1;

        return -1;
    }

    if( MDriver->curMusic == 0L)
    {
        *curTime = 0;
        *fullTime = 1;

        return -1;
    }

    if( MDriver->curMusic->header == 0L)
    {
        *curTime = 0;
        *fullTime = 1;

        return -1;
    }

    timeResult    = 0;
    time                = 0;
    speed                = MDriver->curMusic->header->speed;
    finespeed            = MDriver->curMusic->header->tempo;

    *curTime        = -1;

    for( i = 0; i < MDriver->curMusic->header->numPointers; i++)
    {
        for( x = 0; x < MDriver->curMusic->partition[ MDriver->curMusic->header->oPointers[ i]]->header.size; x++)
        {
            time ++;

            if( i == MDriver->PL    &&
                x == MDriver->PartitionReader)
                {
                    *curTime = timeResult + ((float) (time * 125L * speed * 60L)) / ((float) (50L * finespeed));
                }

            for( y = 0; y <  MDriver->curMusic->header->numChn; y++)
            {
                aCmd = GetMADCommand( x, y, MDriver->curMusic->partition[ MDriver->curMusic->header->oPointers[ i]]);

                /** SpeedE **/

                if( aCmd->cmd == speedE)
                {
                    /** Compute time for this interval **/

                    timeResult += ((float) (time * 125L * speed * 60L)) / ((float) (50L * finespeed));
                    time = 0;

                    /************************************/

                    if( aCmd->arg < 32)
                    {
                        if( aCmd->arg != 0) speed = aCmd->arg;
                    }
                    else
                    {
                        if( aCmd->arg != 0) finespeed = aCmd->arg;
                    }
                }

                /** SkipE **/

                if( aCmd->cmd == skipE)
                {
                    for( ; x < MDriver->curMusic->partition[ MDriver->curMusic->header->oPointers[ i]]->header.size; x++)
                    {
                        if( i == MDriver->PL    &&
                                x == MDriver->PartitionReader)
                        {
                            *curTime = timeResult + ((float) (time * 125L * speed * 60L)) / ((float) (50L * finespeed));
                        }
                    }
                }
            }
        }
    }

    timeResult += ((float) (time * 125L * speed * 60L)) / ((float) (50L * finespeed));

    *fullTime = timeResult;

    if( *curTime == -1) *curTime = *fullTime;

    return noErr;
}

OSErr MADReadMAD( MADMusic **music, UNFILE srcFile, short InPutType, Handle MADRsrc, Ptr MADPtr)
{
short                     i, x;
long                     inOutCount, OffSetToSample;
OSErr                    theErr = noErr;
PatHeader                tempPatHeader;
PatData*                tempPat;
MADMusic                 *MDriver;

*music = 0L;

MDriver = (MADMusic*) MADNewPtrClear( sizeof( MADMusic), MLibrary);
if( !MDriver) return -1L;

MDriver->musicUnderModification = false;

/**** HEADER ****/
inOutCount = sizeof( MADSpec);

MDriver->header = (MADSpec*) MADNewPtr( inOutCount, MLibrary);
if( MDriver->header == 0L)
{
    DisposePtr( (Ptr) MDriver);
    return MADNeedMemory;
}

switch( InPutType)
{
    #ifdef _MAC_H
    case RsrcType:
        OffSetToSample = 0L;
        ReadPartialResource( MADRsrc, 0L, MDriver->header, inOutCount);
        OffSetToSample += inOutCount;
    break;
    #endif

    case FileType:
        if( iRead( inOutCount, (Ptr) MDriver->header, srcFile)) theErr = MADIncompatibleFile;
    break;

    case PtrType:
        OffSetToSample = 0L;
        BlockMoveData( MADPtr, MDriver->header, inOutCount);
        OffSetToSample += inOutCount;
    break;
}

MOT32( &MDriver->header->MAD);
MOT16( &MDriver->header->speed);
MOT16( &MDriver->header->tempo);

for( i = 0; i < MAXINSTRU ; i++)
{
    InstrData    *curIns = &MDriver->header->fid[ i];

    MOT16( &curIns->numSamples);
    MOT16( &curIns->volFade);

    for( x = 0; x < 12; x++)
    {
        MOT16( &curIns->volEnv[ x].pos);
        MOT16( &curIns->volEnv[ x].val);
    }

    for( x = 0; x < 12; x++)
    {
        MOT16( &curIns->pannEnv[ x].pos);
        MOT16( &curIns->pannEnv[ x].val);
    }
}

if( MDriver->header->MAD != 'MADH')
{
    DisposePtr( (Ptr) MDriver->header);
    DisposePtr( (Ptr) MDriver);
    return MADIncompatibleFile;
}

/**** PARTITION ****/
for( i = MDriver->header->numPat; i < MAXPATTERN; i++) MDriver->partition[ i] = 0L;

for( i = 0; i < MDriver->header->numPat; i++)
{
    /** Lecture du header de la partition **/
    inOutCount = sizeof( PatHeader);

    switch( InPutType)
    {
        #ifdef _MAC_H
        case RsrcType:
            ReadPartialResource( MADRsrc, OffSetToSample, &tempPatHeader, inOutCount);
            //    OffSetToSample += inOutCount; ON LE RELIT APRES !!!!!!
        break;
        #endif

        case FileType:
            if( iRead( inOutCount, (Ptr) &tempPatHeader, srcFile)) theErr = MADIncompatibleFile;
            iSeekCur( -sizeof( PatHeader), srcFile);
        break;

        case PtrType:
            BlockMoveData( MADPtr + OffSetToSample, &tempPatHeader, inOutCount);
        break;
    }

    MOT32( &tempPatHeader.size);
    MOT32( &tempPatHeader.compMode);
    MOT32( &tempPatHeader.patBytes);
    MOT32( &tempPatHeader.unused2);

    /*************************************************/
    /** Lecture du header + contenu de la partition **/
    /*************************************************/

    switch( tempPatHeader.compMode)
    {
        case 'MAD1':
            inOutCount = sizeof( PatData) + tempPatHeader.patBytes;
        break;

        case 'NONE':
            inOutCount = sizeof( PatData) + MDriver->header->numChn * tempPatHeader.size * sizeof( Cmd);
        break;

        default:
            return MADIncompatibleFile;
        break;
    }

    MDriver->partition[ i] = ( PatData*) MADNewPtr( inOutCount, MLibrary);
    if( MDriver->partition[ i] == 0L)
    {
        for( x = 0; x < i; x++)
        {
            if( MDriver->partition[ x] != 0L)    DisposePtr( (Ptr) MDriver->partition[ x]);
        }
        DisposePtr( (Ptr) MDriver->header);
        DisposePtr( (Ptr) MDriver);

        return MADNeedMemory;
    }
    switch( InPutType)
    {
        #ifdef _MAC_H
        case RsrcType:
            ReadPartialResource( MADRsrc, OffSetToSample, MDriver->partition[ i], inOutCount);
            OffSetToSample += inOutCount;
        break;
        #endif

        case FileType:
            if( iRead( inOutCount, (Ptr) MDriver->partition[ i], srcFile)) theErr = MADIncompatibleFile;
        break;

        case PtrType:
            BlockMoveData( MADPtr + OffSetToSample, MDriver->partition[ i], inOutCount);
            OffSetToSample += inOutCount;
        break;
    }

    MOT32( &MDriver->partition[ i]->header.size);
    MOT32( &MDriver->partition[ i]->header.compMode);
    MOT32( &MDriver->partition[ i]->header.patBytes);
    MOT32( &MDriver->partition[ i]->header.unused2);

    if( MDriver->partition[ i]->header.compMode == 'MAD1')
    {
        tempPat = DecompressPartitionMAD1( MDriver, MDriver->partition[ i]);

        if( tempPat == 0L)
        {
            for( x = 0; x < i; x++)
            {
                if( MDriver->partition[ x] != 0L)    DisposePtr( (Ptr) MDriver->partition[ x]);
            }
            DisposePtr( (Ptr) MDriver->header);
            DisposePtr( (Ptr) MDriver);

            return MADNeedMemory;
        }

        DisposePtr( (Ptr) MDriver->partition[ i]);
        MDriver->partition[ i] = tempPat;
    }
}

/**** INSTRUMENTS ****/
for( i = 0; i < MAXINSTRU ; i++)
{
    for( x = 0; x < MDriver->header->fid[ i].numSamples ; x++)
    {
        sData     *curData;

        // ** Read Sample header **

        curData = MDriver->sample[ i][ x] = (sData*) MADNewPtr( sizeof( sData), MLibrary);
        if( curData == 0L)
        {
            for( x = 0; x < MAXINSTRU ; x++) MADKillInstrument( MDriver, x);

            for( x = 0; x < MDriver->header->numPat; x++)
            {
                if( MDriver->partition[ x] != 0L)    DisposePtr( (Ptr) MDriver->partition[ x]);
            }
            DisposePtr( (Ptr) MDriver->header);
            DisposePtr( (Ptr) MDriver);

            return MADNeedMemory;
        }

        inOutCount = sizeof( sData);

        switch( InPutType)
        {
            #ifdef _MAC_H
            case RsrcType:
                ReadPartialResource( MADRsrc, OffSetToSample, curData, inOutCount);
                OffSetToSample += inOutCount;
            break;
            #endif

            case FileType:
                if( iRead( inOutCount, (Ptr) curData, srcFile)) theErr = MADIncompatibleFile;
            break;

            case PtrType:
                BlockMoveData( MADPtr + OffSetToSample, curData, inOutCount);
                OffSetToSample += inOutCount;
            break;
        }

        MOT32( &curData->size);
        MOT32( &curData->loopBeg);
        MOT32( &curData->loopSize);
        MOT16( &curData->c2spd);

        // ** Read Sample DATA

        curData->data = MADNewPtr( curData->size, MLibrary);
        if( curData->data == 0L)
        {
            for( x = 0; x < MAXINSTRU ; x++) MADKillInstrument( MDriver, x);

            for( x = 0; x < MDriver->header->numPat; x++)
            {
                if( MDriver->partition[ x] != 0L)    DisposePtr( (Ptr) MDriver->partition[ x]);
            }
            DisposePtr( (Ptr) MDriver->header);
            DisposePtr( (Ptr) MDriver);

            return MADNeedMemory;
        }

        inOutCount = curData->size;
        switch( InPutType)
        {
            #ifdef _MAC_H
            case RsrcType:
                ReadPartialResource( MADRsrc, OffSetToSample, curData->data, inOutCount);
                OffSetToSample += inOutCount;
            break;
            #endif

            case FileType:
                if( iRead( inOutCount, (Ptr) curData->data, srcFile)) theErr = MADIncompatibleFile;
            break;

            case PtrType:
                BlockMoveData( MADPtr + OffSetToSample, curData->data, inOutCount);
                OffSetToSample += inOutCount;
            break;
        }
    }
}
/*********************/

MDriver->header->MAD = 'MADH';

//MADCleanDriver( MDriver);

*music = MDriver;

return( noErr);
}

OSErr MADKillSample( MADMusic *MDriver, short ins, short sample)
{
    short    i;
    Boolean    IsReading;

    if( MDriver->header == 0L) return -1;

        IsReading = MDriver->musicUnderModification;
        MDriver->musicUnderModification = true;

    if( MDriver->sample[ ins][ sample] == 0L) return -1;
    if( MDriver->header->fid[ ins].numSamples <= sample) return -1;

    if( MDriver->sample[ ins][ sample]->data) DisposePtr( MDriver->sample[ ins][ sample]->data);
    DisposePtr( (Ptr) MDriver->sample[ ins][ sample]);
    MDriver->sample[ ins][ sample] = 0L;

    MDriver->header->fid[ ins].numSamples--;

    for( i = sample ; i < MDriver->header->fid[ ins].numSamples; i++)
    {
        MDriver->sample[ ins][ i] = MDriver->sample[ ins][ i + 1];
    }

    for( i = 0; i < NUMBER_NOTES; i++)
    {
        if( MDriver->header->fid[ ins].what[ i] >= sample)
        {
            if( MDriver->header->fid[ ins].what[ i] > 0)
                MDriver->header->fid[ ins].what[ i]--;
        }
    }

        MDriver->musicUnderModification = IsReading;

    return noErr;
}

sData    * MADCreateSample()
{
    sData    *curData;

    curData = (sData*) MADNewPtrClear( sizeof( sData), MLibrary);
    if( curData)
    {
        curData->size        = 0L;
        curData->loopBeg    = 0L;
        curData->loopSize    = 0L;
        curData->vol        = MAX_VOLUME;
        curData->c2spd        = NOFINETUNE;
        curData->loopType    = 0;
        curData->amp        = 8;
        curData->panning    = 0;
        curData->relNote    = 0;
        // curData->name
        curData->data        = 0L;
    }

    return curData;
}

void MADPurgeTrack( MADDriverRec *intDriver)
{
    short    i;

    for( i=0; i<intDriver->DriverSettings.numChn; i++)
    {
    //    intDriver->chan[i].lastWord        = 0;
    //    intDriver->chan[i].curLevel        = 0;
        intDriver->chan[i].prevPtr        = 0;

        intDriver->chan[i].curPtr = intDriver->chan[i].maxPtr;
        intDriver->chan[i].samplePtr = 0L;
        intDriver->chan[i].lAC        = 0;
        intDriver->chan[i].loopBeg = 0;
        intDriver->chan[i].loopSize = 0;
    }
}

OSErr MADCleanCurrentMusic( MADMusic *MDriver, MADDriverRec *intDriver)
{
    if( MDriver->header != 0L)
    {
        short i, x;

        if( intDriver)
        {
            if( intDriver->Pat > MDriver->header->numPat) MADReset( intDriver);
            if( intDriver->PartitionReader > MDriver->partition[ intDriver->Pat]->header.size) MADReset( intDriver);
        }

        for( i = 0; i < MAXINSTRU; i++)
        {
            for( x = 0; x < 96; x++)
            {
                if( MDriver->header->fid[ i].what[ x])
                {
                    if( MDriver->header->fid[ i].what[ x] >= MDriver->header->fid[ i].numSamples)
                    {
                        MDriver->header->fid[ i].what[ x] = 0;
                    }
                }
            }

            for( x = 0; x < MDriver->header->fid[ i].numSamples; x++)
            {
                sData    *curData = MDriver->sample[ i][ x];

                if( curData == 0L)
                {
                    curData = MDriver->sample[ i][ x] = MADCreateSample();
                }

                if( curData->data == 0L)
                {
                    curData->data = NewPtr( 0);
                    curData->size = 0;
                }

                if( curData->size <= 0)
                {
                    curData->loopBeg = 0;
                    curData->loopSize = 0;
                }

                if( curData->loopSize < 0) curData->loopSize = 0;

                if( curData->loopBeg > curData->size)
                {
                    curData->loopBeg = 0;
                    curData->loopSize = 0;
                }

                if( curData->loopBeg + curData->loopSize > curData->size)
                {
                    curData->loopBeg = 0;
                    curData->loopSize = 0;
                }
            }
        }

    //    CheckInstrument();
    }

    return noErr;
}

OSErr MADKillInstrument( MADMusic *music, short ins)
{
short                i;
InstrData        *curIns;
Boolean            IsReading;

    if( music == 0L) return -1;

    curIns = &music->header->fid[ ins];

        IsReading = music->musicUnderModification;
        music->musicUnderModification = true;

    for( i = 0; i < curIns->numSamples; i++)
    {
        if( music->sample[ ins][ i] != 0L)
        {
            if( music->sample[ ins][ i]->data != 0L)
            {
                DisposePtr( (Ptr) music->sample[ ins][ i]->data);
                music->sample[ ins][ i]->data = 0L;
            }
            DisposePtr( (Ptr) music->sample[ ins][ i]);
            music->sample[ ins][ i] = 0L;
        }
    }


    for( i = 0; i < 32; i++) curIns->name[ i]    = 0;
    curIns->type        = 0;
    curIns->numSamples    = 0;

    /**/

    for( i = 0; i < 96; i++) curIns->what[ i]        = 0;
    for( i = 0; i < 12; i++)
    {
        curIns->volEnv[ i].pos        = 0;
        curIns->volEnv[ i].val        = 0;
    }
    for( i = 0; i < 12; i++)
    {
        curIns->pannEnv[ i].pos    = 0;
        curIns->pannEnv[ i].val    = 0;
    }
    curIns->volSize        = 0;
    curIns->pannSize    = 0;

    curIns->volSus        = 0;
    curIns->volBeg        = 0;
    curIns->volEnd        = 0;

    curIns->pannSus        = 0;
    curIns->pannBeg        = 0;
    curIns->pannEnd        = 0;

    curIns->volType        = 0;
    curIns->pannType    = 0;

    curIns->volFade        = DEFAULT_VOLFADE;
    curIns->vibDepth    = 0;
    curIns->vibRate        = 0;

        music->musicUnderModification = IsReading;


    return noErr;
}

OSErr MADKillCmd( Cmd    *aCmd)
{
    aCmd->cmd     = 0;
    aCmd->note     = 0xFF;
    aCmd->arg     = 0;
    aCmd->ins     = 0;
    aCmd->vol     = 0xFF;

    return noErr;
}

void MADCheckSpeed( MADMusic *MDriver, MADDriverRec *intDriver)
{
    short            i, x, y;
    short            curPartitionReader;
    Cmd                *aCmd;
    Boolean            CmdSpeed = false, FineFound = false;

    if( !MDriver) return;
    if( MDriver->header == 0L) return;
    if( !intDriver) return;

    for( i = intDriver->PL; i >= 0; i--)
    {
        if( i == intDriver->PL)
        {
            curPartitionReader = intDriver->PartitionReader;
            if( curPartitionReader >= MDriver->partition[ MDriver->header->oPointers[ i]]->header.size) curPartitionReader--;
        }
        else
        {
            curPartitionReader = MDriver->partition[ MDriver->header->oPointers[ i]]->header.size-1;
        }

        for( x = curPartitionReader; x >= 0; x--)
        {
            for( y = MDriver->header->numChn-1; y >= 0 ; y--)
            {
                aCmd = GetMADCommand( x, y, MDriver->partition[ MDriver->header->oPointers[ i]]);

                if( aCmd->cmd == speedE)
                {
                    if( aCmd->arg < 32)
                    {
                        if( aCmd->arg != 0)
                        {
                            if( CmdSpeed == false) intDriver->speed = aCmd->arg;
                            CmdSpeed = true;
                        }
                    }
                    else
                    {
                        if( aCmd->arg != 0)
                        {
                            if( FineFound == false) intDriver->finespeed = aCmd->arg;
                            FineFound = true;
                        }
                    }
                }
            }
            if( CmdSpeed == true && FineFound == true) return;
        }
    }


    if( !CmdSpeed)     intDriver->speed         = MDriver->header->speed;
    if( !FineFound) intDriver->finespeed     = MDriver->header->tempo;
}

OSErr MADPlayMusic( MADDriverRec *MDriver)
{
    if( !MDriver) return MADParametersErr;
    if( !MDriver->curMusic) return MADDriverHasNoMusic;

    MDriver->Reading = true;

    return noErr;
}

OSErr MADStopMusic( MADDriverRec *MDriver)
{
    if( !MDriver) return MADParametersErr;
    if( !MDriver->curMusic) return MADDriverHasNoMusic;

    MDriver->Reading = false;

    return noErr;
}

OSErr MADStartDriver( MADDriverRec *MDriver)
{
    MDriver->MADPlay = true;
    MDriver->Reading = false;
    MDriver->musicEnd = false;

    MADCleanDriver( MDriver);

    MADCheckSpeed( MDriver->curMusic, MDriver);

    switch( MDriver->DriverSettings.driverMode)
    {
        #ifdef _MAC_H
    case AWACSoundDriver:
    /*    if( (*(unsigned char *)AMICCodecStatus2 & kHeadphonesInserted))
        {
            curR1 = 0;
            curR1 |= kSpeakerMuteBit;
            WRITE_AWACS_REG_1;
        }*/


        CLEAR_SND_OUT_BUF_INTS;
        CLEAR_UNDERRUN_INT;
        ENABLE_BUF_AND_UNDERRUN_INTS;
        SND_OUT_DMA_ENABLE;
    break;

    case ASCSoundDriver:
    case MIDISoundDriver:
        VIAOn2();

        MDriver->VBL.VBL.vblCount = 1;
    break;

    case SoundManagerDriver:
        PlayChannel( MDriver);
    break;
    #endif
    }

    return( noErr);
}

OSErr MADStopDriver( MADDriverRec *MDriver)
{
    MDriver->MADPlay = false;

    switch( MDriver->DriverSettings.driverMode)
    {
    #ifdef _MAC_H
    case AWACSoundDriver:
        DISABLE_BUF_AND_UNDERRUN_INTS;
        SND_OUT_DMA_DISABLE;
        CLEAR_UNDERRUN_INT;
    break;

    case ASCSoundDriver:
    case MIDISoundDriver:
        MDriver->VBL.VBL.vblCount = 0;
        *((Byte*) SoundActive) = 0;
    break;

    case SoundManagerDriver:
        StopChannel( MDriver);
    break;
    #endif
    }

    MADCleanDriver( MDriver);

    return( noErr);
}

OSErr MADReset( MADDriverRec *MDriver)
{
    MADCleanDriver( MDriver);

    MDriver->BufCounter = 0;
    MDriver->BytesToGenerate = 0;
    MDriver->smallcounter = 128;

    MDriver->PL = 0;
    MDriver->PartitionReader = 0;

    if( MDriver->curMusic != 0L)
    {
        MDriver->Pat = MDriver->curMusic->header->oPointers[ MDriver->PL];
        MDriver->speed = MDriver->curMusic->header->speed;
        MDriver->finespeed = MDriver->curMusic->header->tempo;
    }

    return( noErr);
}

short MADGetNextReader( MADMusic *music, MADDriverRec *intDriver, short cur, short *pat)
{
    if( music == 0L) return 0;
    if( intDriver == 0L) return 0;
    if( music->header == 0L) return 0;

    cur++;
    if( cur >= music->partition[ intDriver->Pat]->header.size)
    {
        cur = 0;

        if( intDriver->JumpToNextPattern)
        {
            *pat = music->header->oPointers[ intDriver->PL + 1];

            if( intDriver->speed == 1 && intDriver->PL + 1 >= music->header->numPointers)
            {
                *pat = music->header->oPointers[ 0];
            }
        }
    }

    return cur;
}

OSErr MADDisposeMusic( MADMusic **music)
{
    short        x;

    if( !music) return noErr;
    if( !*music) return noErr;

//    if( (*music)->currentDriver != 0L)
    {
        (*music)->musicUnderModification = true;
    //    MADPurgeTrack(  (*music)->currentDriver);
    //    MADCleanDriver(  (*music)->currentDriver);

    //    MADDetachMusicFromDriver( *music);
    }

    if(  (*music)->header != 0L)
    {
        for( x = 0; x < (*music)->header->numPat ; x++)
        {
            if(  (*music)->partition[ x] != 0L) DisposePtr( (Ptr)  (*music)->partition[ x]);
             (*music)->partition[ x] = 0L;
        }

        for( x = (*music)->header->numPat; x < MAXPATTERN ; x++)
        {
            if(  (*music)->partition[ x] != 0L) DebugStr("\pMADDispose (*music) !");
        }

        for( x = 0; x < MAXINSTRU ; x++)
        {
            MADKillInstrument( *music, x);
        }

        DisposePtr( (Ptr) (*music)->header);
    }

    DisposePtr( (Ptr) *music);
     *music = 0L;

    return( noErr);
}

#if defined(powerc) || defined(__powerc)
#pragma options align=mac68k
#endif

#ifdef _MAC_H
OSErr MADPlaySndHandle( MADDriverRec *MDriver, Handle sound, long channel, long note)
{
    Ptr             soundPtr;
    short             soundFormat;
    short             numSynths, numCmds;
    long             offset;
    SoundHeaderPtr     header;
    CmpSoundHeader    *CmpHeader;
    ExtSoundHeader    *ExtHeader;
    long            i;

    OSType            Scomp;
    long            Ssize, Samp, SbaseFreq, Sc2spd, Sstart, Send;
    Ptr                rPtr;

    /* make the sound safe to use at interrupt time. */
    HLock( sound);

    soundPtr = *sound;

    /* determine what format sound we have. */
    soundFormat = *(short*)soundPtr;

    switch(soundFormat)
    {
        case 1:                        /* format 1 sound. */
            /* look inside the format 1 resource and deduce offsets. */
            numSynths = ((short*)soundPtr)[1];                    /* get # synths. */
            numCmds = *(short*)(soundPtr+4+numSynths*6);        /* get # commands. */
        break;

        case 2:                        /* format 2 sound. */
            numSynths = 0;            /* format 2 sounds have no synth's. */
            numCmds = ((short*)soundPtr)[2];
        break;

        default:                    /* jack says, what about 12? or 6? */
            HUnlock( sound);
            return MADUnknowErr;
        break;
    }

    /* compute address of sound header. */
    offset = 6 + 6*numSynths + 8*numCmds;
    header = (SoundHeaderPtr) (StripAddress(*sound) + offset);

    switch( header->encode)
    {
        case cmpSH:
            CmpHeader = (CmpSoundHeader*) header;
            if( CmpHeader->numChannels != 1)
            {
                HUnlock( sound);
                return MADUnknowErr;
            }

            Sstart        = CmpHeader->loopStart;
            Send        = CmpHeader->loopEnd;
            Samp        = CmpHeader->sampleSize;
            Sc2spd        = CmpHeader->sampleRate;
            SbaseFreq     = CmpHeader->baseFrequency;
            Ssize         = CmpHeader->numFrames;
            rPtr         = (Ptr) CmpHeader->sampleArea;
            Scomp        = CmpHeader->compressionID;
        break;

        case extSH:
            ExtHeader    = (ExtSoundHeader*) header;
            if( ExtHeader->numChannels != 1)
            {
                HUnlock( sound);
                return MADUnknowErr;
            }

            Sstart        = ExtHeader->loopStart;
            Send        = ExtHeader->loopEnd;
            Samp        = ExtHeader->sampleSize;
            Sc2spd        = ExtHeader->sampleRate;
            SbaseFreq     = ExtHeader->baseFrequency;
            Ssize         = ExtHeader->numFrames;
            rPtr         = (Ptr) ExtHeader->sampleArea;
            Scomp        = 'NONE';
        break;

        default:
        case stdSH:
            Sstart        = header->loopStart;
            Send        = header->loopEnd;
            if( header->encode == 0x40) Samp        = 0;
            else Samp        = 8;
            Sc2spd        = header->sampleRate;
            SbaseFreq     = header->baseFrequency;
            Ssize         = header->length;
            rPtr         = (Ptr) header->sampleArea;
            Scomp        = 'NONE';
        break;
    }

    if( Samp == 16)
    {
        Ssize     *= 2L;
        Sstart     *= 2L;
        Send     *= 2L;
    }
    else
    {
        if( Samp == 8)
        {
            for( i = 0; i < Ssize; i++) rPtr[ i] = rPtr[ i] - 0x80;

            switch( header->encode)
            {
                case extSH:
                    ExtHeader->sampleSize = 0;
                break;

                case cmpSH:
                    CmpHeader->sampleSize = 0;
                break;

                default:
                case stdSH:
                    header->encode = 0x40;
                break;
            }
        }
        Samp = 8;
    }

    Sc2spd = Sc2spd >> 16L;

    /*********************/
    if( channel < 0)                                    return MADParametersErr;
    if( channel >= MDriver->DriverSettings.numChn)    return MADParametersErr;

    if( note == 0xFF) note = 48;

    MDriver->chan[ channel].samplePtr        = rPtr;

    MDriver->chan[ channel].maxPtr     = MDriver->chan[ channel].curPtr = MDriver->chan[ channel].begPtr = rPtr;
    MDriver->chan[ channel].maxPtr     += Ssize-1;
    MDriver->chan[ channel].lAC        = 0;

    MDriver->chan[ channel].note        = note + (60 - SbaseFreq);
    MDriver->chan[ channel].period    = GetOldPeriod( MDriver->chan[ channel].note, Sc2spd, MDriver);

    MDriver->chan[ channel].ins        = 0;
    MDriver->chan[ channel].viboffset    = 0;
    MDriver->chan[ channel].amp        = Samp;
    MDriver->chan[ channel].fineTune    = Sc2spd;

    if( Send == Sstart || Send - Sstart < 3)
    {
        Send = 0;
        Sstart = 0;
    }

    MDriver->chan[ channel].loopBeg         = Sstart;
    MDriver->chan[ channel].loopSize         = Send - Sstart;

    if( MDriver->chan[ channel].loopSize > 0)
    {
        MDriver->chan[ channel].maxPtr     = (Ptr) ((long) MDriver->chan[ channel].begPtr + Send);
    }

    MDriver->chan[ channel].vol             = 64;
    MDriver->chan[ channel].volFade        = 32767;
    MDriver->chan[ channel].volEnv        = 64;
    MDriver->chan[ channel].KeyOn            = true;

    return noErr;
}
#endif

OSErr MADPlaySoundData( MADDriverRec *MDriver, Ptr soundPtr, long size, long channel, long note, long amplitude, long loopBeg, long loopSize, unsigned long rate)
{
    if( channel < 0)                                    return MADParametersErr;
    if( channel >= MDriver->DriverSettings.numChn)    return MADParametersErr;

    MDriver->chan[ channel].samplePtr        = soundPtr;

    MDriver->chan[ channel].maxPtr     = MDriver->chan[ channel].curPtr = MDriver->chan[ channel].begPtr = soundPtr;
    MDriver->chan[ channel].maxPtr     += size-1;
    MDriver->chan[ channel].lAC        = 0;

    if( note == 0xFF) note = 48;
    MDriver->chan[ channel].note        = note;
    MDriver->chan[ channel].ins        = 0;
    MDriver->chan[ channel].viboffset    = 0;
    MDriver->chan[ channel].amp        = amplitude;
    MDriver->chan[ channel].fineTune    = rate >> 16L;

    MDriver->chan[ channel].period    = GetOldPeriod( MDriver->chan[ channel].note, MDriver->chan[ channel].fineTune, MDriver);

    if( loopBeg > size)                     { loopBeg = 0; loopSize = 0;}
    if( loopBeg + loopSize > size)             { loopBeg = 0; loopSize = 0;}

    MDriver->chan[ channel].loopBeg         = loopBeg;
    MDriver->chan[ channel].loopSize         = loopSize;

    if( loopSize > 0)
    {
        MDriver->chan[ channel].maxPtr     = (Ptr) ((long) MDriver->chan[ channel].begPtr + loopBeg + loopSize);
    }

    MDriver->chan[ channel].vol             = 64;
    MDriver->chan[ channel].volFade        = 32767;
    MDriver->chan[ channel].volEnv        = 64;
    MDriver->chan[ channel].KeyOn            = true;

    return noErr;
}

Boolean    MADIsPressed( unsigned char* km2, unsigned short k)
{
    return( (Boolean) ((km2[k>>3] >> (k & 7)) & 1) );
}

#ifdef _MAC_H
OSErr MADPlaySoundDataSYNC( MADDriverRec *MDriver, Ptr soundPtr, long size, long channel, long note, long amplitude, long loopBeg, long loopSize, unsigned long rate)
{
    OSErr        iErr;
    Boolean        continueLoop;
    KeyMap        km;

    iErr = MADPlaySoundData( MDriver, soundPtr, size, channel, note, amplitude, 0, 0, rate);
    if( iErr != noErr)

    continueLoop = true;
    while( continueLoop)
    {
        GetKeys( km);

        if( MDriver->chan[ channel].samplePtr == 0L) continueLoop = false;
        if( MADIsPressed( (unsigned char*) km, 0x37) && MADIsPressed( (unsigned char*) km, 0x2F)) continueLoop = false;
        if( Button()) continueLoop = false;
    }

    if( MDriver->chan[ channel].samplePtr != 0L)
    {
        MDriver->chan[ channel].curPtr     = MDriver->chan[ channel].maxPtr;
        MDriver->chan[ channel].samplePtr = 0L;
        MDriver->chan[ channel].lAC        = 0;
        MDriver->chan[ channel].loopBeg     = 0;
        MDriver->chan[ channel].loopSize     = 0;
    }

    return noErr;
}
#endif

void MADKeyOFF( MADDriverRec *MDriver, short track)
{
    if( track == -1)
    {
        short i;

        for( i = 0; i < MAXTRACK; i++) MDriver->chan[ i].KeyOn = false;
    }
    else MDriver->chan[ track].KeyOn = false;
}


#if defined(powerc) || defined(__powerc)
#pragma options align=reset
#endif

Cmd* GetMADCommand( short PosX, short    TrackIdX, PatData*    tempMusicPat)
{
    if( PosX < 0) PosX = 0;
    else if( PosX >= tempMusicPat->header.size) PosX = tempMusicPat->header.size -1;

    return( &(tempMusicPat->Cmds[ (tempMusicPat->header.size * TrackIdX) + PosX]));
}

void ActiveDMA()
{
    SND_OUT_DMA_ENABLE;
}

void MADDisposeVolumeTable( MADDriverRec *intDriver)
{
    if( intDriver->DriverSettings.outPutMode == DeluxeStereoOutPut) MADKillOverShoot( intDriver);

    if( intDriver->Vol != 0L) DisposePtr( (Ptr) intDriver->Vol);
    intDriver->Vol = 0L;
}

OSErr MADCreateVolumeTable( MADDriverRec *intDriver)
{
long            i, x, xx, Tracks = intDriver->DriverSettings.numChn;
short            *tempInt, *interneVol;
Ptr                tempPtr;
OSErr            theErr;

    theErr = MADCreateMicroDelay( intDriver);            if( theErr != noErr) return theErr;

    switch( intDriver->DriverSettings.outPutMode)
    {
        case MonoOutPut:                                                break;
        case StereoOutPut:                Tracks /= 2;    break;
        case DeluxeStereoOutPut:    Tracks    = 1;    MADCreateOverShoot( intDriver);    break;
        case PolyPhonic:                    Tracks    = 1;    break;
        case MultiFiles:                    Tracks = 1;        break;
    }

    intDriver->Vol = MADNewPtr( ( 66L *  256L * intDriver->DriverSettings.outPutBits) / 8L, MLibrary);

    if( intDriver->DriverSettings.outPutBits == 16L)
    {
        interneVol = (short*) intDriver->Vol;

        for(i = 0; i <= 0x0040; i++)
        {
            for(x = 0; x <= 0xFF; x++)
            {
                long add =  x*2L + (long) ((i<<8L) *2L);

                tempInt = ( short*) (((long) interneVol) + add);

                xx = x;
                if( xx >= 0x80) xx -= 0xFF;

                *tempInt = ( xx * i * 4L) / ( Tracks);
            }
        }
    }
    else
    {
        for(i = 0; i <= 0x0040; i++)
        {
            for(x = 0; x <= 0xFF; x++)
            {
                tempPtr = (Ptr) (((long) intDriver->Vol) + (long) x + (long) (i<<8));

                xx = x;
                if( xx >= 0x80) xx -= 0xFF;

                *tempPtr = ( xx * i) / (Tracks * 64L);        // 0x80 +
            }
        }
    }

    return( noErr);
}

MADLibrary* MADGetMADLibraryPtr()
{
    return MLibrary;
}

void MADChangeTracks( MADDriverRec *MDriver, short newVal)
{
    Boolean    play = MDriver->MADPlay, reading = MDriver->Reading;

    MADStopDriver( MDriver);

    MDriver->DriverSettings.numChn = newVal;

    MADDisposeVolumeTable( MDriver);
    MADCreateVolumeTable( MDriver);

    MDriver->trackDiv = MDriver->DriverSettings.numChn;
    if( MDriver->DriverSettings.outPutMode == StereoOutPut) MDriver->trackDiv /= 2;

    if( play) MADStartDriver( MDriver);
    if( reading) MADPlayMusic( MDriver);
}

void UpdateTracksNumber( MADDriverRec *MDriver)
{
    if( MDriver->curMusic != 0L)
    {
        if( MDriver->curMusic->header != 0L)
        {
            if( MDriver->curMusic->header->numChn != MDriver->DriverSettings.numChn)
            {
                MADChangeTracks( MDriver, MDriver->curMusic->header->numChn);
            }
        }
    }
}

//#include "Math.h"

OSErr MADCreateVibrato( MADDriverRec *MDriver)
{
short            i, vibrato_table[ 64] =
    {
        0,50,100,149,196,241,284,325,362,396,426,452,473,490,502,510,512,
        510,502,490,473,452,426,396,362,325,284,241,196,149,100,50,0,-49,
        -99,-148,-195,-240,-283,-324,-361,-395,-425,-451,-472,-489,-501,
        -509,-511,-509,-501,-489,-472,-451,-425,-395,-361,-324,-283,-240,
        -195,-148,-99,-49
    };

    for( i = 0; i < 64; i++) MDriver->vibrato_table[ i] = vibrato_table[ i];

    return noErr;

/*
double            base, pitch;
short            i, j, k;

    for (j = -8; j < 8; j++)
    {
        k = j < 0 ? j + 16 : j;
        base = AMIGA_CLOCKFREQ2 / 440.0 / 4.0 / pow(2.0, j/96.0);

        for (i = 0; i < NUMBER_NOTES + 4; i++)
        {
                pitch = base / pow(2.0, (i+1) /12.0);
                pitchTable[ i][ k] = floor(pitch + 0.5);
        }
    }
*/
}

#ifdef _MAC_H

#define VIA 0x1D4

#if defined(powerc) || defined (__powerc) || defined( NO_ASM)
void VIAOn2()
{
    register    Ptr        VIAPtr = *(Ptr*) VIA, ASCBasePtr = *(Ptr*) ASCBase;

    BitSet( (Ptr) VIAPtr, 0);

    if( ASCBasePtr[ 0x801] == 0)
    {
        ASCBasePtr[ 0x801] = 0x01;
        ASCBasePtr[ 0x806] = 0xFF;
    }

    BitSet( &ASCBasePtr[ 0x802], 6);
}

void SndOff()
{
    Ptr        VIAPtr = *(Ptr*) VIA;

    BitSet( (Ptr) VIAPtr, 0);
    *((Byte*) SoundActive) = 0x05;
}

void SndOn()
{
    Ptr        VIAPtr = *(Ptr*) VIA;

    if( BitTst( (Ptr) VIAPtr, 0))
    {
        BitClr( (Ptr) VIAPtr, 0);
         *((Byte*) SoundActive) = 0x05;
    }
}
#else

void VIAOn2()
{
asm
{
        MOVEA.L VIA,A0
        BSET    #7,(A0)

        MOVE.L    ASCBase, A0
        TST.B    0x801(A0)
        BNE.S   @lcf_2
        MOVE.B    #01,     0x801(A0)
        MOVE.B    #0xFF,     0x806(A0)
@lcf_2    BSET    #1,        0x802(A0)
}
}

void SndOff()
{
asm
{
    MOVEA.L    VIA,A0
    BSET    #7,(A0)
    MOVE.B    #0x05, SoundActive
}
}

void SndOn()
{
asm
{        MOVEA.L VIA,A0
         BTST    #7,(A0)
         BEQ.S   @lcf_1
         BCLR    #7,(A0)
         MOVE.B    #0x05, SoundActive
@lcf_1
}
}
#endif
#endif

enum
{
    ins     = 1,
    note    = 2,
    cmd        = 4,
    argu    = 8,
    vol        = 16
};

PatData* DecompressPartitionMAD1( MADMusic *MDriver, PatData* myPat)
{
    PatData*                finalPtr;
    Byte                     *srcPtr;
    Cmd                        *myCmd;
    short                    maxCmd;
    Byte                    set;

    finalPtr = ( PatData*) MADNewPtr( sizeof( PatHeader) + myPat->header.size * MDriver->header->numChn * sizeof( Cmd), MLibrary);
    if( finalPtr == 0L) return 0L;

    BlockMoveData( myPat, finalPtr, sizeof( PatHeader));

    srcPtr = (Byte*) myPat->Cmds;
    myCmd = (Cmd*) finalPtr->Cmds;
    maxCmd = finalPtr->header.size * MDriver->header->numChn;

    /*** Decompression Routine ***/

    while( maxCmd != 0)
    {
        maxCmd--;

        MADKillCmd( myCmd);

        set = *srcPtr++;

        if( set & ins)    myCmd->ins = *srcPtr++;
        if( set & note)    myCmd->note = *srcPtr++;
        if( set & cmd)    myCmd->cmd = *srcPtr++;
        if( set & argu)    myCmd->arg = *srcPtr++;
        if( set & vol)    myCmd->vol = *srcPtr++;

        myCmd++;
    }

    return finalPtr;
}

PatData* CompressPartitionMAD1( MADMusic *MDriver, PatData* myPat)
{
    PatData*                finalPtr;
    Byte                     *dstPtr, *setByte;
    Cmd                        *myCmd;
    short                    maxCmd;
    long                    NewPtrSize;
    Byte                    set;

    finalPtr = ( PatData*) MADNewPtr( sizeof( PatHeader) + myPat->header.size * MDriver->header->numChn * 6L, MLibrary);
    if( finalPtr == 0L) DebugStr("\pCompressPartitionMAD1");

    BlockMoveData( myPat, finalPtr, sizeof( PatHeader));

    dstPtr = (Byte*) finalPtr->Cmds;
    myCmd = (Cmd*) myPat->Cmds;
    maxCmd = myPat->header.size * MDriver->header->numChn;

    /*** Compression Routine ***/

    set         = 0;
    NewPtrSize     = 0;

    while( maxCmd != 0)
    {
        maxCmd--;

        // Set byte
        set            = 0;
        setByte     = dstPtr;
        *dstPtr++     = 0x00;
        NewPtrSize++;
        ////////

        if( myCmd->ins > 0)
        {
            set += ins;
            *dstPtr++ = myCmd->ins;
            NewPtrSize++;
        }

        if( myCmd->note != 0xFF)
        {
            set += note;
            *dstPtr++ = myCmd->note;
            NewPtrSize++;
        }

        if( myCmd->cmd > 0)
        {
            set += cmd;
            *dstPtr++ = myCmd->cmd;
            NewPtrSize++;
        }

        if( myCmd->arg > 0)
        {
            set += argu;
            *dstPtr++ = myCmd->arg;
            NewPtrSize++;
        }

        if( myCmd->vol != 0xFF)
        {
            set += vol;
            *dstPtr++ = myCmd->vol;
            NewPtrSize++;
        }
        // Set byte
        *setByte = set;
        ////////

        myCmd++;
    }

    finalPtr->header.patBytes = NewPtrSize;

//    SetPtrSize( (Ptr) finalPtr, (long)(NewPtrSize + sizeof( PatHeader)));

    return finalPtr;
}


#ifdef _MAC_H
void DMAIntInstall( unsigned long refCon, Ptr handlerAddr, unsigned long vectorBit)
{
    Ptr        ExpandPtr = (Ptr) 0x02B6L;
    Ptr        dstPtr;

    dstPtr = *((Ptr*) ExpandPtr);
    dstPtr += 0x0210;
    dstPtr = *((Ptr*) dstPtr);

    *((long*)( 0x04L + (long) dstPtr + vectorBit*8L)) = (long) handlerAddr;
    *((long*)( 0x08L + (long) dstPtr + vectorBit*8L)) = refCon;
}

void DMAIntRemove( unsigned long vectorBit)
{
    Ptr        ExpandPtr = (Ptr) 0x02B6L;
    Ptr        dstPtr;

    dstPtr = *((Ptr*)ExpandPtr);
    dstPtr += 0x0210;
    dstPtr = *((Ptr*) dstPtr);

    *((long*)( 0x04L + (long) dstPtr + vectorBit*8L)) = (long) 0x0060;
    *((long*)( 0x08L + (long) dstPtr + vectorBit*8L)) = 0L;
}

static UniversalProcPtr        myInter;

void    InstallDMAVBL( MADDriverRec *MDriver)
{

    MDriver->VBL.VBL.qLink            = 0L;
    MDriver->VBL.VBL.qType            = 0L;
    MDriver->VBL.VBL.vblCount            = 0;
    MDriver->VBL.VBL.vblPhase            = 0;

    SET_RATE_44_1
    CLEAR_SND_OUT_BUF_INTS;

    #define         MyCallMode ( kPascalStackBased )

    myInter = NewRoutineDescriptor( (ProcPtr) DMAPlay, MyCallMode, kPowerPCISA);
    DMAIntInstall( (unsigned long) kAwacsSignature, (Ptr) myInter, hwAmicSOUT);
}

void    RemoveDMAVBL(void)
{
    DMAIntRemove( hwAmicSOUT);
    DisposeRoutineDescriptor( myInter);        myInter = 0L;
}


void    InstallMODVBL( MADDriverRec *MDriver)
{
//    THz             savedZone;

    MDriver->VBL.VBL.qLink        = 0L;        // VLBQueue
    MDriver->VBL.VBL.qType        = vType;

//    savedZone = GetZone();
//    SetZone( SystemZone());
    MDriver->VBL.VBL.vblAddr        = NewVBLProc( MODPlay);
//    SetZone( savedZone);

    MDriver->VBL.VBL.vblCount        = 0;
    MDriver->VBL.VBL.vblPhase        = 0;
    MDriver->VBL.VBLA5                    = (long) MDriver;

    InstallPersistentVBL( MDriver, &MDriver->VBL.VBL);
}

void    RemoveMODVBL( MADDriverRec *MDriver)
{
    OSErr    myErr;

    myErr = VRemove( (QElemPtr) &MDriver->VBL);

    if( MDriver->SysHeapPtr != 0L)
    {
        DisposeRoutineDescriptor( MDriver->VBL.VBL.vblAddr);

        DisposePtr( MDriver->SysHeapPtr);
        MDriver->SysHeapPtr = 0L;
    }
}

void InstallPersistentVBL( MADDriverRec *MDriver, VBLTask *theVBLRec)
{
    #define kJMPInstr     0x4EF9
    #define kJMPSize         6

    OSErr    myErr;
    Ptr        tempPtr;

    MDriver->SysHeapPtr = NewPtrSys( kJMPSize);
    if( MDriver->SysHeapPtr == 0L) DebugStr("\pNewPtrSys Error");

    *(short*) MDriver->SysHeapPtr = kJMPInstr;
    tempPtr = (Ptr) MDriver->SysHeapPtr + sizeof( short);

    *(ProcPtr*)tempPtr = (ProcPtr) theVBLRec->vblAddr;

    #if defined(powerc) || defined (__powerc)
    #else
    theVBLRec->vblAddr = (VBLUPP) ( MDriver->SysHeapPtr);
    #endif

    myErr = VInstall( (QElemPtr) theVBLRec);
    if( myErr) DebugStr("\pError in VInstall");
}
#endif