==============================================================================
                     PMD for Windows uPMDWinv Ver.0.50
                        Copyright & Programmed by C60
                                 DLL dl
==============================================================================


------------------------------------------------------------------------------
͂߂
    {dĺAPMDWin.dll  export Ă֐ꗗłB
    PMDWin Ver0.17 ȍ~Ŏgpł܂B
    bŎgꍇ FMPMD_SDK005.zip ɓĂ PMDWinImport.h,
    PMDWin.lib  include ĉ(邢 LoadLibrary 
    Iɓǂݍł)
    Delphi ŗpꍇ́AFMPMD_SDK005.zip ɓĂ PMDWin.pas,
    PCMMusDriver.pas gݍłgB
    
    
------------------------------------------------------------------------------
ȕύX_
    EVer0.40 AFileIOC^[tFCXɑΉ܂B
      ڍׂ́AFileIOInfo.txt QƂĂB
    EVer0.31 Asetfmcalc55k() ̏ fmgen ł͂Ȃ
      PMDWin.dll Ŏ悤ɂ܂B
    EVer0.31 Agetmemo(), getmemo2(), getmemo3(), fgetmemo(),
      fgetmemo2(), fgetmemo3() ̖߂lő 1024 oCgɐ悤
      ܂B
    EVer0.30 Afmgen ̎dlύXɔ setfmcalc55k() sĂ
      ʂȂȂ܂B
    EVer0.17 ACOM C^[tFCXApmd_CoCreateInstance 
      ܂BPMDWin ̃CX^X𕡐擾ėp邱Ƃ
      ł܂B
    EVer0.17 Asetppzrate(), setfmcalc55k() ǉAsetpcmrate()
      ŔCӂ̐̒lݒł悤ɂȂ܂B
    EVer0.16 Asetfmwait(), setssgwait(), setrhythmwait(),
      setadpcmwait() ǉ܂B
    EVer0.15 Agetloopcount() ǉ܂B
    EVer0.14 Amusic_load2(), fgetmemo(), fgetmemo2(), fgetmemo3() 
      ǉ܂B
    EVer0.09 A֐̌ĂяoK cdecl  stdcall ֕ύX܂B
    EVer0.09 Agetppcfilename() ł PPC/PVI ݂̂擾悤
      ܂B ADPCM/P86 p[gŉt PPC/P86 t@C
      擾ɂ getpcmfilename() pĂB
    
    
------------------------------------------------------------------------------
ӓ_
    PjPMDWin.dll ł͉̏o͍͂s܂B
    @@vC wave foCX PCM f[^̏o͂sKv܂B
    QjPMDWin.dll ͈ꕔXbhZ[tł͂܂B
    @@̃Xbh瓯ɃANZXꍇ́ANeBJZNV
    @@ŕی삵ĂB
    @@getlength(), getlength2() ̂̂ǂ炩 getmemo(), getmemo2(),
    @@getmemo3(), fgetmemo(), fgetmemo2(), fgetmemo3() ̂̂ЂƂA
    @@̊֐̑gݍ킹̂݁Aʂ̃Xbh瓯Ɏsł܂B
    
    
------------------------------------------------------------------------------
֐̎gp菇(FDLLC^[tFCXpꍇ)
    getversion(), getinterfaceversion() Ńo[W`FbN
    @
    pmdwininit() ŏ
    @
    setpcmdir(), setpcmrate() œ̐ݒ
    @
    music_load() 邢 music_load2() ŋȃf[^̓ǂݍ
    @
    music_start() ŉtJn
    @
    getpcmdata()  PCM f[^̎擾BvC wave foCXɏo
    @
    music_stop() ŉtI
    @
    ݂̋ȂĉtȂAmusic_start() B
    ̋ȂtȂAmusic_load() 邢 music_load2() B
    
    
------------------------------------------------------------------------------
t@NVꗗ

    i͂bAi Delphi ł̒`łBȂAbł
        typedef unsigned char uchar;
    Delphi ł
        type PSmallInt = ^SmallInt;
    łB
    
    
===============================================================================
    int getversion(void);
    function getversion : Integer;
-------------------------------------------------------------------------------
    input           
    output          DLL ̃o[W
-------------------------------------------------------------------------------

    PMDWin.dll ̃o[W擾܂B
    10i100̈ʂW[o[WA2}Ci[o[WłB
    ݂̖߂l050łB
    
    
===============================================================================
    int getinterfaceversion(void);
    function getinterfaceversion : Integer;
-------------------------------------------------------------------------------
    input           
    output          DLL C^[tFCX̃o[W
-------------------------------------------------------------------------------
    
    PMDWin.dll ̃C^[tFCX̃o[W擾܂B
    10i100̈ʂW[o[WA2}Ci[o[WłB
    ݂̖߂l118łB
    
    ʃo[W export Ă֐̍팸AdlύXꍇɂ
    W[o[Wオ܂B
    ʃo[W export Ă֐̒ǉ݂̂̏ꍇɂ̓W[o[
    W͕ς炸A}Ci[o[Ŵ݂オ܂B
    ʃo[W export Ă֐ςȂƂɂ̓o[W
    ω܂B
    
    
===============================================================================
    HRESULT WINAPI pmd_CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter,
        DWORD dwClsContext, REFIID riid, LPVOID * ppv);
    function pmd_CoCreateInstance(const clsid: TCLSID; unkOuter: IUnknown;
        dwClsContext: Longint; const iid: TIID; var pv) : HResult; stdcall;
-------------------------------------------------------------------------------

    PMDWin  CX^X𐶐AC^[tFCX|C^擾܂B
    ڍׂ́ACOMInfop.txt QƂĂB
    
    
===============================================================================
    bool pmdwininit(char *path);
    function pmdwininit(path : PChar) : Boolean;
-------------------------------------------------------------------------------
    input
        path        Y wav ݂fBNg
    output          ɐ true, Ȃ false
-------------------------------------------------------------------------------
    
    PMDWin.dll ̏s܂B
    ȉ̃t@NVgpOɈxĂяoĂB
    
    path ̍Ṓu\v͕tĂtȂĂ\܂B
    path  NULL ̏ꍇ͍ƃtH_(V[gJbgŎw肵tH_A
    邢̓vCtH_)ǂݍ݂܂B
    
    
===============================================================================
    bool loadrhythmsample(char *path);
    function loadrhythmsample(path : PChar) : Boolean;
-------------------------------------------------------------------------------
    input
        path        Y wav ݂fBNg
    output          ǂݍ݂ɐ true, Ȃ false
-------------------------------------------------------------------------------
    
    Y wave ēxǂݍ݂܂B
    sƋȂ̉t~܂܂B
    
    path ̍Ṓu\v͕tĂtȂĂ\܂B
    path  NULL ̏ꍇ͍ƃtH_(V[gJbgŎw肵tH_A
    邢̓vCtH_)ǂݍ݂܂B
    
    
===============================================================================
    bool setpcmdir(char **path);
    function setpcmdir(pcmdir : Array of PChar) : Boolean;
-------------------------------------------------------------------------------
    input
        path        PCM ̌pX̃|C^z
    output          path 64𒴂 false
-------------------------------------------------------------------------------
    
    PCM(PPC,PPS,P86,PVI,PZI) ̌pXw肵܂B
    path PCM ̌pX̃|C^złB
    music_load() œǂݍ܂ȃf[^ƓfBNg͍ŏɕK
    ̂ŁAŎw肷Kv͂܂B
    
    path ̍Ṓu\v͕tĂtȂĂ\܂B
    MAX_PCMDIR(64)fBNg܂Ŏwł܂B
    Ōɂ NULL  "" w肵ĂB
    
    ex) c:\pmd\ppc, c:\pmd\pvi w肷Ƃ
        
        char *path[MAX_PCMDIR+1];
        path[0] = "c:\pmd\ppc";
        path[1] = "c:\pmd\pvi";
        path[2] = NULL; ܂ path[2] = "";
    
    
===============================================================================
    void setpcmrate(int rate);
    procedure setpcmrate(rate : Integer);
-------------------------------------------------------------------------------
    input
        rate        Đg
    output          Ȃ
-------------------------------------------------------------------------------
    
    getpcmdata() Ŏ擾 PCM ̎gw肵܂B
    rate ͔Cӂ̒lwł܂Aʌ݊mۂ̂߁AAPI 
    setppzrate(), setfmcalc55k() IɎs܂B
    
    Erate = SOUND_55K ܂ rate = SOUND_55K_2 ̏ꍇ
        o͂ PCM ̎gAPPZ 쓮g 44kHz
        fmcalc55k(true);
        
    Erate != SOUND_55K  rate != SOUND_55K_2 ̏ꍇ
        o͂ PCM ̎gAPPZ 쓮g rate Ŏw肳ꂽlB
        fmcalc55k(false);
    
    
    setppzrate(), setfmcalc55k() ́A{ API ̌ɎsĂB
    
    
===============================================================================
    void setppzrate(int rate);
    procedure setppzrate(rate : Integer);
-------------------------------------------------------------------------------
    input
        rate        PPZ8 쓮g(Hz)
    output          Ȃ
-------------------------------------------------------------------------------
    
    PPZ8 ̋쓮gw肵܂Brate ͔Cӂ̒li1ȏ)wł܂B
    
    setpcmrate() sƁA{ API Ŏw肳ꂽl㏑̂ŁA
    setpcmrate() ̌Ɏs悤ɂĉB
    
    
===============================================================================
    void setfmcalc55k(bool flag);
    procedure setfmcalc55k(flag : Boolean);
-------------------------------------------------------------------------------
    input
        flag        // FM ̍ 55kHz ōsȂ true
                    // setpcmrate() Ŏw肵lōsȂ false
    output          Ȃ
-------------------------------------------------------------------------------
    FM ̍ 55kHz ōsǂw肵܂B
    55kHz ōsƉ͌サ܂A኱dȂ܂B
    { API ̎ẃAgetpcmdata() Ŏ擾 PCM f[^̎gƂ
    ֌WłB
    
    setpcmrate() sƁA{ API Ŏw肳ꂽl㏑̂ŁA
    setpcmrate() ̌Ɏs悤ɂĉB
    
    
===============================================================================
    void setppsuse(bool value);
    procedure setppsuse(value : Boolean);
-------------------------------------------------------------------------------
    input           PPS 炷Ȃ trueBSSG Rhythm 炷Ȃ false
    output          Ȃ
-------------------------------------------------------------------------------

    PPS 炷ǂw肵܂B
    PPS 炳Ȃꍇ́A SSG Y܂B

===============================================================================
    void setrhythmwithssgeffect(bool value);
    procedure setrhythmwithssgeffect(value : Boolean);
-------------------------------------------------------------------------------
    input           SSG YƓ OPNA Y炷Ȃ true
    output          Ȃ
-------------------------------------------------------------------------------

    SSG Y(邢 PPS)Ɠ OPNA Y炷ǂ
    w肵܂B
    

===============================================================================
    void setpmd86pcmmode(bool value);
    procedure setpmd86pcmmode(value : Boolean);
-------------------------------------------------------------------------------
    input           PMD86  PCM  ADPCM ݊ɂȂ true
    output          Ȃ
-------------------------------------------------------------------------------

    PMD86  PCM  ADPCM ݊ɂ邩ǂw肵܂B
    

===============================================================================
    bool getpmd86pcmmode(void);
    function getpmd86pcmmode : Boolean;
-------------------------------------------------------------------------------
    input           Ȃ
    output          PMD86  PCM  ADPCM ݊ɂȂ true
-------------------------------------------------------------------------------

    PMD86  PCM  ADPCM ݊ǂ擾܂B
    

===============================================================================
    int music_load(char *filename);
    function music_load(filename : PChar) : Integer;
-------------------------------------------------------------------------------
    input
        filename    ȃf[^̃t@C(tpX)
    output          L̖߂lQ
-------------------------------------------------------------------------------
    
    t@CŎȃf[^ PMDWin.dll ɓǂݍ݂܂B
    ȃf[^ PCM t@Cw肳Ăꍇ́Aŏɋȃf[^
    ݂fBNgAȂ setpcmdir() Ŏw肳ꂽ
    fBNg PCM ̓ǂݍ݂s܂B
    ۂɉt邽߂ɂ́Amusic_start() ĂяoKv܂B
    
    ߂lF
        PMDWIN_OK                   I
        ERR_OPEN_MUSIC_FILE          f[^JȂ
        ERR_WRONG_MUSIC_FILE        PMD ̋ȃf[^ł͂Ȃ
        ERR_OPEN_PPC_FILE           PPC JȂ
        ERR_WRONG_PPC_FILE          PPC ُ
        WARNING_PPC_ALREADY_LOAD    PPC ͊ɓǂݍ܂Ă
        ERR_OPEN_PPS_FILE           PPS JȂ
        WARNING_PPS_ALREADY_LOAD    PPS ͊ɓǂݍ܂Ă
        ERR_OPEN_PPZ1_FILE          PPZ(Buffer 1)JȂ
        ERR_OPEN_PPZ2_FILE          PPZ(Buffer 2)JȂ
        ERR_WRONG_PPZ1_FILE         PPZ(Buffer 1)ُ
        ERR_WRONG_PPZ2_FILE         PPZ(Buffer 2)ُ
        WARNING_PPZ1_ALREADY_LOAD   PPZ(Buffer 1)͊ɓǂݍ܂Ă
        WARNING_PPZ2_ALREADY_LOAD   PPZ(Buffer 2)͊ɓǂݍ܂Ă
        ERR_OUT_OF_MEMORY           s
        ERR_OTHER                   ̑̃G[
                                    (oꍇ͘A肢܂)
    
    
===============================================================================
    int music_load2(uchar *musdata, int size);
    function music_load2(musdata : Pointer; size : Integer) : Integer;
-------------------------------------------------------------------------------
    input
        musdata     ȃf[^̃|C^
        size        ȃf[^̃TCY
    output          L̖߂lQ
-------------------------------------------------------------------------------
    
    musdata  size Ŏw肳郁̋ȃf[^ PMDWin.dll 
    ǂݍ݂܂B
    PCM  setpcmdir() Ŏw肳ꂽfBNgǂݍ܂܂B
    ۂɉt邽߂ɂ́Amusic_start() ĂяoKv܂B
    
    ߂lF
        PMDWIN_OK                   I
        ERR_WRONG_MUSIC_FILE        PMD ̋ȃf[^ł͂Ȃ
        ERR_OPEN_PPC_FILE           PPC JȂ
        ERR_WRONG_PPC_FILE          PPC ُ
        WARNING_PPC_ALREADY_LOAD    PPC ͊ɓǂݍ܂Ă
        ERR_OPEN_PPS_FILE           PPS JȂ
        WARNING_PPS_ALREADY_LOAD    PPS ͊ɓǂݍ܂Ă
        ERR_OPEN_PPZ1_FILE          PPZ(Buffer 1)JȂ
        ERR_OPEN_PPZ2_FILE          PPZ(Buffer 2)JȂ
        ERR_WRONG_PPZ1_FILE         PPZ(Buffer 1)ُ
        ERR_WRONG_PPZ2_FILE         PPZ(Buffer 2)ُ
        WARNING_PPZ1_ALREADY_LOAD   PPZ(Buffer 1)͊ɓǂݍ܂Ă
        WARNING_PPZ2_ALREADY_LOAD   PPZ(Buffer 2)͊ɓǂݍ܂Ă
        ERR_OUT_OF_MEMORY           s
        ERR_OTHER                   ̑̃G[
                                    (oꍇ͘A肢܂)
    
    
===============================================================================
    void music_start(void);
    procedure music_start;
-------------------------------------------------------------------------------
    input           Ȃ
    output          Ȃ
-------------------------------------------------------------------------------
    
    music_load() 邢 music_load2() œǂݍ܂ꂽȂ̍Jn
    w܂B
    ۂ PCM f[^̎擾ɂ́Agetpcmdata() gpĂB
    
    
===============================================================================
    void music_stop(void);
    procedure music_stop;
-------------------------------------------------------------------------------
    input           Ȃ
    output          Ȃ
-------------------------------------------------------------------------------
    
    Ȃ̍I܂B
    s getpcmdata() ĂяoĂf[^擾ł܂B
    
    
===============================================================================
    void fadeout(int speed);
    procedure fadeout(speed : Integer);
-------------------------------------------------------------------------------
    input
        speed       tF[hAEg̑x(P`PQV)
    output          Ȃ
-------------------------------------------------------------------------------
    
    Ȃ̃tF[hAEgs܂(PMD ݊)
    speed ͂P`PQVŁA傫قǑȂ܂B
    
    
===============================================================================
    void fadeout2(int speed);
    procedure fadeout2(speed : Integer);
-------------------------------------------------------------------------------
    input
        speed       tF[hAEg܂ł̎(ms PʁA1`2147483647)
    output          Ȃ
-------------------------------------------------------------------------------
    
    Ȃ̃tF[hAEgs܂()
    speed ̓tF[hAEg܂ł̎(ms P)w肵܂B
    
    
===============================================================================
    void getpcmdata(short *buf, int nsamples);
    procedure getpcmdata(buf : PSmallInt; nsamples : Integer);
-------------------------------------------------------------------------------
    input
        buf         PCM f[^i[obt@̃|C^
        nsamples    擾Tv
    output          Ȃ
-------------------------------------------------------------------------------
    
    PMDWin.dll ōꂽ PCM f[^擾܂B
    music_start() ŋȂ̉tJnĂȂɂ͖f[^擾܂B
     PCM f[^ 16bit, stereo, setpcmrate() Ŏw肵głB
    obt@TCÝAnsamples * 4(bytes)KvłB
    ̊֐Ŏ擾 PCM f[^vCōĐĂB
    
    ex) setpcmrate(SOUND_44K);      // 44.1kHz w
        getpcmdata(buf, 44100);     // 1b̃f[^ buf Ɏ擾
                                    // ([N̓ePbi݂܂)
    
    ̊֐ĂяoƂɃ[N̕ύXs܂B
    @r[A[Ń[Ñf[^\ꍇ́AÂǂݏoȂ
    @\ȂȂĂ܂܂B


===============================================================================
    void setppsinterpolation(bool ip);
    procedure setppsinterpolation(ip : Boolean);
-------------------------------------------------------------------------------
    input
        ip          ꎟԂsȂ true
    output          Ȃ
-------------------------------------------------------------------------------
    
    PPS p[gňꎟԂsǂw肵܂B
    ꎟԂsƉ͏オ܂AdȂ܂B
    
    
===============================================================================
    void setp86interpolation(bool ip);
    procedure setp86interpolation(ip : Boolean);
-------------------------------------------------------------------------------
    input
        ip          ꎟԂsȂ true
    output          Ȃ
-------------------------------------------------------------------------------
    
    P86 p[gňꎟԂsǂw肵܂B
    ꎟԂsƉ͏オ܂AdȂ܂B
    
    
===============================================================================
    void setppzinterpolation(bool ip);
    procedure setppzinterpolation(ip : Boolean);
-------------------------------------------------------------------------------
    input
        ip          ꎟԂsȂ true
    output          Ȃ
-------------------------------------------------------------------------------
    
    PPZ8 p[gňꎟԂsǂw肵܂B
    ꎟԂsƉ͏オ܂AdȂ܂B
    
    
===============================================================================
    char *getmemo(char *dest, uchar *musdata, int size, int al);
    function getmemo(dest : PChar; musdata : Pointer; size, al : Integer)
        : PChar;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
        musdata     ȃf[^̃|C^
        size        ȃf[^̃TCY
        al          擾̎
    output          dest Ɠ
-------------------------------------------------------------------------------

    擾܂B
    musdata = NULL ܂ size = 0 ̏ꍇ PMDWin.dll ɓǂݍ܂
    ȃf[^̕擾Ȃ̏ꍇ musdata  size 
    w肳郁̋ȃf[^̃擾܂B
    dest Ŏw肳obt@ 1024 oCgȏmۂĉB
    
    ԍƒ`ȇΉ͈ȉ̒ʂłB
        AL      `
        -2      #PPZFile(1,2pBMMLɋLq񂻂̂܂)
        -1      #PPSFile
         0      #PCMFile ܂ #PPCFile
         1      #Title
         2      #Composer
         3      #Arranger
         4      #Memo(1)
         5      #Memo(2)
         :
         :
    
    getlength(), getlength2() ̂̂ǂ炩 getmemo(), getmemo2(),
    getmemo3(), fgetmemo(), fgetmemo2(), fgetmemo3() ̂̂ЂƂA
    ̊֐̑gݍ킹̂݁Aʂ̃Xbh瓯Ɏsł܂B
    
    
===============================================================================
    char *getmemo2(char *dest, uchar *musdata, int size, int al);
    function getmemo2(dest : PChar; musdata : Pointer; size, al : Integer)
        : PChar;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
        musdata     ȃf[^̃|C^
        size        ȃf[^̃TCY
        al          擾̎
    output          dest Ɠ
-------------------------------------------------------------------------------
    
    getmemo ƂقړlłAQoCgpʏ̔p
    ϊĎ擾܂B
    dest Ŏw肳obt@ 1024 oCgȏmۂĉB
    
    getlength(), getlength2() ̂̂ǂ炩 getmemo(), getmemo2(),
    getmemo3(), fgetmemo(), fgetmemo2(), fgetmemo3() ̂̂ЂƂA
    ̊֐̑gݍ킹̂݁Aʂ̃Xbh瓯Ɏsł܂B


===============================================================================
    char *getmemo3(char *dest, uchar *musdata, int size, int al);
    function getmemo3(dest : PChar; musdata : Pointer; size, al : Integer)
        : PChar;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
        musdata     ȃf[^̃|C^
        size        ȃf[^̃TCY
        al          擾̎
    output          dest Ɠ
-------------------------------------------------------------------------------
    
    getmemo2 ɉĂɃGXP[vV[PX̏s܂B
    dest Ŏw肳obt@ 1024 oCgȏmۂĉB
    
    getlength(), getlength2() ̂̂ǂ炩 getmemo(), getmemo2(),
    getmemo3(), fgetmemo(), fgetmemo2(), fgetmemo3() ̂̂ЂƂA
    ̊֐̑gݍ킹̂݁Aʂ̃Xbh瓯Ɏsł܂B


===============================================================================
    int fgetmemo(char *dest, char *filename, int al);
    function fgetmemo(dest : PChar; filename : PChar; al : Integer) : Integer;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
        filename    ȃf[^̃t@CitpXj
        al          擾̎
    output          L̖߂lQ
-------------------------------------------------------------------------------

    擾܂B
    t@CŎw肷ȊO getmemo ƓłB
    filename = NULL ̏ꍇ PMDWin.dll ɓǂݍ܂Ăȃf[^
    擾Ȃ̏ꍇ filename Ŏw肳ȃf[^
    擾܂B
    dest Ŏw肳obt@ 1024 oCgȏmۂĉB

    ߂lF
        PMDWIN_OK                   I
        ERR_OPEN_MUSIC_FILE          f[^JȂ
        ERR_OUT_OF_MEMORY           s

    getlength(), getlength2() ̂̂ǂ炩 getmemo(), getmemo2(),
    getmemo3(), fgetmemo(), fgetmemo2(), fgetmemo3() ̂̂ЂƂA
    ̊֐̑gݍ킹̂݁Aʂ̃Xbh瓯Ɏsł܂B


===============================================================================
    int fgetmemo2(char *dest, char *filename, int al);
    function fgetmemo2(dest : PChar; filename : PChar; al : Integer) : Integer;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
        filename    ȃf[^̃t@CitpXj
        al          擾̎
    output          fgetmemo() Ɠ
-------------------------------------------------------------------------------

    fgetmemo ƂقړlłAQoCgpʏ̔p
    ϊĎ擾܂B
    dest Ŏw肳obt@ 1024 oCgȏmۂĉB
    
    getlength(), getlength2() ̂̂ǂ炩 getmemo(), getmemo2(),
    getmemo3(), fgetmemo(), fgetmemo2(), fgetmemo3() ̂̂ЂƂA
    ̊֐̑gݍ킹̂݁Aʂ̃Xbh瓯Ɏsł܂B


===============================================================================
    int fgetmemo3(char *dest, char *filename, int al);
    function fgetmemo3(dest : PChar; filename : PChar; al : Integer) : Integer;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
        filename    ȃf[^̃t@CitpXj
        al          擾̎
    output          fgetmemo() Ɠ
-------------------------------------------------------------------------------

    fgetmemo2 ɉĂɃGXP[vV[PX̏s܂B
    dest Ŏw肳obt@ 1024 oCgȏmۂĉB
    
    getlength(), getlength2() ̂̂ǂ炩 getmemo(), getmemo2(),
    getmemo3(), fgetmemo(), fgetmemo2(), fgetmemo3() ̂̂ЂƂA
    ̊֐̑gݍ킹̂݁Aʂ̃Xbh瓯Ɏsł܂B


===============================================================================
    char *getmusicfilename(char *dest);
    function getmusicfilename(dest : PChar) : PChar;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
    output          dest Ɠ
-------------------------------------------------------------------------------
    
    PMDWin.dll ɓǂݍ܂Ăȃf[^̃t@C(tpX)
    擾܂B
    
    
===============================================================================
    char *getpcmfilename(char *dest);
    function getpcmfilename(dest : PChar) : PChar;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
    output          dest Ɠ
-------------------------------------------------------------------------------
    
    PMDWin.dll ɓǂݍ܂Ă PPC/P86 ̃t@C(tpX)
    擾܂(P86 gpĂꍇ P86 ̃t@CAgp
    ȂꍇPPC ̃t@C擾܂)
    
    
===============================================================================
    char *getppcfilename(char *dest);
    function getppcfilename(dest : PChar) : PChar;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
    output          dest Ɠ
-------------------------------------------------------------------------------
    
    PMDWin.dll ɓǂݍ܂Ă PPC ̃t@C(tpX)
    擾܂B
    
    
===============================================================================
    char *getppsfilename(char *dest);
    function getppsfilename(dest : PChar) : PChar;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
    output          dest Ɠ
-------------------------------------------------------------------------------
    
    PMDWin.dll ɓǂݍ܂Ă PPS ̃t@C(tpX)
    擾܂B
    
    
===============================================================================
    char *getp86filename(char *dest);
    function getp86filename(dest : PChar) : PChar;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
    output          dest Ɠ
-------------------------------------------------------------------------------
    
    PMDWin.dll ɓǂݍ܂Ă P86 ̃t@C(tpX)
    擾܂B
    
    
===============================================================================
    char *getppzfilename(char *dest, int bufnum);
    function getppzfilename(dest : PChar; bufnum : Integer) : PChar;
-------------------------------------------------------------------------------
    input
        dest        擾i[AhX̃|C^
        bufnum      obt@ԍ(0 ܂ 1)
    output          dest Ɠ
-------------------------------------------------------------------------------
    
    PMDWin.dll ɓǂݍ܂Ă PPZ8  PCM t@C(tpX)
    擾܂B
    
    
===============================================================================
    int ppc_load(char *filename);
    function ppc_load(filename : PChar) : Integer;
-------------------------------------------------------------------------------
    input
        filename    PPC ̃t@C
    output          L̖߂lQ
-------------------------------------------------------------------------------
    
    t@CŎ PPC f[^ I PMDWin.dll ɓǂݍ݂܂B
    (ȃf[^Ŏw肳Ăꍇ music_load() 邢 music_load2() 
    @ɓǂݍ܂̂Œʏ͗pKv͂܂)
    t@C̓tpXŎw肵ĂBsetpcmdir() Ŏw肳ꂽ
    fBNǧ͍s܂B
    
    ߂lF
        PMDWIN_OK                   I
        ERR_OPEN_PPC_FILE           PPC JȂ
        ERR_WRONG_PPC_FILE          PPC ُ
        WARNING_PPC_ALREADY_LOAD    PPC ͊ɓǂݍ܂Ă
        ERR_OUT_OF_MEMORY           s


===============================================================================
    int pps_load(char *filename);
    function pps_load(filename : PChar) : Integer;
-------------------------------------------------------------------------------
    input
        filename    PPS ̃t@C
    output          L̖߂lQ
-------------------------------------------------------------------------------
    
    t@CŎ PPS f[^ I PMDWin.dll ɓǂݍ݂܂B
    (ȃf[^Ŏw肳Ăꍇmusic_load() 邢 music_load2() 
    @ɓǂݍ܂̂Œʏ͗pKv͂܂)
    t@C̓tpXŎw肵ĂBsetpcmdir() Ŏw肳ꂽ
    fBNǧ͍s܂B
    
    ߂lF
        PMDWIN_OK                   I
        ERR_OPEN_PPS_FILE           PPS JȂ
        WARNING_PPS_ALREADY_LOAD    PPS ͊ɓǂݍ܂Ă
        ERR_OUT_OF_MEMORY           s
        ERR_OTHER                   ̑̃G[
                                    (oꍇ͘A肢܂)


===============================================================================
    int p86_load(char *filename);
    function p86_load(filename : PChar) : Integer;
-------------------------------------------------------------------------------
    input
        filename    P86 ̃t@C
    output          L̖߂lQ
-------------------------------------------------------------------------------
    
    t@CŎ P86 f[^ I PMDWin.dll ɓǂݍ݂܂B
    (ȃf[^Ŏw肳Ăꍇ music_load() 邢 music_load2() 
    @ɓǂݍ܂̂Œʏ͗pKv͂܂)
    t@C̓tpXŎw肵ĂBsetpcmdir() Ŏw肳ꂽ
    fBNǧ͍s܂B
    
    ߂lF
        PMDWIN_OK                   I
        ERR_OPEN_P86_FILE           P86 JȂ
        ERR_WRONG_P86_FILE          P86 ُ
        WARNING_P86_ALREADY_LOAD    P86 ͊ɓǂݍ܂Ă
        ERR_OUT_OF_MEMORY           s
        ERR_OTHER                   ̑̃G[
                                    (oꍇ͘A肢܂)


===============================================================================
    int ppz_load(char *filename, int bufnum);
    function ppz_load(filename : PChar; bufnum : Integer) : Integer;
-------------------------------------------------------------------------------
    input
        filename    PPZ ̃t@C
        bufnum      obt@ԍ(0 ܂ 1)
    output          L̖߂lQ
-------------------------------------------------------------------------------
    
    t@CŎ PPZ f[^ I PMDWin.dll ɓǂݍ݂܂B
    (ȃf[^Ŏw肳Ăꍇ music_load() 邢 music_load2() 
    @ɓǂݍ܂̂Œʏ͗pKv͂܂)
    t@C̓tpXŎw肵ĂBsetpcmdir() Ŏw肳ꂽ
    fBNǧ͍s܂B
    
    ߂lF
        PMDWIN_OK                   I
        ERR_OPEN_PPZ1_FILE          PPZ(Buffer 1)JȂ
        ERR_OPEN_PPZ2_FILE          PPZ(Buffer 2)JȂ
        ERR_WRONG_PPZ1_FILE         PPZ(Buffer 1)ُ
        ERR_WRONG_PPZ2_FILE         PPZ(Buffer 2)ُ
        WARNING_PPZ1_ALREADY_LOAD   PPZ(Buffer 1)͊ɓǂݍ܂Ă
        WARNING_PPZ2_ALREADY_LOAD   PPZ(Buffer 2)͊ɓǂݍ܂Ă
        ERR_OUT_OF_MEMORY           s
        ERR_OTHER                   ̑̃G[
                                    (oꍇ͘A肢܂)
    
    
===============================================================================
    int maskon(int ch);
    function maskon(ch : Integer) : Integer;
-------------------------------------------------------------------------------
    input
        ch          }XN`l(O`QR)
    output          L̖߂lQ
-------------------------------------------------------------------------------

    p[g}XN܂B
    `lԍƃp[g̑Ή͈ȉ̂ƂłB
    
        0`5    FM1 (A)`FM6(F)
        6`8    SSG1(G)`SSG3(I)
        9       ADPCM(J)
        10      Yp[g(K)
        11`13  FMEx1`FMEx3
        14      RhythmS
        15      Ȃ
        16`23  PPZ1`PPZ8
        
        
    ߂lF
        PMDWIN_OK                   I
        ERR_WRONG_PARTNO            p[gԍُ
    
    
===============================================================================
    int maskoff(int ch);
    function maskoff(ch : Integer) : Integer;
-------------------------------------------------------------------------------
    input
        ch          }XN`l(O`QR)
    output          L̖߂lQ
-------------------------------------------------------------------------------
    
    p[g}XN܂B
    `lԍ maskon() ƓlłB
    
        ߂lF
            PMDWIN_OK                   I
            ERR_WRONG_PARTNO            p[gԍُ
            ERR_NOT_MASKED              wp[g̓}XNĂȂ
            ERR_EFFECT_USED             wp[g͌ʉŎgp
            ERR_MUSIC_STOPPED           Ȃ~܂Ă
    
    
===============================================================================
    void setfmvoldown(int voldown);
    procedure setfmvoldown(voldown : Integer);
-------------------------------------------------------------------------------
    input
        voldown     elp[g̉ʕ␳l(O`QTT)
    output          Ȃ
-------------------------------------------------------------------------------
    
    FM p[g̉ʂw肵l܂B
    
    
===============================================================================
    void setssgvoldown(int voldown);
    procedure setssgvoldown(voldown : Integer);
-------------------------------------------------------------------------------
    input
        voldown     rrfp[g̉ʕ␳l(O`QTT)
    output          Ȃ
-------------------------------------------------------------------------------
    
    SSG p[g̉ʂw肵l܂B
    
    
===============================================================================
    void setrhythmvoldown(int voldown);
    procedure setrhythmvoldown(voldown : Integer);
-------------------------------------------------------------------------------
    input
        voldown     OPNA Ỷʕ␳l(O`QTT)
    output          Ȃ
-------------------------------------------------------------------------------
    
    OPNA Ỷʂw肵l܂B
    
    
===============================================================================
    void setadpcmvoldown(int voldown);
    procedure setadpcmvoldown(voldown : Integer);
-------------------------------------------------------------------------------
    input
        voldown     ADPCM ̉ʕ␳l(O`QTT)
    output          Ȃ
-------------------------------------------------------------------------------
    
    ADPCM ̉ʂw肵l܂B
    
    
===============================================================================
    void setppzvoldown(int voldown);
    procedure setppzvoldown(voldown : Integer);
-------------------------------------------------------------------------------
    input
        voldown     PPZ8 ̉ʕ␳l(O`QTT)
    output          Ȃ
-------------------------------------------------------------------------------
    
    PPZ8 ̉ʂw肵l܂B
    
    
===============================================================================
    int getfmvoldown(void);
    function getfmvoldown : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          elp[g̉ʕ␳l(O`QTT)
-------------------------------------------------------------------------------
    
    FM p[g̉ʕ␳l(MML Ŏw肳ꂽlBw肳ĂȂꍇ
    setfmvoldown() Ŏw肵l)擾܂B
    
    
===============================================================================
    int getfmvoldown2(void);
    function getfmvoldown2 : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          elp[g̉ʕ␳l(O`QTT)
-------------------------------------------------------------------------------
    
    FM p[g̉ʕ␳l(setfmvoldown() Ŏw肵l)擾܂B
    
    
===============================================================================
    int getssgvoldown(void);
    function getssgvoldown : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          rrfp[g̉ʕ␳l(O`QTT)
-------------------------------------------------------------------------------
    
    SSG p[g̉ʕ␳l(MML Ŏw肳ꂽlBw肳ĂȂꍇ
    setssgvoldown() Ŏw肵l)擾܂B
    
    
===============================================================================
    int getssgvoldown2(void);
    function getssgvoldown2 : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          rrfp[g̉ʕ␳l(O`QTT)
-------------------------------------------------------------------------------
    
    SSG p[g̉ʕ␳l(setssgvoldown() Ŏw肵l)擾܂B
    
    
===============================================================================
    int getrhythmvoldown(void);
    function getrhythmvoldown : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          OPNA Ỷʕ␳l(O`QTT)
-------------------------------------------------------------------------------
    
    OPNA Ỷʕ␳l(MML Ŏw肳ꂽlBw肳ĂȂꍇ
    setrhythmvoldown() Ŏw肵l)擾܂B
    
    
===============================================================================
    int getrhythmvoldown2(void);
    function getrhythmvoldown2 : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          OPNA Ỷʕ␳l(O`QTT)
-------------------------------------------------------------------------------
    
    OPNA Ỷʕ␳l(setrhythmvoldown() Ŏw肵l)
    擾܂B
    
    
===============================================================================
    int getadpcmvoldown(void);
    function getadpcmvoldown : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          ADPCM ̉ʕ␳l(O`QTT)
-------------------------------------------------------------------------------
    
    ADPCM ̉ʕ␳l(MML Ŏw肳ꂽlBw肳ĂȂꍇ
    setadpcmvoldown() Ŏw肵l)擾܂B
    
    
===============================================================================
    int getadpcmvoldown2(void);
    function getadpcmvoldown2 : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          ADPCM ̉ʕ␳l(O`QTT)
-------------------------------------------------------------------------------
    
    ADPCM ̉ʕ␳l(setadpcmvoldown() Ŏw肵l)擾܂B
    
    
===============================================================================
    int getppzvoldown(void);
    function getppzvoldown : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          PPZ8 ̉ʕ␳l(O`QTT)
-------------------------------------------------------------------------------
    
    PPZ8 ̉ʕ␳l(MML Ŏw肳ꂽlBw肳ĂȂꍇ
    setppzvoldown() Ŏw肵l)擾܂B
    
    
===============================================================================
    int getppzvoldown2(void);
    function getppzvoldown2 : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          PPZ8 ̉ʕ␳l(O`QTT)
-------------------------------------------------------------------------------
    
    PPZ8 ̉ʕ␳l(setppzvoldown() Ŏw肵l)擾܂B
    
    
===============================================================================
    void setpos(int pos);
    procedure setpos(pos : Integer);
-------------------------------------------------------------------------------
    input           Đʒu(ms P)
    output          Ȃ
-------------------------------------------------------------------------------
    
    tw肵ʒu(ms P)ɃXLbv܂B
    
    
===============================================================================
    void setpos2(int pos);
    procedure setpos2(pos : Integer);
-------------------------------------------------------------------------------
    input           Đʒu(TimerB count P)
    output          Ȃ
-------------------------------------------------------------------------------
    
    tw肵ʒu(TimerB count P)ɃXLbv܂B
    
    
===============================================================================
    int getpos(void);
    function getpos : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          Đʒu(ms P)
-------------------------------------------------------------------------------
    
    tJn̍Đʒu(ms P)擾܂B
    
    
===============================================================================
    int getpos2(void);
    function getpos2 : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          Đʒu(TimerB count P)
-------------------------------------------------------------------------------
    
    tJn̍Đʒu(TimerB count P)擾܂B
    
    
===============================================================================
    bool getlength(char *filename, int *length, int *loop);
    function getlength(filename : PChar;
        var length : Integer; var loop : Integer) : Boolean;
-------------------------------------------------------------------------------
    input
        filename    擾ȃf[^̃t@C(tpX)
    output
        ߂l      t@Cǂ߂ĐɎ擾ł true
        length      P[vڂ̒(ms P)
        loop        Q[vڈȍ~̂P[v̒(ms P)
-------------------------------------------------------------------------------
    
    filename Ŏw肳Ȃ̒(ms P)擾܂B
    length łP[vڂ̒Aloop łQ[vڈȍ~̂P[v̒
    擾܂BQ[vvZ邽ߑdłB
    
    getlength, getlength2 ̂̂ǂ炩 getmemo, getmemo2, getmemo3
    ̂̂ЂƂÅ֐̑gݍ킹̂݁Aʂ̃Xbh瓯
    sł܂B


===============================================================================
    bool getlength2(char *filename, int *length, int *loop);
    function getlength2(filename : PChar;
        var length : Integer; var loop : Integer) : Boolean;
-------------------------------------------------------------------------------
    input
        filename    擾ȃf[^̃t@C(tpX)
    output
        ߂l      t@Cǂ߂ĐɎ擾ł true
        length      P[vڂ̒(TimerB count P)
        loop        Q[vڈȍ~̂P[v̒(TimerB count P)
-------------------------------------------------------------------------------
    
    filename Ŏw肳Ȃ̒(TimerB count P)擾܂B
    length łP[vڂ̒Aloop łQ[vڈȍ~̂P[v̒
    擾܂BQ[vvZ邽ߑdłB
    
    getlength, getlength2 ̂̂ǂ炩 getmemo, getmemo2, getmemo3
    ̂̂ЂƂÅ֐̑gݍ킹̂݁Aʂ̃Xbh瓯
    sł܂B


===============================================================================
    int getloopcount(void);
    function getloopcount : Integer;
-------------------------------------------------------------------------------
    input           Ȃ
    output          [v
-------------------------------------------------------------------------------
    
    ݂̃[v񐔂擾܂B
    
    ߂lF
        -1                          t~
        0ȏ                       [v
    
    
===============================================================================
    void setfmwait(int nsec);
    function setfmwait(nsec : Integer);
-------------------------------------------------------------------------------
    input           wait(nsec P)
    output          Ȃ
-------------------------------------------------------------------------------
    
    FM p[g̃WX^Ƀf[^o͂O wait ݒ肵܂B
    ftHg 15000 łBʏ͕ύXKv͂܂B


===============================================================================
    void setssgwait(int nsec);
    function setssgwait(nsec : Integer);
-------------------------------------------------------------------------------
    input           wait(nsec P)
    output          Ȃ
-------------------------------------------------------------------------------
    
    SSG p[g̃WX^Ƀf[^o͂O wait ݒ肵܂B
    ftHg 15000 łBʏ͕ύXKv͂܂B


===============================================================================
    void setrhythmwait(int nsec);
    function setrhythmwait(nsec : Integer);
-------------------------------------------------------------------------------
    input           wait(nsec P)
    output          Ȃ
-------------------------------------------------------------------------------
    
    OPNA Yp[g̃WX^Ƀf[^o͂O wait ݒ肵܂B
    ftHg 15000 łBʏ͕ύXKv͂܂B


===============================================================================
    void setadpcmwait(int nsec);
    function setadpcmwait(nsec : Integer);
-------------------------------------------------------------------------------
    input           wait(nsec P)
    output          Ȃ
-------------------------------------------------------------------------------
    
    ADPCM p[g̃WX^Ƀf[^o͂O wait ݒ肵܂B
    ftHg 15000 łBʏ͕ύXKv͂܂B


===============================================================================
    OPEN_WORK *getopenwork(void);
    function getopenwork : POPEN_WORK;
-------------------------------------------------------------------------------
    input           Ȃ
    output          ŠJ[Ñ|C^
-------------------------------------------------------------------------------
    ŠJ[Ñ|C^擾܂B
    
    [Nւ݂͍̏sȂŉB
    OPEN_WORK ̍\͍ύX\܂B


===============================================================================
    QQ *getpartwork(int ch);
    function getpartwork(ch : Integer) : PQQ;
-------------------------------------------------------------------------------
    input
        ch          p[g[N擾`l(O`QR)
    output          p[g[Ñ|C^
-------------------------------------------------------------------------------
    
    wp[g̃[Ñ|C^擾܂B
    `lԍƃp[g̑Ή maskon() ƓłB
    p[g[Ñ|C^擾łȂꍇɂ NULL Ԃ܂B
    
    [Nւ݂͍̏sȂŉB
    
    

------------------------------------------------------------------------------
A

    E-mail                  HQD00151@nifty.com
    Homepage                http://c60.la.coocan.jp/
    Twitter                 c60fmp



                                                                bUO
