QuickTime 2.0 Developer Kit/QuickTime 2.0 Developer Kit.iso/mac/MAC/Programming Stuff/Sample Code/Music Architecture/Embedding Instruments/MusicHelper.c

C/C++ Source or Header | 1994-12-06 | 7.7 KB | 425 lines | [TEXT/KAHL]

#include <types.h>
#include <QuickTimeComponents.h>

#define _MusicHelperC_



#define kFullVolume 256

typedef struct
    {
    short partCount;
    ToneDescription **toneDescriptions;
    FlatInstrument ***flatInstruments;

    long tuneSize;
    long tuneHandleSize;
    unsigned long **tune;
    } MusicScoreRecord, **MusicScore;



typedef struct
    {
    Movie mo;
    Track tr;
    Media me;

    MusicDescriptionHandle mdH;
    TimeValue duration;
    short refNum;
    } MusicMovieRecord, **MusicMovie;


#include "MusicHelper.h"


#define kTuneHandleBump 1024



static void StuffToneDescription(short gmNumber,ToneDescription *td);
static void BumpTuneHandleSize(MusicScoreRecord *msr);
static short InternalAddPart(MusicScore ms,ToneDescription *td,FlatInstrument *flat);


#define hLock(x) HLock((Handle)(x))
#define hUnlock(x) HUnlock((Handle)(x))

MusicScore NewMusicScore(void)
    {
    MusicScoreRecord *msr;
    MusicScore ms;

    ms = (MusicScore)NewHandle(sizeof(MusicScoreRecord));
    hLock(ms);
    msr = *ms;
    msr->partCount= 0;
    msr->toneDescriptions = (ToneDescription **)NewHandle(0);
    msr->flatInstruments = (FlatInstrument ***)NewHandle(0);
    msr->tuneSize = 0;
    msr->tuneHandleSize = kTuneHandleBump;
    msr->tune = (unsigned long**)NewHandle(kTuneHandleBump * sizeof(long));
    hUnlock(ms);

    return ms;
    }


void DisposeMusicScore(MusicScore *ms)
    {
    MusicScoreRecord *msr;

    hLock(*ms);
    msr = **ms;
    DisposeHandle((Handle)msr->toneDescriptions);
    DisposeHandle((Handle)msr->tune);
    *ms = nil;
    }

short AddMusicScoreGMInstrument(MusicScore ms,short gmInstrument)
    {
    ToneDescription td;

    StuffToneDescription(gmInstrument,&td);
    return AddMusicScoreInstrument(ms,&td);
    }

short AddMusicScoreInstrument(MusicScore ms,ToneDescription *td)
    {
    return InternalAddPart(ms,td,nil);
    }


short AddMusicScoreFlatInstrument(MusicScore ms,FlatInstrument *flat)
    {
    return InternalAddPart(ms,&flat->tone,flat);
    }




short InternalAddPart(MusicScore ms,ToneDescription *td,FlatInstrument *flat)
    {
    MusicScoreRecord *msr;

    hLock(ms);
    msr = *ms;
    msr->partCount++;
    SetHandleSize((Handle)msr->toneDescriptions,msr->partCount * sizeof(ToneDescription));
    SetHandleSize((Handle)msr->flatInstruments,msr->partCount * sizeof(FlatInstrument *));
    (*msr->toneDescriptions)[msr->partCount-1] = *td;
    (*msr->flatInstruments)[msr->partCount-1] = flat;
    hUnlock(ms);
    return msr->partCount;
    }







void AddMusicScoreNote(MusicScore ms,short part,Fixed pitch,long velocity,TimeValue noteDuration)
    {
    MusicScoreRecord *msr;
    unsigned long *w;

    hLock(ms);
    msr = *ms;

    part--;

    BumpTuneHandleSize(msr);

    HLock((Handle)msr->tune);
    w = *(msr->tune) + msr->tuneSize;

    if(pitch >= 32 && pitch <= 95 && part < 32
            && noteDuration < 2048)
        {
        _StuffNoteEvent(*w,part,pitch,velocity,noteDuration);
        msr->tuneSize ++;
        }
    else
        {
        _StuffXNoteEvent(*w,*(w+1),part,pitch,velocity,noteDuration);
        msr->tuneSize += 2;
        }

    hUnlock(msr->tune);
    hUnlock(ms);
    }

void AddMusicScoreRest(MusicScore ms,TimeValue restDuration)
    {
    MusicScoreRecord *msr;
    unsigned long *w;

    hLock(ms);
    msr = *ms;

    BumpTuneHandleSize(msr);

    HLock((Handle)msr->tune);
    w = *(msr->tune) + msr->tuneSize;

    _StuffRestEvent(*w,restDuration);
    msr->tuneSize ++;

    hUnlock(msr->tune);
    hUnlock(ms);
    }

#define kNoteRequestMessageSize sizeof(NoteRequest)/4 + 2


