//
// DMStyle2.cpp : Further Implementation of CDMStyle
//
// Copyright (c) 1999-2001 Microsoft Corporation
//
// @doc EXTERNAL
//

#include "DMStyle.h"
#include "debug.h"

#include "..\shared\Validate.h"
#include "iostru.h"
#include "mgentrk.h"

struct FirstTimePair
{
    DWORD dwPart;
    MUSIC_TIME mtTime;
};

/////////////////////////////////////////////////////////////////////////////
// IDirectMusicStyle2

/*
@method:(EXTERNAL) HRESULT | IDirectMusicComposer | ComposeMelodyFromTemplate | Creates a sequence segment from a
style and a Melody template (containing a Melody Generation track, a Chord track, and an
optional Style track).  Clones the segment and adds a Sequence track containing melodic
information.

@rdesc Returns:

@flag S_OK | Success
@flag E_POINTER | One or both of <p pTempSeg> and <p ppSeqSeg> is an invalid pointer.
@flag E_INVALIDARG | <p pStyle> is NULL and there is no Style track.

@comm If <p pStyle> is non-NULL, it is used in composing the segment; if it is NULL,
a Style is retrieved from <p pTempSeg>'s Style track.
The length of the section segment is equal to the length of the template section
passed in.
*/

HRESULT CDMStyle::ComposeMelodyFromTemplate(
                    IDirectMusicStyle*          pStyle, // @parm The style from which to create the sequence segment.
                    IDirectMusicSegment*        pTempSeg, // @parm The template from which to create the sequence segment.
                    IDirectMusicSegment**       ppSeqSeg // @parm Returns the created sequence segment.
            )
{
    V_INAME(ComposeMelodyFromTemplate)

    V_PTR_WRITE_OPT(pStyle, 1);
    V_PTR_WRITE(pTempSeg, 1);
    V_PTRPTR_WRITE(ppSeqSeg);

    DWORD dwTrackGroup = 0xffffffff;
    BOOL fStyleFromTrack = FALSE;
    HRESULT hr = S_OK;
    IDirectMusicTrack* pPatternTrack = NULL;
    IDirectMusicTrack* pMelGenTrack = NULL;
    MUSIC_TIME mtLength = 0;
    hr = pTempSeg->GetLength(&mtLength);
    if (FAILED(hr)) goto ON_END;

    // get the MelGen track and its track group.
    hr = pTempSeg->GetTrack(CLSID_DirectMusicMelodyFormulationTrack, 0xffffffff, 0, &pMelGenTrack);
    if (S_OK != hr) goto ON_END;
    if (FAILED(pTempSeg->GetTrackGroup(pMelGenTrack, &dwTrackGroup)))
    {
        dwTrackGroup = 0xffffffff;
    }

    // Get the style (either use the passed-in style or get one from a style track)
    if (!pStyle)
    {
        if (FAILED(hr = GetStyle(pTempSeg, 0, dwTrackGroup, pStyle)))
        {
            hr = E_INVALIDARG;
            goto ON_END;
        }
        fStyleFromTrack = TRUE;
    }

    // Using style, and melgen track, create a pattern track
    hr = GenerateTrack(pTempSeg, NULL, dwTrackGroup, pStyle, pMelGenTrack, mtLength, pPatternTrack);
    if (SUCCEEDED(hr))
    {
        if (hr == S_FALSE)
        {
            if (pPatternTrack) pPatternTrack->Release();
            pPatternTrack = NULL;
        }
        HRESULT hrCopy = CopySegment(pTempSeg, pStyle, pPatternTrack, dwTrackGroup, ppSeqSeg);
        if (FAILED(hrCopy)) hr = hrCopy;
    }

ON_END:
    // release from Addref in GetTrack
    if (pMelGenTrack) pMelGenTrack->Release();
    // release from CoCreateInstance in CreatePatternTrack
    if (pPatternTrack) pPatternTrack->Release();
    // Release from Addref in GetStyle
    if (fStyleFromTrack) pStyle->Release();

    return hr;
}

HRESULT CDMStyle::GetStyle(IDirectMusicSegment* pFromSeg, MUSIC_TIME mt, DWORD dwTrackGroup, IDirectMusicStyle*& rpStyle)
{
    HRESULT hr = S_OK;
    // Get the segment's style track.
    IDirectMusicTrack* pStyleTrack;
    hr = pFromSeg->GetTrack(CLSID_DirectMusicStyleTrack, dwTrackGroup, 0, &pStyleTrack);
    if (S_OK != hr) return hr;
    // Get the style from the style track
    hr = pStyleTrack->GetParam(GUID_IDirectMusicStyle, mt, NULL, (void*) &rpStyle);
    pStyleTrack->Release();
    return hr;
}

