windows-server-2003/multimedia/directx/dmusic/dmstyle/dmsect.cpp

//+-------------------------------------------------------------------------
//
//  Copyright (c) 1998-2001 Microsoft Corporation
//
//  File:       dmsect.cpp
//
//--------------------------------------------------------------------------

// DMSection.cpp : Implementation of CDMSection
#include "DMSect.h"
#include "DMStyle.h"
#include <initguid.h>
#include "debug.h"
#include "..\dmloader\ima.h"
#include "..\shared\Validate.h"

HRESULT CDMSection::GetDescriptor(LPDMUS_OBJECTDESC pDesc)
{
    return S_OK;
}

HRESULT CDMSection::SetDescriptor(LPDMUS_OBJECTDESC pDesc)
{
    return S_OK;
}

HRESULT CDMSection::ParseDescriptor(LPSTREAM pStream, LPDMUS_OBJECTDESC pDesc)
{
    return S_OK;
}

STDMETHODIMP CDMSection::QueryInterface(
    const IID &iid,
    void **ppv)
{
    V_INAME(CDMSection::QueryInterface);
    V_REFGUID(iid);
    V_PTRPTR_WRITE(ppv);

    if (iid == IID_IUnknown || iid == IID_IDMSection)
    {
        *ppv = static_cast<IDMSection*>(this);
    }
    else if (iid == IID_IPersistStream)
    {
        *ppv = static_cast<IPersistStream*>(this);
    }
    else if (iid == IID_IDirectMusicObject)
    {
        *ppv = static_cast<IDirectMusicObject*>(this);
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    reinterpret_cast<IUnknown*>(this)->AddRef();
    return S_OK;
}


STDMETHODIMP_(ULONG) CDMSection::AddRef()
{
    return InterlockedIncrement(&m_cRef);
}


STDMETHODIMP_(ULONG) CDMSection::Release()
{
    if (!InterlockedDecrement(&m_cRef))
    {
        delete this;
        return 0;
    }

    return m_cRef;
}


/////////////////////////////////////////////////////////////////////////////
// CDMSection

STDMETHODIMP CDMSection::GetStyle(IUnknown * * ppStyle)
{
    HRESULT hr;
    if (m_pStyle)
    {
        IUnknown* pIU = NULL;
        hr = m_pStyle->QueryInterface(IID_IUnknown, (void**)&pIU);
        if (SUCCEEDED(hr))
        {
            *ppStyle = pIU;
            pIU->Release();
            hr = S_OK;
        }
    }
    else
        hr = E_FAIL;
    return hr;
}

STDMETHODIMP CDMSection::CreateSegment(IDirectMusicSegment* pISegment)
{
    HRESULT                    hr                        = S_OK;
    IDirectMusicTrack*        pIStyleTrack            = NULL;
    IDirectMusicTrack*        pICommandTrack            = NULL;
    IDirectMusicTrack*        pIChordTrack            = NULL;
    IDirectMusicTrack*        pBandTrack                = NULL;
    IDirectMusicTrack*        pDMTrack                = NULL;
    IAARIFFStream*            pCommandRIFF            = NULL;
    IAARIFFStream*            pChordRIFF                = NULL;
    IStream*                pICommandStream            = NULL;
    IStream*                pIChordStream            = NULL;
    IPersistStream*            pICommandTrackStream    = NULL;
    IPersistStream*            pIChordTrackStream        = NULL;
    IStyleTrack*            pS                        = NULL;
    IUnknown*                pU                        = NULL;
    DMUS_BAND_PARAM            DMBandParam;

    // 1. Create Style, Command, and Chord Tracks.
    hr = ::CoCreateInstance(
        CLSID_DirectMusicStyleTrack,
        NULL,
        CLSCTX_INPROC,
        IID_IDirectMusicTrack,
        (void**)&pIStyleTrack
        );
    if (FAILED(hr)) goto ON_END;
    hr = ::CoCreateInstance(
        CLSID_DirectMusicCommandTrack,
        NULL,
        CLSCTX_INPROC,
        IID_IDirectMusicTrack,
        (void**)&pICommandTrack
        );
    if (FAILED(hr)) goto ON_END;
    hr = ::CoCreateInstance(
        CLSID_DirectMusicChordTrack,
        NULL,
        CLSCTX_INPROC,
        IID_IDirectMusicTrack,
        (void**)&pIChordTrack
        );
    if (FAILED(hr)) goto ON_END;
    hr = ::CoCreateInstance(
        CLSID_DirectMusicBandTrack,
        NULL,
        CLSCTX_INPROC,
        IID_IDirectMusicTrack,
        (void**)&pBandTrack
        );
    if (FAILED(hr)) goto ON_END;

    // 2/3. Use the section's style create a style track.
    hr = m_pStyle->QueryInterface(IID_IUnknown, (void**)&pU);
    if (FAILED(hr)) goto ON_END;
    hr = pIStyleTrack->QueryInterface(IID_IStyleTrack, (void**)&pS);
    if (FAILED(hr)) goto ON_END;
    pS->SetTrack(pU);
    m_pStyle->AddRef(); // Whenever I create a track from a style, I need to addref the style
    // 4. Write the section's command list out to a stream.
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pICommandStream);
    if (FAILED(hr)) goto ON_END;
    hr = AllocRIFFStream( pICommandStream, &pCommandRIFF);
    if (FAILED(hr)) goto ON_END;
    SaveCommandList(pCommandRIFF);
    // 5. Write the section's chord list out to a stream.
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pIChordStream);
    if (S_OK != hr) goto ON_END;
    hr = AllocRIFFStream( pIChordStream, &pChordRIFF);
    if (FAILED(hr)) goto ON_END;
    SaveChordList(pChordRIFF);
    // 6. Use the command list stream as input to the Command Track's Load method.
    hr = pICommandTrack->QueryInterface(IID_IPersistStream, (void**)&pICommandTrackStream);
    if (FAILED(hr)) goto ON_END;
    StreamSeek(pICommandStream, 0, STREAM_SEEK_SET);
    hr = pICommandTrackStream->Load(pICommandStream);
    if (FAILED(hr)) goto ON_END;
    // 7a. Use the chord list stream as input to the Chord Track's Load method.
    hr = pIChordTrack->QueryInterface(IID_IPersistStream, (void**)&pIChordTrackStream);
    if (FAILED(hr)) goto ON_END;
    StreamSeek(pIChordStream, 0, STREAM_SEEK_SET);
    hr = pIChordTrackStream->Load(pIChordStream);
    if(FAILED(hr)) goto ON_END;
    // 7b. Load band into band track
    DMBandParam.mtTimePhysical = -64;
    DMBandParam.pBand = m_pIDMBand;
    hr = pBandTrack->SetParam(GUID_BandParam, 0, (void*)&DMBandParam);
    if (FAILED(hr)) goto ON_END;

    // 8. Create a Segment has been removed it is now passed in

    // 9. Initialize the segment appropriately.
    pISegment->SetRepeats(m_wRepeats);
    pISegment->SetDefaultResolution((DWORD)m_wClocksPerBeat);
    pISegment->SetLength(m_dwClockLength); // need the length of the section!
    /////////////////////////////////////////////////////////////////
    DMUS_TEMPO_PARAM tempo;
    tempo.mtTime = 0; // ConvertTime( dwTime );
    tempo.dblTempo = (double) m_wTempo; // ((double)dw) / 64;
    /////////////////////////////////////////////////////////////////
    hr = S_OK;
    // Create a Tempo Track in which to store the tempo events
    if( SUCCEEDED( CoCreateInstance( CLSID_DirectMusicTempoTrack,
        NULL, CLSCTX_INPROC, IID_IDirectMusicTrack,
        (void**)&pDMTrack )))
    {
        GUID Guid = GUID_TempoParam;
        if ( SUCCEEDED(pDMTrack->SetParam(Guid, 0, &tempo)))
        {
            pISegment->InsertTrack( pDMTrack, 1 );
        }
    }
    // 10. Insert the three Tracks into the Segment's Track list.
    pISegment->InsertTrack(pBandTrack, 1);
    pISegment->InsertTrack(pIStyleTrack, 1);
    pISegment->InsertTrack(pICommandTrack, 1);
    pISegment->InsertTrack(pIChordTrack, 1);

    // Note: the segment must release the track objects...