Handle GetMusicScoreHeader(MusicScore ms)
    {
    Handle h;
    unsigned long *w;
    long size;
    NoteRequest *nr;
    FlatInstrument *flat;
    MusicScoreRecord *msr;
    int i;

    hLock(ms);
    msr = *ms;

    size = msr->partCount*(8 + sizeof(NoteRequest))
            + 4; /* 8 bytes for general music message,
                        + 4 for end marker */

    for(i = 0; i < msr->partCount; i++)
        {
        flat = (*msr->flatInstruments)[i];
        if(flat)
            size += flat->size;
        }


    h = NewHandleClear(size);
    w = (unsigned long *)*h;

    for(i = 0; i < msr->partCount; i++)
        {
        flat = (*msr->flatInstruments)[i];
        if(flat)
            {
            size = kNoteRequestMessageSize + (flat->size + 3)/4;
            _StuffGeneralEvent(*w,*(w + size - 1),
                    i,kGeneralEventFlatInstrument,size);
            nr = (NoteRequest *)(w + 1);

            nr->polyphony = 1;
            nr->typicalPolyphony = 0x10000;

            nr->tone = (*msr->toneDescriptions)[i];
            BlockMove(&flat->size,((char *)&nr->tone) + sizeof(ToneDescription),flat->size);

            w += size;
            }
        else
            {
            _StuffGeneralEvent(*w,*(w + kNoteRequestMessageSize - 1),
                    i,kGeneralEventNoteRequest,kNoteRequestMessageSize);
            nr = (NoteRequest *)(w + 1);

            nr->polyphony = 1;
            nr->typicalPolyphony = 0x10000;

            nr->tone = (*msr->toneDescriptions)[i];

            w += kNoteRequestMessageSize;
            }
        }

    *w++ = 0x60000000;                        /* end marker */

    hUnlock(ms);

    return h;
    }

Handle GetMusicScoreScore(MusicScore ms)
    {
    Handle h;
    MusicScoreRecord *msr;
    unsigned long *w;
    long size;

    hLock(ms);
    msr = *ms;

    size = msr->tuneSize * sizeof(unsigned long) + 4;

    msr = *ms;
    h = NewHandle(size);
    BlockMove(*msr->tune, *h, size);
    (*(unsigned long **)h)[msr->tuneSize] = 0x60000000;

    hUnlock(ms);

    return h;
    }



void StuffToneDescription(short gmNumber,ToneDescription *td)
    {
    ComponentResult result;
    NoteAllocator na;


    na = OpenDefaultComponent('nota',0);
    if(na)
        {
        NAStuffToneDescription(na,gmNumber,td);
        CloseComponent(na);
        }
    else
        {
        td->synthesizerType = 0;
        td->synthesizerName[0] = 0;
        td->instrumentName[0] = 0;
        td->instrumentNumber = 0;
        td->gmNumber = gmNumber;
        }
    }

#define kTuneSizeMargin 16

void BumpTuneHandleSize(MusicScoreRecord *msr)
    {
    if(msr->tuneHandleSize - msr->tuneSize < kTuneSizeMargin)
        {
        msr->tuneHandleSize += kTuneHandleBump;
        SetHandleSize((Handle)msr->tune,msr->tuneHandleSize * sizeof(unsigned long));
        }
    }












MusicMovie StartMusicMovie(FSSpec *movieSpec,Handle header)
    {
    MusicMovie mm;
    MusicMovieRecord *mmr;
    ComponentResult thisError;
    unsigned long size;

    EnterMovies();

    mm = (MusicMovie)NewHandle(sizeof(MusicMovieRecord));
    hLock(mm);
    mmr = *mm;

    thisError = CreateMovieFile(movieSpec,'TVOD',0,
             createMovieFileDeleteCurFile,
             &mmr->refNum,
             &mmr->mo);
     SetMoviePreferredVolume(mmr->mo,kFullVolume);
     SetMovieVolume(mmr->mo,kFullVolume);
    mmr->tr = NewMovieTrack(mmr->mo,0,0,kFullVolume);
    mmr->me = NewTrackMedia(mmr->tr,kMusicComponentType,600,0,0);
    thisError = GetMoviesError();

    size = sizeof(MusicDescription) + GetHandleSize(header);

    mmr->mdH = (void *)NewHandleClear(size);
// ••• ???    (**mmr->mdH).size = size;
// ••• ???    (**mmr->mdH).type = 'musi';
    BlockMove(*header,&(**mmr->mdH).headerData,GetHandleSize(header));

    mmr->duration = 0;

    thisError = BeginMediaEdits(mmr->me);

    hUnlock(mm);

    return mm;
    }


void AddMusicMovieSample(MusicMovie mm,Handle score)
    {
    MusicMovieRecord *mmr;
    ComponentResult thisError;
    TimeValue sampleDuration;
    unsigned long sampleLength;

    hLock(mm);
    mmr = *mm;

    // • Compute duration of tune
        {
        unsigned long *start,*w,*end;
        unsigned long eventType,eventLength;
        unsigned long x;

        start = (unsigned long *)*score;
        end = (unsigned long *)( ((char *)*score) + GetHandleSize(score));

        w = start;
        sampleDuration = 0;
        while(w < end)
            {
            x = *w;
            eventLength = _EventLength(x);
            eventType = _EventType(x);
            if(eventType == kRestEventType)
                sampleDuration += _RestDuration(x);
            if(eventLength < 1 || eventLength > 1000)
                goto done;
            w += eventLength;
            }
done:
        sampleLength = (w - start) * sizeof(unsigned long);
        }

    thisError = AddMediaSample(mmr->me,score,0,sampleLength,
            sampleDuration,(void *)mmr->mdH,
            1,0,0);

    mmr->duration += sampleDuration;

    hUnlock(mm);
    }



void FinishMusicMovie(MusicMovie *mm)
    {
    MusicMovieRecord *mmr;
    ComponentResult thisError;

    hLock(*mm);
    mmr = **mm;

    thisError = InsertMediaIntoTrack(mmr->tr,0,0,mmr->duration,(1L<<16));
    thisError = EndMediaEdits(mmr->me);

     thisError = AddMovieResource(mmr->mo,mmr->refNum,nil,nil);
    thisError = CloseMovieFile(mmr->refNum);

    DisposeHandle((Handle)*mm);
    *mm = 0;

    ExitMovies();
    }