HRESULT CDMStyle::CopySegment(IDirectMusicSegment* pTempSeg,
                              IDirectMusicStyle* pStyle,
                              IDirectMusicTrack* pPatternTrack,
                              DWORD dwTrackGroup,
                              IDirectMusicSegment** ppSectionSeg)
{
    if (!ppSectionSeg) return E_INVALIDARG;

    HRESULT                 hr                      = S_OK;
    long                    nClocks                 = 0;
    IDirectMusicTrack*      pIStyleTrack            = NULL;
    IDirectMusicTrack*      pDMTrack                = NULL;
    IDirectMusicTrack*      pBandTrack              = NULL;
    IDirectMusicBand*       pBand                   = NULL;

    DMUS_BAND_PARAM DMBandParam;
    pTempSeg->GetLength(&nClocks);
    /////////////////////////////////////////////////////////////
    // clone the template segment to get a section segment
    hr = pTempSeg->Clone(0, nClocks, ppSectionSeg);
    if (!SUCCEEDED(hr)) goto ON_END;
    // Extract the style's time signature.
    DMUS_TIMESIGNATURE TimeSig;
    pStyle->GetTimeSignature(&TimeSig);

    // Remove all style tracks from the new segment.
    do
    {
        hr = (*ppSectionSeg)->GetTrack(CLSID_DirectMusicStyleTrack, dwTrackGroup, 0, &pIStyleTrack);
        if (S_OK == hr)
        {
            (*ppSectionSeg)->RemoveTrack(pIStyleTrack);
            pIStyleTrack->Release();
            pIStyleTrack = NULL;
        }
    } while (S_OK == hr);

    // hr is no longer S_OK, so reset it.
    hr = S_OK;

    // if there's no tempo track in the template segment, create one and add it
    if (FAILED(pTempSeg->GetTrack(CLSID_DirectMusicTempoTrack, dwTrackGroup, 0, &pDMTrack)))
    {
        // Create a Tempo Track in which to store the tempo events
        DMUS_TEMPO_PARAM tempo;
        tempo.mtTime = 0;

        pStyle->GetTempo(&tempo.dblTempo);
        if( SUCCEEDED( CoCreateInstance( CLSID_DirectMusicTempoTrack,
            NULL, CLSCTX_INPROC, IID_IDirectMusicTrack,
            (void**)&pDMTrack )))
        {
            if ( SUCCEEDED(pDMTrack->SetParam(GUID_TempoParam, 0, &tempo)) )
            {
                (*ppSectionSeg)->InsertTrack( pDMTrack, dwTrackGroup );
            }
        }
    }
    // if there's no band track in the template segment, create one and add it
    if (FAILED(pTempSeg->GetTrack(CLSID_DirectMusicBandTrack, dwTrackGroup, 0, &pBandTrack)))
    {
        // Create band track
        hr = ::CoCreateInstance(
            CLSID_DirectMusicBandTrack,
            NULL,
            CLSCTX_INPROC,
            IID_IDirectMusicTrack,
            (void**)&pBandTrack
            );

        if(!SUCCEEDED(hr)) goto ON_END;

        // Load default band from style into track
        hr = pStyle->GetDefaultBand(&pBand);
        if (!SUCCEEDED(hr)) goto ON_END;
        DMBandParam.mtTimePhysical = -64;
        DMBandParam.pBand = pBand;
        hr = pBandTrack->SetParam(GUID_BandParam, 0, (void*)&DMBandParam);
        if (!SUCCEEDED(hr)) goto ON_END;
        (*ppSectionSeg)->InsertTrack(pBandTrack, dwTrackGroup);
    }

    // Add the pattern track
    if (pPatternTrack)
    {
        (*ppSectionSeg)->InsertTrack(pPatternTrack, dwTrackGroup);
    }

    // Initialize the segment
    (*ppSectionSeg)->SetRepeats(0);
    TraceI(4, "Segment Length: %d\n", nClocks);
    (*ppSectionSeg)->SetLength(nClocks);

ON_END:
    if (pDMTrack)
    {
        // This releases the Addref made either by GetTrack or (if GetTrack failed)
        // by CoCreateInstance
        pDMTrack->Release();
    }
    if (pBandTrack)
    {
        // This releases the Addref made either by GetTrack or (if GetTrack failed)
        // by CoCreateInstance
        pBandTrack->Release();
    }
    if (pIStyleTrack) pIStyleTrack->Release();
    if (pBand) pBand->Release();
    return hr;
}