ON_END:
    if (pDMTrack) pDMTrack->Release();
    if (pIChordStream) pIChordStream->Release();
    if (pIChordTrackStream) pIChordTrackStream->Release();
    if (pICommandStream) pICommandStream->Release();
    if (pICommandTrackStream) pICommandTrackStream->Release();
    if (pCommandRIFF) pCommandRIFF->Release();
    if (pChordRIFF) pChordRIFF->Release();
    if (pS) pS->Release();
    if (pU) pU->Release();
    if (pIStyleTrack) pIStyleTrack->Release();
    if (pICommandTrack) pICommandTrack->Release();
    if (pIChordTrack) pIChordTrack->Release();
    if (pBandTrack) pBandTrack->Release();
    return hr;
}

CDMSection::CDMSection() : m_pStyle(NULL), m_pIDMBand(NULL), m_cRef(1)
{
    InterlockedIncrement(&g_cComponent);
}

CDMSection::~CDMSection()
{
    CleanUp();
    InterlockedDecrement(&g_cComponent);
}

void CDMSection::CleanUp( BOOL fStop)
{
    if(m_pIDMBand)
    {
        m_pIDMBand->Release();
    }

    // let whoever used the section release the style.
    if (m_pStyle)
    {
        m_pStyle->Release();
    }
}

static BYTE setchordbits( long lPattern )
{
LONG    i;
short   count = 0;
BYTE bBits = 0;

    for( i=0L ;  i<32L ;  i++ )
    {
        if( lPattern & (1L << i) )
            count++;
    }
    bBits |= CHORD_INVERT;
    if( count > 3 )
        bBits |= CHORD_FOUR;
    if( lPattern & (15L << 18L) )
        bBits |= CHORD_UPPER;
    bBits &= ~CHORD_COUNT;
    bBits |= count;
    return bBits;
}

HRESULT CDMSection::LoadChordList( LPSTREAM pStream, LPMMCKINFO pck, TList<DMChord>& ChordList )
{
    HRESULT        hr = S_OK;
    DWORD        cb;
    long        lSize;
    TListItem<DMChord>*   pChord;
    ioChordSelection iChordSelection;
    WORD        wSizeChord;

    lSize = pck->cksize;
    // load size of chord structure
    hr = pStream->Read( &wSizeChord, sizeof( wSizeChord ), &cb );
    if( FAILED( hr ) || cb != sizeof( wSizeChord ) )
    {
        hr = E_FAIL;
        goto ON_ERR;
    }
    FixBytes( FBT_SHORT, &wSizeChord );
    lSize -= cb;
    while( lSize > 0 )
    {
        pChord = new TListItem<DMChord>;
        if( pChord == NULL )
        {
            hr = E_OUTOFMEMORY;
            goto ON_ERR;
        }
        if( wSizeChord > sizeof( ioChordSelection ) )
        {
            hr = pStream->Read( &iChordSelection, sizeof( ioChordSelection ), &cb );
            if( FAILED( hr ) || cb != sizeof( ioChordSelection ) )
            {
                hr = E_FAIL;
                goto ON_ERR;
            }
            FixBytes( FBT_IOCHORDSELECTION, &iChordSelection );
            StreamSeek( pStream, wSizeChord - sizeof( ioChordSelection ), STREAM_SEEK_CUR );
        }
        else
        {
            hr = pStream->Read( &iChordSelection, wSizeChord, &cb );
            if( FAILED( hr ) || cb != wSizeChord )
            {
                hr = E_FAIL;
                goto ON_ERR;
            }
            FixBytes( FBT_IOCHORDSELECTION, &iChordSelection );
        }
        lSize -= wSizeChord;

        // WideCharToMultiByte( CP_ACP, 0, iChordSelection.wstrName, -1, pChord->name, sizeof( pChord->name ), NULL, NULL );
        DMChord& rChord = pChord->GetItemValue();
        rChord.m_bKey = m_bRoot;
        rChord.m_dwScale = DEFAULT_SCALE_PATTERN;
        rChord.m_strName = iChordSelection.wstrName;
        rChord.m_bBeat = iChordSelection.bBeat;
        rChord.m_wMeasure = iChordSelection.wMeasure;
        rChord.m_mtTime = m_wClocksPerMeasure * rChord.m_wMeasure + m_wClocksPerBeat * rChord.m_bBeat;
        // If chordpattern contains <= n notes (for an n-note chord)
        //   create a single subchord
        // Else
        //   create 2 subchords, with the 1st having the lower n notes and the
        //   2nd having the upper n notes (assumes there are <= 2n notes)
        BYTE bBits = setchordbits( iChordSelection.aChord[0].lChordPattern );
        short nChordCount = bBits & CHORD_COUNT;
        // The root of the lower chord is the input chord's root,
        // relative to the scale (section) root.
        BYTE bChordRoot = iChordSelection.aChord[0].bRoot;
        //    (bBits & CHORD_UPPER) ? (iChordSelection.aChord[0].bRoot  - 12) : iChordSelection.aChord[0].bRoot;
        bChordRoot -= m_bRoot;
        if (bChordRoot < 0) bChordRoot += 12;
        if ((bBits & CHORD_FOUR && nChordCount <= 4) ||
            (!(bBits & CHORD_FOUR) && nChordCount <= 3))
        {
            // single subchord with all info from input chord
            TListItem<DMSubChord>* pSubChord = new TListItem<DMSubChord>;
            if( pSubChord == NULL )
            {
                hr = E_OUTOFMEMORY;
                goto ON_ERR;
            }
            DMSubChord& rSubChord = pSubChord->GetItemValue();
            if (iChordSelection.aChord[0].lChordPattern)
            {
                rSubChord.m_dwChordPattern = iChordSelection.aChord[0].lChordPattern;
            }
            else
            {
            }
            rSubChord.m_dwScalePattern = iChordSelection.aChord[0].lScalePattern;
            rSubChord.m_dwInversionPoints = 0xffffff;    // default: inversions everywhere
            rSubChord.m_dwLevels = (1 << SUBCHORD_BASS) | (1 << SUBCHORD_STANDARD_CHORD);
            rSubChord.m_bChordRoot = bChordRoot;
            rSubChord.m_bScaleRoot = m_bRoot;        // scale root is root of the section
            rChord.m_SubChordList.AddTail(pSubChord);
        }
        else
        {
            // two subchords both with scale and roots from input chord, and:
            // 1st chord: chord pattern from lower n notes of input chord
            // 2nd chord: chord pattern from upper n notes of input chord
            DWORD dwLowerSubChord = 0L;
            DWORD dwUpperSubChord = 0L;
            BYTE bUpperRoot = bChordRoot;
            DWORD dwChordPattern = iChordSelection.aChord[0].lChordPattern;
            short nIgnoreHigh = (bBits & CHORD_FOUR) ? 4 : 3;
            short nIgnoreLow = (bBits & CHORD_FOUR) ? nChordCount - 4 : nChordCount - 3;
            short nLowestUpper = 0;
            for (short nPos = 0, nCount = 0; nPos < 24; nPos++)
            {
                if (dwChordPattern & 1)
                {
                    if (nCount < nIgnoreHigh)
                    {
                        dwLowerSubChord |= 1L << nPos;
                    }
                    if (nCount >= nIgnoreLow)
                    {
                        if (!nLowestUpper)
                        {
                            nLowestUpper = nPos;
                            bUpperRoot = (bUpperRoot + (BYTE) nLowestUpper);
                        }
                        dwUpperSubChord |= 1L << (nPos - nLowestUpper);
                    }
                    nCount++;
                    if (nCount >= nChordCount)
                        break;
                }
                dwChordPattern >>= 1L;
            }
            // now, create the two subchords.
            TListItem<DMSubChord>* pLowerSubChord = new TListItem<DMSubChord>;
            if( pLowerSubChord == NULL )
            {
                hr = E_OUTOFMEMORY;
                goto ON_ERR;
            }
            DMSubChord& rLowerSubChord = pLowerSubChord->GetItemValue();
            rLowerSubChord.m_dwChordPattern = dwLowerSubChord;
            rLowerSubChord.m_dwScalePattern = iChordSelection.aChord[0].lScalePattern;
            rLowerSubChord.m_dwInversionPoints = 0xffffff;    // default: inversions everywhere
            rLowerSubChord.m_dwLevels = (1 << SUBCHORD_BASS);
            rLowerSubChord.m_bChordRoot = bChordRoot;
            rLowerSubChord.m_bScaleRoot = m_bRoot;        // scale root is root of the section
            rChord.m_SubChordList.AddTail(pLowerSubChord);
            TListItem<DMSubChord>* pUpperSubChord = new TListItem<DMSubChord>;
            if( pUpperSubChord == NULL )
            {
                hr = E_OUTOFMEMORY;
                goto ON_ERR;
            }
            DMSubChord& rUpperSubChord = pUpperSubChord->GetItemValue();
            rUpperSubChord.m_dwChordPattern = dwUpperSubChord;
            rUpperSubChord.m_dwScalePattern = iChordSelection.aChord[0].lScalePattern;
            rUpperSubChord.m_dwInversionPoints = 0xffffff;    // default: inversions everywhere
            rUpperSubChord.m_dwLevels = (1 << SUBCHORD_STANDARD_CHORD);
            rUpperSubChord.m_bChordRoot = bUpperRoot % 24;
            while (rUpperSubChord.m_bChordRoot < rLowerSubChord.m_bChordRoot)
                rUpperSubChord.m_bChordRoot += 12;
            rUpperSubChord.m_bScaleRoot = m_bRoot;        // scale root is root of the section
            rChord.m_SubChordList.AddTail(pUpperSubChord);
        }

        ChordList.AddTail(pChord);
    }
ON_ERR:
    return hr;
}