HRESULT CDMStyle::GenerateTrack(IDirectMusicSegment* pTempSeg,
                                IDirectMusicSong* pSong,
                                DWORD dwTrackGroup,
                                IDirectMusicStyle* pStyle,
                                IDirectMusicTrack* pMelGenTrack,
                                MUSIC_TIME mtLength,
                                IDirectMusicTrack*& pNewTrack)
{
    if (!pStyle || !pMelGenTrack) return E_INVALIDARG;

    HRESULT hr = S_OK;

    // CoCreate the pattern track
    hr = ::CoCreateInstance(
        CLSID_DirectMusicPatternTrack,
        NULL,
        CLSCTX_INPROC,
        IID_IDirectMusicTrack,
        (void**)&pNewTrack
    );
    if (FAILED(hr)) return hr;

    // Get the Style's info struct
    IDMStyle* pDMStyle = NULL;
    hr = pStyle->QueryInterface(IID_IDMStyle, (void**) &pDMStyle);
    if (FAILED(hr)) return hr;
    DMStyleStruct* pStyleStruct = NULL;
    pDMStyle->GetStyleInfo((void**)&pStyleStruct);

    MUSIC_TIME mtNewFragment = 0;
    MUSIC_TIME mtNext = 0;
    MUSIC_TIME mtRealNextChord = 0;
    MUSIC_TIME mtNextChord = 0;
    MUSIC_TIME mtLaterChord = 0;
    DMUS_MELODY_FRAGMENT DMUS_Fragment;
    memset(&DMUS_Fragment, 0, sizeof(DMUS_Fragment));
    DMUS_CHORD_PARAM CurrentChord;
    DMUS_CHORD_PARAM RealCurrentChord;
    DMUS_CHORD_PARAM NextChord;
    CDirectMusicPattern* pPattern;
    TList<CompositionFragment> listFragments;
    TListItem<CompositionFragment>* pLastFragment = NULL;
    CompositionFragment CompRepeat;
    FirstTimePair* aFirstTimes = NULL;
    BYTE bPlaymode = 0;
    pMelGenTrack->GetParam(GUID_MelodyPlaymode, 0, NULL,  (void*)&bPlaymode);
    if (bPlaymode & DMUS_PLAYMODE_NONE)
    {
        bPlaymode = DMUS_PLAYMODE_ALWAYSPLAY;
    }
    // for each melody fragment:
    do
    {
        pLastFragment = listFragments.GetHead();
        // get the fragment
        HRESULT hrFragment = pMelGenTrack->GetParam(GUID_MelodyFragment, mtNewFragment, &mtNext, (void*)&DMUS_Fragment);
        if (FAILED(hrFragment)) break;
        MelodyFragment Fragment = DMUS_Fragment;
        if (mtNext) mtNewFragment += mtNext;
        else mtNewFragment = 0;

        // get its repeat
        MelodyFragment repeatFragment = Fragment;
        hr = pMelGenTrack->GetParam(GUID_MelodyFragmentRepeat, 0, NULL, (void*)&DMUS_Fragment);
        if (SUCCEEDED(hr))
        {
            repeatFragment = DMUS_Fragment;
        }
        else // failing to get a repeat just means this fragment doesn't repeat; composition can still continue
        {
            hr = S_OK;
        }

        // If the fragment repeats an earlier fragment, get the earlier fragment.
        // Regardless, get the fragment's pattern.
        ZeroMemory( &CompRepeat, sizeof(CompRepeat));
        if (SUCCEEDED(hrFragment) && Fragment.UsesRepeat())
        {
            TListItem<CompositionFragment>* pScan = listFragments.GetHead();
            for (; pScan; pScan = pScan->GetNext())
            {
                if (pScan->GetItemValue().GetID() == repeatFragment.GetID())
                {
                    CompRepeat = pScan->GetItemValue();
                }
            }
            pPattern = CompRepeat.m_pPattern;
        }
        else
        {
            Fragment.GetPattern(pStyleStruct, pPattern, pLastFragment);
        }
        // bail if we couldn't get a pattern
        if (!pPattern)
        {
            hr = DMUS_E_NOT_FOUND;
            break;
        }

        // get the pattern's partrefs
        TListItem<DirectMusicPartRef>* pPartRef = pPattern->m_PartRefList.GetHead();
        int nParts = pPattern->m_PartRefList.GetCount();

        // clear all inversion groups for the fragment
        Fragment.ClearInversionGroups();

        // get the starting chords for the fragment
        Fragment.GetChord(pTempSeg, pSong, dwTrackGroup, mtNextChord, CurrentChord, mtRealNextChord, RealCurrentChord);

        Fragment.GetChord(mtNextChord, pTempSeg, pSong, dwTrackGroup, mtLaterChord, NextChord);

        // initializations
        TListItem<CompositionFragment>* pFragmentItem = new TListItem<CompositionFragment>(Fragment);
        if (!pFragmentItem)
        {
            hr = E_OUTOFMEMORY;
            break;
        }
        CompositionFragment& rFragment = pFragmentItem->GetItemValue();
        hr = rFragment.Init(pPattern, pStyleStruct, nParts);
        if (FAILED(hr))
        {
            break;
        }
        if (aFirstTimes) delete [] aFirstTimes;
        aFirstTimes = new FirstTimePair[nParts];
        if (!aFirstTimes)
        {
            hr = E_OUTOFMEMORY;
            break;
        }

        // If we're repeating using transposition intervals:
        // go through each part, attempting to fit the repeated part to the constraints.
        // If this process fails for any part, abort the process.
        // If it succeeds for every part, we can skip everything else that follows.
        // (ASSUMPTION 1: constraints are pattern-wide, and so must be satisfied by every part)
        // (ASSUMPTION 2: different parts are allowed to transpose by different intervals)
        HRESULT hrSkipVariations = S_OK;
        if (Fragment.RepeatsWithConstraints()) // if repeating using transposition intervals
        {
            for (int i = 0; pPartRef != NULL; pPartRef = pPartRef->GetNext(), i++)
            {
                aFirstTimes[i].dwPart = pPartRef->GetItemValue().m_dwLogicalPartID;
                aFirstTimes[i].mtTime = 0;
                hrSkipVariations = Fragment.GetRepeatedEvents(CompRepeat,
                                                              CurrentChord,
                                                              RealCurrentChord,
                                                              bPlaymode,
                                                              i,
                                                              pPartRef->GetItemValue(),
                                                              pLastFragment,
                                                              aFirstTimes[i].mtTime,
                                                              rFragment.EventList(i));
                if (FAILED(hrSkipVariations)) break;
            }
        }
        else
        {
            hrSkipVariations = E_FAIL;
        }

        if (FAILED(hrSkipVariations))
        {
            // If we're repeating, make sure the repeat fragment actually has variations,
            // and is not itself repeating an earlier fragment.
            // (we don't need to get the pattern again; that will be the same for all repeats)
            CompositionFragment CompLast = CompRepeat;
            while (repeatFragment.UsesRepeat())
            {
                DWORD dwRepeatID = repeatFragment.GetRepeatID();
                ZeroMemory( &CompRepeat, sizeof(CompRepeat));
                TListItem<CompositionFragment>* pScan = listFragments.GetHead();
                for (; pScan; pScan = pScan->GetNext())
                {
                    if (pScan->GetItemValue().GetID() == dwRepeatID)
                    {
                        CompRepeat = pScan->GetItemValue();
                        repeatFragment = CompRepeat;
                        if (!CompLast.m_abVariations && CompRepeat.m_abVariations)
                        {
                            ZeroMemory( &CompLast, sizeof(CompLast));
                            CompLast = CompRepeat;
                        }
                    }
                }
            }

            // Get variations for the Fragment
            Fragment.GetVariations(rFragment, CompRepeat, CompLast, CurrentChord, NextChord, mtNextChord, pLastFragment);

            bool fNeedChord = false;

            // for each part in the pattern:
            for (int i = 0; pPartRef != NULL; pPartRef = pPartRef->GetNext(), i++)
            {
                // Clean up anything that might have happened with repeats
                rFragment.CleanupEvents(i);

                if (fNeedChord)
                {
                    Fragment.GetChord(pTempSeg, pSong, dwTrackGroup, mtNextChord, CurrentChord, mtRealNextChord, RealCurrentChord);
                    Fragment.GetChord(mtNextChord, pTempSeg, pSong, dwTrackGroup, mtLaterChord, NextChord);
                    fNeedChord = false;
                }

                DirectMusicPart* pPart = pPartRef->GetItemValue().m_pDMPart;
                DirectMusicTimeSig& TimeSig = rFragment.GetTimeSig(pPart);
                aFirstTimes[i].dwPart = pPartRef->GetItemValue().m_dwLogicalPartID;
                aFirstTimes[i].mtTime = 0;
                bool fFoundFirst = false;
                // for each note in the variation:
                CDirectMusicEventItem* pEvent = pPart->EventList.GetHead();
                for (; pEvent; pEvent = pEvent->GetNext())
                {
                    if ( pEvent->m_dwVariation & (1 << rFragment.m_abVariations[i]) )
                    {
                        TListItem<EventWrapper>* pEventItem = NULL;
                        // get the time (offset from the start of the track)
                        MUSIC_TIME mtNow = Fragment.GetTime() +
                            TimeSig.GridToClocks(pEvent->m_nGridStart) + pEvent->m_nTimeOffset;
                        // Make sure this doesn't overlap with the next fragment.
                        MUSIC_TIME mtDuration = 0;
                        switch (pEvent->m_dwEventTag)
                        {
                        case DMUS_EVENT_NOTE:
                            mtDuration = ((CDMStyleNote*)pEvent)->m_mtDuration;
                            break;
                        case DMUS_EVENT_CURVE:
                            mtDuration = ((CDMStyleCurve*)pEvent)->m_mtDuration;
                            break;
                        }
                        bool fAddToOverlap = false;
                        if ( !mtNewFragment || mtNow + mtDuration <= mtNewFragment )
                        {
                            if (pEvent->m_dwEventTag == DMUS_EVENT_ANTICIPATION)
                            {
                                fAddToOverlap = true;
                            }
                            else
                            {
                                // use proper chord for non-anticipated notes
                                if (mtRealNextChord != mtNextChord && mtNow >= mtRealNextChord)
                                {
                                    mtRealNextChord = mtNextChord;
                                    RealCurrentChord = CurrentChord;
                                }
                                // get a new chord if necessary
                                if (mtNextChord && mtNow >= mtNextChord)
                                {
                                    Fragment.GetChord(mtNow, pTempSeg, pSong, dwTrackGroup, mtNextChord, CurrentChord);
                                    mtRealNextChord = mtNextChord;
                                    RealCurrentChord = CurrentChord;
                                    fNeedChord = true;
                                }
                                // Convert the event to a wrapped event
                                hr = Fragment.GetEvent(pEvent, CurrentChord, RealCurrentChord, mtNow, pPartRef->GetItemValue(), pEventItem);
                                // Add the new event to a list of wrapped events.
                                if (hr == S_OK)
                                {
                                    rFragment.AddEvent(i, pEventItem);
                                }
                                if (!fFoundFirst || mtNow < aFirstTimes[i].mtTime)
                                {
                                    fFoundFirst = true;
                                    aFirstTimes[i].mtTime = mtNow;
                                }
                            }
                        }
                        // ignore anticipations that start after the next fragment
                        else if (pEvent->m_dwEventTag != DMUS_EVENT_ANTICIPATION)
                        {
                            fAddToOverlap = true;
                        }
                        if (fAddToOverlap)
                        {
                            TListItem<EventOverlap>* pOverlap = new TListItem<EventOverlap>;
                            if (pOverlap)
                            {
                                EventOverlap& rOverlap = pOverlap->GetItemValue();
                                rOverlap.m_PartRef = pPartRef->GetItemValue();
                                rOverlap.m_pEvent = pEvent;
                                rOverlap.m_mtTime = mtNow;
                                rOverlap.m_mtDuration = mtDuration;
                                rOverlap.m_Chord = CurrentChord;
                                rOverlap.m_RealChord = RealCurrentChord;
                                rFragment.AddOverlap(pOverlap);
                            }
                        }
                    }
                }
                if (!fFoundFirst) aFirstTimes[i].mtTime = mtNewFragment;
                // Sort the sequence items in reverse order, so that the last element is easy to find
                rFragment.SortEvents(i);
                        }
                // Clear this so the pointers it may reference aren't deleted twice.
                ZeroMemory( &CompLast, sizeof(CompLast));
        }
        listFragments.AddHead(pFragmentItem);
        // Go through the list of overlaps for the last fragment, adding any events that don't
        // actually overlap (and processing anticipations)
        // alg for processing anticipations:
        //   if the overlap list contains an anticipation for a part:
        //     find the first event in that part's fragment list
        //     make the start time of that event be the start time of the anticipation
        //     add to the duration of the event the difference between the event's start time
        //       and the anticipation's start time
        if (pLastFragment)
        {
            TListItem<EventWrapper>* pEventItem = NULL;
            CompositionFragment& rLastFragment = pLastFragment->GetItemValue();
            TListItem<EventOverlap>* pTupleItem;
            pTupleItem = rLastFragment.GetOverlapHead();
            for (; pTupleItem; pTupleItem = pTupleItem->GetNext() )
            {
                EventOverlap& rTuple = pTupleItem->GetItemValue();
                for (int i = 0; i < nParts; i++)
                {
                    if (rTuple.m_PartRef.m_dwLogicalPartID == aFirstTimes[i].dwPart) break;
                }
                if (i >= nParts ||
                    !aFirstTimes[i].mtTime ||
                    rTuple.m_mtTime < aFirstTimes[i].mtTime)
                {
                    if (rTuple.m_pEvent->m_dwEventTag == DMUS_EVENT_ANTICIPATION)
                    {
                        if (i < nParts && aFirstTimes[i].mtTime)
                        {
                            TListItem<EventWrapper>* pFirstNote = NULL;
                            TListItem<EventWrapper>* pScan = rFragment.GetEventHead(i);
                            // since the list is sorted in reverse order, the first note in
                            // the fragment will be the last one in the list.
                            for (; pScan; pScan = pScan->GetNext())
                            {
                                if (pScan->GetItemValue().m_pEvent->m_dwEventTag == DMUS_EVENT_NOTE)
                                {
                                    pFirstNote = pScan;
                                }
                            }
                            if (pFirstNote)
                            {
                                EventWrapper& rFirstNote = pFirstNote->GetItemValue();
                                CDMStyleNote* pNoteEvent = (CDMStyleNote*)rFirstNote.m_pEvent;
                                pNoteEvent->m_mtDuration += (rFirstNote.m_mtTime - rTuple.m_mtTime);
                                rFirstNote.m_mtTime = rTuple.m_mtTime;
                            }
                        }
                    }
                    else
                    {
                        hr = rLastFragment.GetEvent(rTuple.m_pEvent, rTuple.m_Chord, rTuple.m_RealChord, rTuple.m_mtTime, rTuple.m_PartRef, pEventItem);
                        if (i < nParts &&
                            aFirstTimes[i].mtTime &&
                            rTuple.m_mtTime + rTuple.m_mtDuration >= aFirstTimes[i].mtTime)
                        {
                            int nDiff = rTuple.m_mtTime + rTuple.m_mtDuration - aFirstTimes[i].mtTime;
                            if (pEventItem && pEventItem->GetItemValue().m_pEvent)
                            {
                                switch (pEventItem->GetItemValue().m_pEvent->m_dwEventTag)
                                {
                                case DMUS_EVENT_NOTE:
                                    ((CDMStyleNote*)pEventItem->GetItemValue().m_pEvent)->m_mtDuration -= nDiff;
                                    break;
                                case DMUS_EVENT_CURVE:
                                    ((CDMStyleCurve*)pEventItem->GetItemValue().m_pEvent)->m_mtDuration -= nDiff;
                                    break;
                                }
                            }
                        }
                        rLastFragment.InsertEvent(i, pEventItem);
                    }
                }
            }
        }
        // NOTE:  Need to apply transformations (invert, reverse...) here.
        // I should also move the individual sorts out of the overlapped notes code,
        // and put it directly preceding the transformations.

    } while (mtNext != 0);

    // Clear this so the pointers it may reference aren't deleted twice.
    ZeroMemory( &CompRepeat, sizeof(CompRepeat));

    // Once pattern tracks are introduced, I need to change this to create a pattern track.
    // I should allow an option to create one or the other (?).
    if (SUCCEEDED(hr))
    {
        hr = CreatePatternTrack(listFragments,
                                pStyleStruct->m_TimeSignature,
                                pStyleStruct->m_dblTempo,
                                mtLength,
                                bPlaymode,
                                pNewTrack);
    }

    if (aFirstTimes) delete [] aFirstTimes;

    pDMStyle->Release();
    return hr;
}