HRESULT CDMSection::LoadCommandList( LPSTREAM pStream, LPMMCKINFO pck, TList<DMCommand>& CommandList )
{
    HRESULT        hr = S_OK;
    DWORD        cb;
    long        lSize;
    TListItem<DMCommand>* pCommand;
    ioCommand   iCommand;
    WORD        wSizeCommand;

    lSize = pck->cksize;
    // load size of command structure
    hr = pStream->Read( &wSizeCommand, sizeof( wSizeCommand ), &cb );
    if( FAILED( hr ) || cb != sizeof( wSizeCommand ) )
    {
        hr = E_FAIL;
        goto ON_ERR;
    }
    FixBytes( FBT_SHORT, &wSizeCommand );
    lSize -= cb;
    while( lSize > 0 )
    {
        pCommand = new TListItem<DMCommand>;
        if( pCommand == NULL )
        {
            hr = E_OUTOFMEMORY;
            goto ON_ERR;
        }
        if( wSizeCommand > sizeof( ioCommand ) )
        {
            hr = pStream->Read( &iCommand, sizeof( ioCommand ), &cb );
            if( FAILED( hr ) || cb != sizeof( ioCommand ) )
            {
                hr = E_FAIL;
                goto ON_ERR;
            }
            FixBytes( FBT_IOCOMMAND, &iCommand );
            StreamSeek( pStream, wSizeCommand - sizeof( ioCommand ), STREAM_SEEK_CUR );
        }
        else
        {
            hr = pStream->Read( &iCommand, wSizeCommand, &cb );
            if( FAILED( hr ) || cb != wSizeCommand )
            {
                hr = E_FAIL;
                goto ON_ERR;
            }
            FixBytes( FBT_IOCOMMAND, &iCommand );
        }
        lSize -= wSizeCommand;

        DMCommand& rCommand = pCommand->GetItemValue();
        ////////////////////////////////////////////////////////////////////
        // Change this from absolute time to measures and beats!
        ////////////////////////////////////////////////////////////////////
         // To convert clock time to measures and beats:
         // 1. Use clocksPerMeasure to find the measure
         // 2. Use clocksPerBeat to find the beat
         // DWORD dwClocks = rCommand.m_dwTime - m_dwTime;
         rCommand.m_wMeasure = (WORD) (ConvertTime(iCommand.lTime) / m_wClocksPerMeasure); // assumes 1st measure is 0
         rCommand.m_bBeat = (BYTE) ((ConvertTime(iCommand.lTime) % m_wClocksPerMeasure) / m_wClocksPerBeat); // ditto
         rCommand.m_mtTime = ConvertTime(iCommand.lTime);
        /////////////////////////////////////////////////////////////////////
         switch (iCommand.dwCommand & PF_RIFF)
         {
         case PF_INTRO:
             rCommand.m_bCommand = DMUS_COMMANDT_INTRO;
             break;
         case PF_END:
             rCommand.m_bCommand = DMUS_COMMANDT_END;
             break;
         case PF_BREAK:
             rCommand.m_bCommand = DMUS_COMMANDT_BREAK;
             break;
         case PF_FILL:
             rCommand.m_bCommand = DMUS_COMMANDT_FILL;
             break;
         default:
             rCommand.m_bCommand = DMUS_COMMANDT_GROOVE;
         }
         switch (iCommand.dwCommand & PF_GROOVE)
         {
         case PF_A:
             rCommand.m_bGrooveLevel = 12;
             break;
         case PF_B:
             rCommand.m_bGrooveLevel = 37;
             break;
         case PF_C:
             rCommand.m_bGrooveLevel = 62;
             break;
         case PF_D:
             rCommand.m_bGrooveLevel = 87;
             break;
         default:
             rCommand.m_bGrooveLevel = 0;
         }
         rCommand.m_bGrooveRange = 0;
         rCommand.m_bRepeatMode = DMUS_PATTERNT_RANDOM;

        CommandList.AddTail(pCommand);
    }
ON_ERR:
    return hr;
}

HRESULT CDMSection::LoadStyleReference( LPSTREAM pStream, MMCKINFO* pck)
{
    HRESULT hr;
    DWORD   cb;
    DWORD    cSize;
    //char    szName[40];
    wchar_t    wstrName[40];
    //IAALoader* pLoader;

    cSize = min( pck->cksize, sizeof( wstrName ) );
    hr = pStream->Read( wstrName, cSize, &cb );
    if( FAILED( hr ) || cb != cSize )
    {
        return E_FAIL;
    }
    m_strStyleName = wstrName;
    DMUS_OBJECTDESC ObjectDescript;
    ObjectDescript.dwSize = sizeof(DMUS_OBJECTDESC);
    ObjectDescript.guidClass = CLSID_DirectMusicStyle;
    wcscpy(ObjectDescript.wszName, wstrName);
    ObjectDescript.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_NAME;
    IDirectMusicLoader* pLoader;
    IDirectMusicGetLoader *pIGetLoader;  // <==============
    hr = pStream->QueryInterface( IID_IDirectMusicGetLoader, (void **) &pIGetLoader );// <========
    if (SUCCEEDED(hr))
    {
        hr = pIGetLoader->GetLoader(&pLoader);  // <========
        if (SUCCEEDED(hr))                      // <========
        {                                       // <========
            hr = pLoader->GetObject(&ObjectDescript, IID_IDirectMusicStyle, (void**)&m_pStyle);
            pLoader->Release();
        }                                       // <========
        pIGetLoader->Release();                 // <========
    }
    return hr;
}