TListItem<DMUS_IO_SEQ_ITEM>* ConvertToSequenceEvent(TListItem<EventWrapper>* pEventItem)
{
    TListItem<DMUS_IO_SEQ_ITEM>* pResult = new TListItem<DMUS_IO_SEQ_ITEM>;
    if (pResult)
    {
        DMUS_IO_SEQ_ITEM& rSeq = pResult->GetItemValue();
        EventWrapper& rEvent = pEventItem->GetItemValue();
        rSeq.bStatus = 0x90;  // MIDI note on (with channel nibble stripped out)
        rSeq.mtTime = rEvent.m_mtTime;
        rSeq.bByte1 = rEvent.m_bMIDI;
        rSeq.dwPChannel = rEvent.m_dwPChannel;
        rSeq.nOffset = rEvent.m_pEvent->m_nTimeOffset;
        if (rEvent.m_pEvent)
        {
            switch (rEvent.m_pEvent->m_dwEventTag)
            {
            case DMUS_EVENT_NOTE:
                rSeq.mtDuration = ((CDMStyleNote*)rEvent.m_pEvent)->m_mtDuration;
                rSeq.bByte2 = ((CDMStyleNote*)rEvent.m_pEvent)->m_bVelocity;
                break;
            case DMUS_EVENT_CURVE:
                rSeq.mtDuration = ((CDMStyleCurve*)rEvent.m_pEvent)->m_mtDuration;
                rSeq.bByte2 = 0;  // Actually, curves shouldn't end up as note events...
                break;
            }
        }
    }
    return pResult;
}