HRESULT CDMSection::LoadSection( IAARIFFStream* pRIFF, MMCKINFO* pckMain )
{
    HRESULT     hr = S_OK;
    HRESULT     hrBand = S_OK;
    ioSection   iSection;
    MMCKINFO    ck;
    DWORD        cb;
    DWORD        cSize;
    IStream*    pStream;
    BOOL        fLoadedSection = FALSE;

    pStream = pRIFF->GetStream();
    while( pRIFF->Descend( &ck, pckMain, 0 ) == 0 )
    {
        switch( ck.ckid )
        {
        case FOURCC_SECTION:
            cSize = min( ck.cksize, sizeof( iSection ) );
            hr = pStream->Read( &iSection, cSize, &cb );
            if( FAILED( hr ) || cb != cSize )
            {
                hr = E_FAIL;
                goto ON_ERR;
            }
            FixBytes( FBT_IOSECTION, &iSection );

            m_strName = iSection.wstrName;
            m_dwTime = iSection.lTime;
            m_wTempo = iSection.wTempo;
            // wRepeats refers to repeats after the first play.
            m_wRepeats = iSection.wRepeats;
            m_wMeasureLength = iSection.wMeasureLength;
            m_wClocksPerMeasure = ConvertTime(iSection.wClocksPerMeasure);
            m_wClocksPerBeat = ConvertTime(iSection.wClocksPerBeat);
            m_wTempoFract = iSection.wTempoFract;
            m_dwFlags = iSection.dwFlags;
            m_bRoot = (char)( iSection.chKey & ~KEY_FLAT );
            m_dwClockLength = (long)m_wMeasureLength * (long)m_wClocksPerMeasure;

            fLoadedSection = TRUE;
            break;
        case FOURCC_STYLEREF:
            if( fLoadedSection )
            {
                hr = LoadStyleReference( pStream, &ck );
                if (hr != S_OK)
                {
                    hrBand = hr;
                }
                if( FAILED( hr ) )
                {
                    goto ON_ERR;
                }
            }
            break;

        case FOURCC_RIFF:
            switch(ck.fccType)
            {
                case FOURCC_BAND_FORM:
                {
                    // Create a band
                    hr = CoCreateInstance(CLSID_DirectMusicBand,
                                          NULL,
                                          CLSCTX_INPROC,
                                          IID_IDirectMusicBand,
                                          (void**)&m_pIDMBand);

                    if(SUCCEEDED(hr))
                    {
                        // Seek back to begining of Riff chunk
                        // This is the amount read by Descend when descending into a FOURCC_RIFF chunk
                        // Get current position
                        LARGE_INTEGER li;
                        ULARGE_INTEGER ul;
                        li.HighPart = 0;
                        li.LowPart = 0;
                        hr = pStream->Seek(li,
                                           STREAM_SEEK_CUR,
                                           &ul);

                        if(SUCCEEDED(hr))
                        {
                            li.HighPart = 0;
                            // This is always a valid operation
                            li.LowPart = ul.LowPart - (2 * sizeof(FOURCC) + sizeof(DWORD));
                            hr = pStream->Seek(li,
                                               STREAM_SEEK_SET,
                                               &ul);
                        }
                    }

                    if(SUCCEEDED(hr))
                    {
                        // Load band
                        IPersistStream* pIPersistStream;
                        hr = m_pIDMBand->QueryInterface(IID_IPersistStream, (void **)&pIPersistStream);

                        if(SUCCEEDED(hr))
                        {
                            hr = pIPersistStream->Load(pStream);
                            if (hr != S_OK)
                            {
                                hrBand = hr;
                            }
                            pIPersistStream->Release();
                        }
                    }

                    if(FAILED(hr))
                    {
                        goto ON_ERR;
                    }
                }
                break;
            }
            break;

        case FOURCC_CHORD:
            if( fLoadedSection )
            {
                hr = LoadChordList( pStream, &ck, m_ChordList );
                if( FAILED( hr ) )
                {
                    goto ON_ERR;
                }
            }
            break;
        case FOURCC_COMMAND:
            if( fLoadedSection )
            {
                hr = LoadCommandList( pStream, &ck, m_CommandList );
                if( FAILED( hr ) )
                {
                    goto ON_ERR;
                }
            }
            break;
        }
        pRIFF->Ascend( &ck, 0 );
    }


ON_ERR:
    if( FAILED( hr ) )
    {

        if(m_pIDMBand != NULL)
        {
            if(m_pIDMBand)
            {
                m_pIDMBand->Release();
            }
            m_pIDMBand = NULL;
        }

    }
    pStream->Release( );
    if (hr == S_OK && hrBand != S_OK)
    {
        hr = hrBand;
    }
    return hr;
}

HRESULT CDMSection::Load(
                        LPSTREAM pStream )    // Pointer to a stream that contains the
                                            // Section information to load.
{
    DWORD dwPos;
    IAARIFFStream*  pRIFF;
    MMCKINFO        ckMain;
    HRESULT         hr;

    if ( pStream == NULL ) return E_INVALIDARG;
    hr = E_FAIL;
    CleanUp( FALSE );

    dwPos = StreamTell( pStream );

    StreamSeek( pStream, dwPos, STREAM_SEEK_SET );

    if( SUCCEEDED( AllocRIFFStream( pStream, &pRIFF ) ) )
    {
        ckMain.fccType = FOURCC_SECTION_FORM;
        if( pRIFF->Descend( &ckMain, NULL, MMIO_FINDRIFF ) == 0 )
        {
            hr = LoadSection( pRIFF, &ckMain );
            pRIFF->Ascend( &ckMain, 0 );
        }
        pRIFF->Release( );
    }
    return hr;
}



DMChord::DMChord(DMUS_CHORD_PARAM& DMC)
{
    m_strName = DMC.wszName;
    m_wMeasure = DMC.wMeasure;
    m_bBeat = DMC.bBeat;
    m_bKey = DMC.bKey;
    m_dwScale = DMC.dwScale;
    m_fSilent = (DMC.bFlags & DMUS_CHORDKEYF_SILENT) ? true : false;
    for (BYTE n = 0; n < DMC.bSubChordCount; n++)
    {
        TListItem<DMSubChord>* pSub = new TListItem<DMSubChord>(DMC.SubChordList[n]);
        if (pSub)
        {
            m_SubChordList.AddTail(pSub);
        }
    }
}

DMChord::DMChord(DMChord& DMC)
{
    m_strName = DMC.m_strName;
    m_wMeasure = DMC.m_wMeasure;
    m_bBeat = DMC.m_bBeat;
    m_bKey = DMC.m_bKey;
    m_dwScale = DMC.m_dwScale;
    m_fSilent = DMC.m_fSilent;
    TListItem<DMSubChord>* pScan = DMC.m_SubChordList.GetHead();
    for (; pScan != NULL; pScan = pScan->GetNext())
    {
        TListItem<DMSubChord>* pSub = new TListItem<DMSubChord>(pScan->GetItemValue());
        if (pSub)
        {
            m_SubChordList.AddTail(pSub);
        }
    }
}

DMChord& DMChord::operator=(const DMChord& DMC)
{
    if (this != &DMC)
    {
        m_strName = DMC.m_strName;
        m_wMeasure = DMC.m_wMeasure;
        m_bBeat = DMC.m_bBeat;
        m_bKey = DMC.m_bKey;
        m_dwScale = DMC.m_dwScale;
        m_fSilent = DMC.m_fSilent;
        m_SubChordList.CleanUp();
        TListItem<DMSubChord>* pScan = DMC.m_SubChordList.GetHead();
        for (; pScan != NULL; pScan = pScan->GetNext())
        {
            TListItem<DMSubChord>* pSub = new TListItem<DMSubChord>(pScan->GetItemValue());
            if (pSub)
            {
                m_SubChordList.AddTail(pSub);
            }
        }
    }
    return *this;
}

DMChord::operator DMUS_CHORD_PARAM()
{
    DMUS_CHORD_PARAM result;
    wcscpy(result.wszName, m_strName);
    result.wMeasure = m_wMeasure;
    result.bBeat = m_bBeat;
    result.bKey = m_bKey;
    result.dwScale = m_dwScale;
    result.bFlags = 0;
    if (m_fSilent) result.bFlags |= DMUS_CHORDKEYF_SILENT;
    BYTE n = 0;
    TListItem<DMSubChord>* pSub = m_SubChordList.GetHead();
    for (; pSub != NULL; pSub = pSub->GetNext(), n++)
    {
        result.SubChordList[n] = pSub->GetItemValue();
    }
    result.bSubChordCount = n;
    return result;
}

HRESULT DMChord::Save( IAARIFFStream* pRIFF )
{
    IStream*    pStream;
    MMCKINFO    ck;
    DWORD       cb;
    DMUS_IO_CHORD    iChord;
    DMUS_IO_SUBCHORD    iSubChord;
    DWORD        dwSize;
    HRESULT hr = E_FAIL;

    pStream = pRIFF->GetStream();
    ck.ckid = mmioFOURCC('c', 'r', 'd', 'b');
    if( pRIFF->CreateChunk( &ck, 0 ) == 0 )
    {
        memset( &iChord, 0, sizeof( iChord ) );
        m_strName = iChord.wszName;
        //MultiByteToWideChar( CP_ACP, 0, m_strName, -1, iChord.wszName, sizeof( iChord.wszName ) / sizeof( wchar_t ) );
        iChord.mtTime = m_mtTime;
        iChord.wMeasure = m_wMeasure;
        iChord.bBeat = m_bBeat;
        iChord.bFlags = 0;
        if (m_fSilent) iChord.bFlags |= DMUS_CHORDKEYF_SILENT;
        dwSize = sizeof( iChord );
        hr = pStream->Write( &dwSize, sizeof( dwSize ), &cb );
        if( SUCCEEDED(hr) &&
            SUCCEEDED( pStream->Write( &iChord, sizeof( iChord), &cb ) ) &&
            cb == sizeof( iChord) ) // &&
            //pRIFF->Ascend( &ck, 0 ) == 0 )
        {
            //ck.ckid = mmioFOURCC('s', 'u', 'b', 'c');
            //if( pRIFF->CreateChunk( &ck, 0 ) == 0 )
            {
                DWORD dwCount = (WORD) m_SubChordList.GetCount();
                hr = pStream->Write( &dwCount, sizeof( dwCount ), &cb );
                if( FAILED( hr ) || cb != sizeof( dwSize ) )
                {
                    pStream->Release();
                    return E_FAIL;
                }
                dwSize = sizeof( iSubChord );
                hr = pStream->Write( &dwSize, sizeof( dwSize ), &cb );
                if( FAILED( hr ) || cb != sizeof( dwSize ) )
                {
                    pStream->Release();
                    return E_FAIL;
                }
                for (TListItem<DMSubChord>* pSub = m_SubChordList.GetHead(); pSub != NULL; pSub = pSub->GetNext())
                {
                    DMSubChord& rSubChord = pSub->GetItemValue();
                    memset( &iSubChord, 0, sizeof( iSubChord ) );
                    iSubChord.dwChordPattern = rSubChord.m_dwChordPattern;
                    iSubChord.dwScalePattern = rSubChord.m_dwScalePattern;
                    iSubChord.dwInversionPoints = rSubChord.m_dwInversionPoints;
                    iSubChord.dwLevels = rSubChord.m_dwLevels;
                    iSubChord.bChordRoot = rSubChord.m_bChordRoot;
                    iSubChord.bScaleRoot = rSubChord.m_bScaleRoot;
                    if( FAILED( pStream->Write( &iSubChord, sizeof( iSubChord ), &cb ) ) ||
                        cb != sizeof( iSubChord ) )
                    {
                        break;
                    }
                }
                // ascend from chord body chunk
                if( pSub == NULL &&
                    pRIFF->Ascend( &ck, 0 ) != 0 )
                {
                    hr = S_OK;
                }
            }
        }
    }
    pStream->Release();
    return hr;
}