HRESULT CDMStyle::CreateSequenceTrack(TList<CompositionFragment>& rlistFragments,
                                IDirectMusicTrack*& pSequenceTrack)
{
    HRESULT hr = S_OK;

    TList<DMUS_IO_SEQ_ITEM> SeqList;

    // fold all the individual event lists into one list
    TListItem<CompositionFragment>* pFragmentItem = rlistFragments.GetHead();
    for (; pFragmentItem; pFragmentItem = pFragmentItem->GetNext())
    {
        CompositionFragment& rFragment = pFragmentItem->GetItemValue();
        int nParts = rFragment.m_pPattern->m_PartRefList.GetCount();
        for (int i = 0; i < nParts; i++)
        {
            while (!rFragment.IsEmptyEvents(i))
            {
                TListItem<EventWrapper>* pHead = rFragment.RemoveEventHead(i);
                SeqList.AddHead(ConvertToSequenceEvent(pHead));
            }
        }
    }

    // Sort the sequence items
    SeqList.MergeSort(Less);

    // Now, persist the sequence events into the Sequence track
    IPersistStream* pIPSTrack = NULL;
    if( SUCCEEDED( pSequenceTrack->QueryInterface( IID_IPersistStream, (void**)&pIPSTrack )))
    {
        // Create a stream in which to place the events so we can
        // give it to the SeqTrack.Load.
        IStream* pEventStream;
        if( S_OK == CreateStreamOnHGlobal( NULL, TRUE, &pEventStream ) )
        {
            // Save the events into the stream
            TListItem<DMUS_IO_SEQ_ITEM>* pSeqItem = NULL;
            ULONG   cb, cbWritten;
            // Save the chunk id
            DWORD dwTemp = DMUS_FOURCC_SEQ_TRACK;
            pEventStream->Write( &dwTemp, sizeof(DWORD), NULL );
            // Save the overall size. Count the number of events to determine.
            DWORD dwSize = 0;
            for( pSeqItem = SeqList.GetHead(); pSeqItem; pSeqItem = pSeqItem->GetNext() )
            {
                dwSize++;
            }
            dwSize *= sizeof(DMUS_IO_SEQ_ITEM);
            // add 12 --- 8 for the subchunk header and overall size,
            // and 4 for the DMUS_IO_SEQ_ITEM size DWORD in the subchunk
            dwSize += 12;
            pEventStream->Write( &dwSize, sizeof(DWORD), NULL );
            // Save the subchunk id
            dwTemp = DMUS_FOURCC_SEQ_LIST;
            pEventStream->Write( &dwTemp, sizeof(DWORD), NULL );
            // Subtract the previously added 8 (for subchunk header and overall size)
            dwSize -= 8;
            // Save the size of the subchunk (including the DMUS_IO_SEQ_ITEM size DWORD)
            pEventStream->Write( &dwSize, sizeof(DWORD), NULL );
            // Save the structure size.
            dwTemp = sizeof(DMUS_IO_SEQ_ITEM);
            pEventStream->Write( &dwTemp, sizeof(DWORD), NULL );
            // Save the events.
            cb = sizeof(DMUS_IO_SEQ_ITEM);
            for( pSeqItem = SeqList.GetHead(); pSeqItem; pSeqItem = pSeqItem->GetNext() )
            {
                DMUS_IO_SEQ_ITEM& rSeqItem = pSeqItem->GetItemValue();
                pEventStream->Write( &rSeqItem, cb, &cbWritten );
                if( cb != cbWritten ) // error!
                {
                    pEventStream->Release();
                    pEventStream = NULL;
                    hr = DMUS_E_CANNOTREAD;
                    break;
                }
            }
            if( pEventStream ) // may be NULL
            {
                StreamSeek( pEventStream, 0, STREAM_SEEK_SET );
                pIPSTrack->Load( pEventStream );
                pEventStream->Release();
            }
        }
        pIPSTrack->Release();
    }

    return hr;
}