HRESULT CDMSection::SaveChordList( IAARIFFStream* pRIFF )
{
    IStream*    pStream;
    //LPSECT      pSection;
    MMCKINFO    ck;
    MMCKINFO    ckHeader;
    HRESULT     hr;
    DWORD       cb;
    //WORD        wSize;
    TListItem<DMChord>*   pChord;
    //int         i;


    pStream = pRIFF->GetStream();
    //pSection = (LPSECT)m_pSection->lpDLL1;

    ck.fccType = DMUS_FOURCC_CHORDTRACK_LIST;
    hr = pRIFF->CreateChunk(&ck, MMIO_CREATELIST);
    if (SUCCEEDED(hr))
    {
       // wSize = sizeof( ioChordSelection );
        //FixBytes( FBT_SHORT, &wSize );
       // hr = pStream->Write( &wSize, sizeof( wSize ), &cb );
       // if( FAILED( hr ) || cb != sizeof( wSize ) )
       // {
       //     RELEASE( pStream );
       //     return E_FAIL;
        //}

        DWORD dwRoot = m_bRoot;
        DWORD dwScale = DEFAULT_SCALE_PATTERN | (dwRoot << 24);

        ckHeader.ckid = DMUS_FOURCC_CHORDTRACKHEADER_CHUNK;
        hr = pRIFF->CreateChunk(&ckHeader, 0);
        if (FAILED(hr))
        {
            pStream->Release();
            return hr;
        }
        hr = pStream->Write( &dwScale, sizeof( dwScale ), &cb );
        if (FAILED(hr))
        {
            pStream->Release();
            return hr;
        }
        hr = pRIFF->Ascend( &ckHeader, 0 );
        if (hr != S_OK)
        {
            pStream->Release();
            return hr;
        }

        for( pChord = m_ChordList.GetHead() ; pChord != NULL ; pChord = pChord->GetNext() )
        {
            hr = pChord->GetItemValue().Save(pRIFF);
            if (FAILED(hr))
            {
                pStream->Release();
                return hr;
            }
        }
        if( pChord == NULL &&
            pRIFF->Ascend( &ck, 0 ) == 0 )
        {
            hr = S_OK;
        }
    }

    pStream->Release();
    return hr;
}


HRESULT CDMSection::SaveCommandList( IAARIFFStream* pRIFF )
{
    IStream*    pStream;
    MMCKINFO    ck;
    HRESULT     hr;
    DWORD       cb;
    DWORD       dwSize;
    DMUS_IO_COMMAND   iCommand;
    TListItem<DMCommand>* pCommand;

    pStream = pRIFF->GetStream();
    if (!pStream) return E_FAIL;

    hr = E_FAIL;
    ck.ckid = FOURCC_COMMAND;
    if( pRIFF->CreateChunk( &ck, 0 ) == 0 )
    {
        dwSize = sizeof( DMUS_IO_COMMAND );
        hr = pStream->Write( &dwSize, sizeof( dwSize ), &cb );
        if( FAILED( hr ) || cb != sizeof( dwSize ) )
        {
            pStream->Release();
            return E_FAIL;
        }
        for( pCommand = m_CommandList.GetHead(); pCommand != NULL ; pCommand = pCommand->GetNext() )
        {
            DMCommand& rCommand = pCommand->GetItemValue();
            memset( &iCommand, 0, sizeof( iCommand ) );
            iCommand.mtTime = rCommand.m_mtTime;
            iCommand.wMeasure = rCommand.m_wMeasure;
            iCommand.bBeat = rCommand.m_bBeat;
            iCommand.bCommand = rCommand.m_bCommand;
            iCommand.bGrooveLevel = rCommand.m_bGrooveLevel;
             iCommand.bGrooveRange = rCommand.m_bGrooveRange;
             iCommand.bRepeatMode = rCommand.m_bRepeatMode;
            if( FAILED( pStream->Write( &iCommand, sizeof( iCommand ), &cb ) ) ||
                cb != sizeof( iCommand ) )
            {
                break;
            }
        }
        if( pCommand == NULL &&
            pRIFF->Ascend( &ck, 0 ) == 0 )
        {
            hr = S_OK;
        }
    }

    pStream->Release();
    return hr;
}


HRESULT CDMSection::Save(
                        LPSTREAM pStream,        // Stream to store Section.
                        BOOL /*fClearDirty*/ )    // TRUE to clear dirty flag, FALSE to leave
                                                // dirty flag unchanged.
{
    IAARIFFStream*  pRIFF;
    HRESULT         hr;
    MMCKINFO        ckMain;

    hr = E_FAIL;
    if( SUCCEEDED( AllocRIFFStream( pStream, &pRIFF ) ) )
    {
        ckMain.fccType = FOURCC_SECTION_FORM;
        if( pRIFF->CreateChunk( &ckMain, MMIO_CREATERIFF ) != 0 )
        {
            goto ON_ERR;
        }

        if( FAILED( SaveChordList( pRIFF ) ) ||
            FAILED( SaveCommandList( pRIFF ) ) )
        {
            goto ON_ERR;
        }

        if( pRIFF->Ascend( &ckMain, 0 ) != 0 )
        {
            goto ON_ERR;
        }
        hr = S_OK;
ON_ERR:
        pRIFF->Release();
    }
    return hr;
}


/* IPersist methods */
 HRESULT CDMSection::GetClassID( LPCLSID pclsid )
{
    return E_NOTIMPL;
}

 HRESULT CDMSection::IsDirty()
{
    return E_NOTIMPL;
}

HRESULT CDMSection::GetSizeMax( ULARGE_INTEGER* /*pcbSize*/ )
{
    return E_NOTIMPL;
}