CDirectMusicEventItem* ConvertToPatternEvent(TListItem<EventWrapper>* pEventWrapper,
                                             DWORD dwID,
                                             BYTE bPlaymode,
                                             DirectMusicTimeSig& TimeSig)
{
    if (!pEventWrapper) return NULL;
    BYTE bEventPlaymode = pEventWrapper->GetItemValue().m_bPlaymode;
    if (bPlaymode == bEventPlaymode)
    {
        bEventPlaymode = DMUS_PLAYMODE_NONE;
    }
    CDirectMusicEventItem* pWrappedEvent = pEventWrapper->GetItemValue().m_pEvent;
    if (!pWrappedEvent) return NULL;
    MUSIC_TIME mtClocksPerGrid = TimeSig.ClocksPerGrid();
    short nGrid = 0;
    short nOffset = 0;
    if (mtClocksPerGrid)
    {
        nGrid = (short) (pEventWrapper->GetItemValue().m_mtTime / mtClocksPerGrid);
        nOffset = (short) (pWrappedEvent->m_nTimeOffset + pEventWrapper->GetItemValue().m_mtTime % mtClocksPerGrid);
    }
    DWORD dwVariations = 0xffffffff;
    BYTE bFlags = 0;
    if (pEventWrapper->GetItemValue().m_pEvent &&
        pEventWrapper->GetItemValue().m_pEvent->m_dwEventTag == DMUS_EVENT_NOTE)
    {
        bFlags = ((CDMStyleNote*)pEventWrapper->GetItemValue().m_pEvent)->m_bFlags;
    }
    return pWrappedEvent->ReviseEvent(nGrid, nOffset, &dwVariations, &dwID, &pEventWrapper->GetItemValue().m_wMusic, &bEventPlaymode, &bFlags);
}

HRESULT CDMStyle::CreatePatternTrack(TList<CompositionFragment>& rlistFragments,
                                     DirectMusicTimeSig& rTimeSig,
                                     double dblTempo,
                                     MUSIC_TIME mtLength,
                                     BYTE bPlaymode,
                                     IDirectMusicTrack*& pPatternTrack)
{
    HRESULT hr = S_OK;

    CDirectMusicPattern* pPattern = new CDirectMusicPattern(&rTimeSig);
    if (pPattern == NULL) return E_OUTOFMEMORY;

    pPattern->m_strName = "<Composed Pattern>";

    // fold all the individual event lists into corresponding parts in the pattern
    TListItem<CompositionFragment>* pFragmentItem = rlistFragments.GetHead();
    for (; pFragmentItem; pFragmentItem = pFragmentItem->GetNext())
    {
        CompositionFragment& rFragment = pFragmentItem->GetItemValue();
        TListItem<DirectMusicPartRef>* pPartRef = rFragment.m_pPattern->m_PartRefList.GetHead();
        int nParts = rFragment.m_pPattern->m_PartRefList.GetCount();
        for (int i = 0; i < nParts && pPartRef; i++, pPartRef = pPartRef->GetNext() )
        {
            DirectMusicPartRef& rPartRef = pPartRef->GetItemValue();
            TListItem<DirectMusicPartRef>* pNewPartRef = pPattern->CreatePart(rPartRef, bPlaymode);
            if (!pNewPartRef)
            {
                hr = E_OUTOFMEMORY;
                break;
            }
            DirectMusicPart* pPart = pNewPartRef->GetItemValue().m_pDMPart;
            if (!pPart)
            {
                hr = E_FAIL;
                break;
            }
            while (!rFragment.IsEmptyEvents(i))
            {
                TListItem<EventWrapper>* pHead = rFragment.RemoveEventHead(i);
                CDirectMusicEventItem* pNew = ConvertToPatternEvent(pHead, rFragment.GetID(), bPlaymode, rTimeSig);
                if (pNew)
                {
                    pPart->EventList.AddHead(pNew);
                }
                delete pHead;
            }
        }
        if (FAILED(hr)) break;
    }
    WORD wNumMeasures = 0;
    MUSIC_TIME mtClocksPerMeasure = rTimeSig.ClocksPerMeasure();
    if (mtClocksPerMeasure)
    {
        wNumMeasures = (WORD)(mtLength / mtClocksPerMeasure);
        if (mtLength % mtClocksPerMeasure)
        {
            wNumMeasures++;
        }
    }
    pPattern->m_wNumMeasures = wNumMeasures;
    pPattern->m_pRhythmMap = new DWORD[wNumMeasures];
    if (pPattern->m_pRhythmMap)
    {
        for (int i = 0; i < wNumMeasures; i++)
        {
            pPattern->m_pRhythmMap[i] = 0;
        }
    }
    else
    {
        hr = E_OUTOFMEMORY;
    }
    if (SUCCEEDED(hr))
    {
        TListItem<DirectMusicPartRef>* pPartRef = pPattern->m_PartRefList.GetHead();
        int nParts = pPattern->m_PartRefList.GetCount();
        // Sort the event lists for each part, and set the number of measures.
        for (int i = 0; i < nParts && pPartRef; i++, pPartRef = pPartRef->GetNext() )
        {
            DirectMusicPart* pPart = pPartRef->GetItemValue().m_pDMPart;
            if (pPart)
            {
                pPart->m_wNumMeasures = wNumMeasures;
                pPart->EventList.MergeSort(rTimeSig);
                // remove notes so close that they might as well be overlapping
                CDirectMusicEventItem* pThisEvent = pPart->EventList.GetHead();
                CDirectMusicEventItem* pLastEvent = NULL;
                for (; pThisEvent; pThisEvent = pThisEvent->GetNext())
                {
                    if (pThisEvent->m_dwEventTag == DMUS_EVENT_NOTE)
                    {
                        CDMStyleNote* pThisNote = (CDMStyleNote*)pThisEvent;
                        CDirectMusicEventItem* pNextEvent = pThisEvent->GetNext();
                        for (; pNextEvent; pNextEvent = pNextEvent->GetNext())
                        {
                            if (pNextEvent->m_dwEventTag == DMUS_EVENT_NOTE) break;
                        }
                        if (pNextEvent)
                        {
                            CDMStyleNote* pNextNote = (CDMStyleNote*)pNextEvent;
                            MUSIC_TIME mtThis = rTimeSig.GridToClocks(pThisNote->m_nGridStart) + pThisNote->m_nTimeOffset;
                            MUSIC_TIME mtNext = rTimeSig.GridToClocks(pNextNote->m_nGridStart) + pNextNote->m_nTimeOffset;
                            if ( (pNextNote->m_dwFragmentID != pThisNote->m_dwFragmentID) &&
                                 ((mtThis < mtNext && mtThis + OVERLAP_DELTA > mtNext) ||
                                  (mtThis > mtNext && mtThis + OVERLAP_DELTA < mtNext)) ) // could happen with negative offsets...
                            {
                                if (pLastEvent)
                                {
                                    pLastEvent->SetNext(pThisEvent->GetNext());
                                }
                                else // the note I want to remove is the first event
                                {
                                    pPart->EventList.RemoveHead();
                                }
                                pThisEvent->SetNext(NULL);
                                delete pThisEvent;
                                pThisEvent = pLastEvent;
                            }
                        }
                    }
                    pLastEvent = pThisEvent;
                }
            }
        }
        // Now, save the newly created pattern to a pattern track
        IPersistStream* pIPSTrack = NULL;
        IAARIFFStream* pIRiffStream;
        MMCKINFO ckMain;
        if( SUCCEEDED( pPatternTrack->QueryInterface( IID_IPersistStream, (void**)&pIPSTrack )))
        {
            // Create a stream in which to place the events so we can
            // give it to the PatternTrack.Load.
            IStream* pEventStream;
            if( S_OK == CreateStreamOnHGlobal( NULL, TRUE, &pEventStream ) )
            {
                if( SUCCEEDED( AllocRIFFStream( pEventStream, &pIRiffStream ) ) )
                {
                    ckMain.fccType = DMUS_FOURCC_PATTERN_FORM;
                    if( pIRiffStream->CreateChunk( &ckMain, MMIO_CREATERIFF ) == 0 )
                    {
                        MMCKINFO ckHeader;
                        ckHeader.ckid = DMUS_FOURCC_STYLE_CHUNK;
                        if( pIRiffStream->CreateChunk( &ckHeader, 0 ) != 0 )
                        {
                            hr = E_FAIL;
                        }
                        if (SUCCEEDED(hr))
                        {
                            // Prepare DMUS_IO_STYLE
                            DMUS_IO_STYLE oDMStyle;
                            DWORD dwBytesWritten = 0;
                            memset( &oDMStyle, 0, sizeof(DMUS_IO_STYLE) );
                            oDMStyle.timeSig.bBeatsPerMeasure = rTimeSig.m_bBeatsPerMeasure;
                            oDMStyle.timeSig.bBeat = rTimeSig.m_bBeat;
                            oDMStyle.timeSig.wGridsPerBeat = rTimeSig.m_wGridsPerBeat;
                            oDMStyle.dblTempo = dblTempo;
                            // Write chunk data
                            hr = pEventStream->Write( &oDMStyle, sizeof(DMUS_IO_STYLE), &dwBytesWritten);
                            if( FAILED( hr ) ||  dwBytesWritten != sizeof(DMUS_IO_STYLE) )
                            {
                                hr = E_FAIL;
                            }

                            if( SUCCEEDED(hr) && pIRiffStream->Ascend( &ckHeader, 0 ) != 0 )
                            {
                                hr = E_FAIL;
                            }
                        }

                        if ( SUCCEEDED(hr) )
                        {
                            hr = pPattern->Save( pEventStream );
                            pPartRef = pPattern->m_PartRefList.GetHead();
                            for (; pPartRef; pPartRef = pPartRef->GetNext())
                            {
                                if (pPartRef->GetItemValue().m_pDMPart)
                                {
                                    delete pPartRef->GetItemValue().m_pDMPart;
                                    pPartRef->GetItemValue().m_pDMPart = NULL;
                                }
                            }
                            pPattern->CleanUp();
                            delete pPattern;
                            if ( SUCCEEDED( hr ) && pIRiffStream->Ascend( &ckMain, 0 ) != 0 )
                            {
                                hr = E_FAIL;
                            }
                        }
                    }
                    pIRiffStream->Release();
                }
                if( SUCCEEDED(hr) )
                {
                    StreamSeek( pEventStream, 0, STREAM_SEEK_SET );
                    pIPSTrack->Load( pEventStream );
                }
                pEventStream->Release();
            }
            pIPSTrack->Release();
        }
    }

    if (hr == S_OK && !rlistFragments.GetHead()) hr = S_FALSE;
    return hr;
}