home *** CD-ROM | disk | FTP | other *** search
/ FreeWare Collection 3 / FreeSoftwareCollection3pd199x-jp.img / pao / ms_dos / cdplay / src / cdtape.c < prev    next >
Text File  |  1980-01-02  |  44KB  |  1,784 lines
  1. /** << MSC V5.1 >> ************************************************************
  2. **
  3. **    ＣＤダビング助さん
  4. **
  5. **    < note > : TABS = 4
  6. **
  7. **    CREATE : 1990.08.12
  8. **    FINISH : 1990.08.12  Version 0.50
  9. **
  10. **    ----- HISTORY -----
  11. **    1990.08.12 : CREATE
  12. **    1990.08.15 : CDCに対してむやみに命令を発行(BIOS使用だけど･･･)してしまうと
  13. **                 音飛びやいろいろな悪影響を及ぼすみたいなので、ﾀｲﾐﾝｸﾞをとる
  14. **                 ようにした。
  15. **    1990.08.15 : ﾌﾟﾛｸﾞﾗﾑ起動時に演奏中であれば、ﾒｯｾｰｼﾞを出力するようにした。
  16. **                 ｷｰ入力の処理をﾏﾄﾘｸｽにした。
  17. **                 また、操作ｷｰの一部変更を行った｡
  18. **    1990.08.21 : ｷｰ入力 & ｺﾝｿｰﾙ出力を BIOS で行うようにした。
  19. **                 ｷｰﾘﾋﾟｰﾄ及びｷｰが押されたままの制御,画面の表示変更等を行った｡
  20. **                 また、いろいろなBIOSを使用することによってBEEP音を鳴らすよう
  21. **                 にしたりと細々とした修正をした。
  22. **    1990.08.23 : CD-ROMで、演奏できないﾃﾞｰﾀ部分にはｶｰｿﾙ移動できないようにした。
  23. **    1990.08.26 : FF/REVの操作性を向上した。
  24. **
  25. **    Programed by Y.Hirata ( Nifty ID : NAB03321 )
  26. **
  27. ******************************************************************************/
  28.  
  29. #include "cdr.h"
  30. #include "cdtape.h"
  31. #include "evol.h"
  32. #include "kyb.h"
  33. #include "crt.h"
  34. #include "cdtime.h"
  35. #include "cdtdisp.h"
  36.  
  37. #define        Cddrv        0                /*  ＣＤドライブ番号 ( 0 - 6 )    */
  38.                                         /*  TOWNSでは Cddrv=0 のみ        */
  39. int        Cdtype ;                        /*    ＣＤタイプ                    */
  40.                                         /*    = 0 : なし                    */
  41.                                         /*    = 1 : CD-DA                    */
  42.                                         /*    = 2 : DATA                    */
  43.                                         /*    = 3 : CD-DA & DATA            */
  44. int        Sttrack ;                        /*    先頭トラック(曲)番号        */
  45. int        Endtrack ;                        /*    最終トラック(曲)番号        */
  46. int        Status ;                        /*    音楽の演奏状態                */
  47. int        Nowmusicno ;                    /*    現在演奏中の曲番号            */
  48.  
  49. char    SideAon[99] ;                    /*  = 1 : A面に録音                */
  50. int        Tapetime ;                        /*  選択したﾃｰﾌﾟ時間(ﾃｰﾌﾟ種類)    */
  51.  
  52. TOC Trtime[99],Endtime,Disctime,Nowtime,Usest,Useet,Trtime2[99] ;
  53. TOC Totaltime,Datatime,SideAtime,Sidetotal ;
  54. /*
  55. **    Trtime[99] : 各トラックの演奏開始時間
  56. **    Endtime    : ディスク内演奏終了時間
  57. **    Disctime   : ディスク内演奏時間
  58. **    Nowtime    : 演奏中のトラック内演奏時間
  59. **    Usest      : 演奏開始指定時間
  60. **    Useet      : 演奏終了指定時間
  61. **    Trtime2    : 各トラックの演奏時間
  62. **    Totaltime  : 全トラック時間
  63. **    Datatime   : ﾃﾞｰﾀ部分の合計時間
  64. **    SideAtime  : A面選択分の合計時間
  65. **    Sidetotal  : ﾃｰﾌﾟの片面時間
  66. */
  67.  
  68. struct _CDFLG {
  69.     char    ready ;                /*  CD はREADY状態か？                        */
  70.     char    change ;            /*  CD が入れ換えられたか？                    */
  71.     char    stop ;                /*  STOPするのか？                            */
  72.     char    mute ;                /*  ミュートしているのか？                    */
  73.     char    tape ;                /*  ﾃｰﾌﾟ選択済か？                            */
  74.     char    time ;                /*  時間表示切り換え用 : TRUE = 標準        */
  75. } CDflg ;
  76.  
  77. char        Trdata[20][81] ;    /*  各曲時間表示用                            */
  78. char        Strbuf[81] ;        /*  文字列表示用                            */
  79.  
  80. int            CURx = CUR_X0 ;                            /*  カーソル位置X        */
  81. int            CURy = CUR_Y0 ;                            /*  カーソル位置Y        */
  82.  
  83. int            CDnows = FALSE ;    /*  現在のCDの状態 : 0 - 停止中                */
  84.                                 /*                     1 - 演奏中                */
  85.  
  86. unsigned char Evol = VOL_MAX ;    /*  電子ﾎﾞﾘｭｰﾑ  0 ～ 63                        */
  87.  
  88. /***************************  ＣＤ情報の取得  ********************************/
  89. int cdinfo()
  90. {
  91.     return(
  92.         CDR_cdinfo
  93.         ( Cddrv,&Cdtype,&Sttrack,&Endtrack,(char *)Trtime,(char *)&Endtime )
  94.     ) ;
  95. }
  96.  
  97. /*******************************  ＣＤ演奏  **********************************/
  98. /*                
  99. **    <input>        : count - 演奏回数(リピート)
  100. */
  101. int mtrplay( unsigned char count )
  102. {
  103.     return(
  104.         CDR_mtrplay( Cddrv,(char *)&Usest,(char *)&Useet,count )
  105.     ) ;
  106. }
  107.  
  108. /***************************  ＣＤ演奏状態の取得  ****************************/
  109. int mphase()
  110. {
  111.     return(
  112.         CDR_mphase
  113.         ( Cddrv,&Status,&Nowmusicno,(char *)&Nowtime,(char *)&Disctime )
  114.     ) ;
  115. }
  116.  
  117. /***************************  演奏開始時間の設定  ****************************/
  118. /*
  119. **    <input>        : trackno - 演奏開始トラック(曲番号)
  120. */
  121. void usestset( int trackno )
  122. {
  123.     if ( trackno<Sttrack )    trackno = Sttrack ;
  124.     if ( trackno>Endtrack )    trackno = Endtrack ;
  125.  
  126.     if ( Cdtype==3 && trackno==Sttrack ) trackno++ ;
  127.  
  128.     Usest.sec   = Trtime[trackno-1].sec ;
  129.     Usest.min   = Trtime[trackno-1].min ;
  130.     Usest.frame = Trtime[trackno-1].frame ;
  131.  
  132.     return ;
  133. }
  134.  
  135. /*************************  演奏終了時間の設定  ******************************/
  136. /*
  137. **    <input>        : trackno - 演奏終了トラック(曲番号)
  138. */
  139. void useetset( int trackno )
  140. {
  141.     char    minw, secw, framew ;
  142.  
  143. /*    frame : 0 - 74 : 75frame=1sec    */
  144.  
  145.     if ( trackno<Sttrack ) trackno = Sttrack ;
  146.     if ( Cdtype==3 && trackno==Sttrack ) trackno++ ;
  147. /*
  148. **    最後の曲まで(または最後の曲だけを)演奏した～い時には、
  149. **    演奏終了時間の指定に注意しましょう！
  150. **
  151. **    ※ 演奏終了時間は、ディスク内演奏終了時間から 1 フレーム引いた値を指定
  152. **       しないとだめだよ！
  153. */
  154.     if ( trackno >= Endtrack ) {                /*  最終曲が指定された時    */
  155.         trackno = Endtrack ;
  156.         framew = Endtime.frame ;
  157.         secw   = Endtime.sec ;
  158.         minw   = Endtime.min ;
  159.         subtime( minw,secw,framew,0,0,1,&minw,&secw,&framew ) ;
  160.                                                             /*  1ﾌﾚｰﾑ引く    */
  161.     } else {                                    /*  最終曲じゃない時        */
  162.         framew = Trtime[trackno].frame ;
  163.         secw   = Trtime[trackno].sec ;
  164.         minw   = Trtime[trackno].min ;
  165.     }
  166.  
  167.     Useet.frame = framew ;
  168.     Useet.sec = secw ;
  169.     Useet.min = minw ;
  170.  
  171.     return ;
  172. }
  173.  
  174. /*********************  CD の現在の状態をﾁｪｯｸします  *************************/
  175. int nowstatus()
  176. {
  177.     int    ret ;
  178.  
  179.     CDnows = NOW_STOP ;
  180.     CDflg.ready = FALSE ;
  181.  
  182.     ret = mphase() ;
  183.     if ( ret == CDERR7 ) {                            /*  CD が入れ換えられた    */
  184.         CDflg.change = TRUE ;
  185.     } else if ( !ret ) {
  186.         CDflg.ready = TRUE ;
  187.         if ( Status ) {                                            /*  演奏中    */
  188.             CDnows = NOW_PLAY ;
  189.         } else {                                                /*  停止中    */
  190.                 ;
  191.         }
  192.     }
  193.  
  194.     return( ret ) ;
  195. }
  196.  
  197. /****************************  ＴＯＣ情報の取得  *****************************/
  198. /*
  199. **    < RETURN > : = 0 - TOC 読み込み成功
  200. **                   1 - TOC 読み込み失敗
  201. */
  202. int tocread()
  203. {
  204.     int        errcnt, ret ;
  205.  
  206.     CDflg.tape = FALSE ;
  207.  
  208.     errcnt = 0 ;
  209.     do {
  210.         ret = cdinfo() ;
  211.         if ( ret == CDERR7 ) CDflg.change = TRUE ;
  212.         CDR_pause( Cddrv ) ;
  213.         errcnt++ ;
  214.     } while ( ret && errcnt<=RETRY ) ;
  215.     if ( errcnt > RETRY ) {                            /*  TOC 読み込み失敗！    */
  216.         CDflg.ready = FALSE ;
  217.         return( 1 ) ;
  218.     } else {                                        /*  TOC 読み込み成功♪    */
  219.         CDflg.ready = TRUE ;
  220.         return( 0 ) ;
  221.     }
  222.  
  223. }
  224.  
  225. /**************************  時間指定演奏処理  ******************************/
  226. /*                
  227. **    <input>        : repeat - 演奏回数(リピート)
  228. */
  229. void timeplay( int repeat )
  230. {
  231.     int        errcnt ;
  232.  
  233.     errcnt = 0 ;
  234.     do {
  235.         if ( CDR_pause( Cddrv ) == CDERR7 )
  236.             CDflg.change = TRUE ;
  237.         mtrplay( repeat ) ;                                 /*  演奏開始        */
  238.         if ( mphase() ) Status = FALSE ;
  239.         if ( ++errcnt >= RETRY ) {
  240.             errdisp( M_ERR ) ;
  241.             CRT_setcur( CURx,CURy ) ;
  242.             break ;
  243.         }
  244.     } while( !Status ) ;
  245.  
  246.     nowstatus() ;                                        /*  演奏状態取得    */
  247.  
  248.     return ;
  249. }
  250.  
  251. /**************************  ＣＤの演奏をします。 ****************************/
  252. /*
  253. **    <input>        : tocon   - =1(!=0) TOC 情報の取得をする。
  254. **                          =0      TOC 情報の取得はしない。
  255. **              : startno - 演奏開始曲番号
  256. **              : endno   - 演奏終了曲番号
  257. **              : repeat  - リピート回数
  258. **
  259. **    <return>    : = 0 - 正常終了
  260. **                : = 1 - エラー
  261. */
  262. int cdplay( int tocon, int startno, int endno, unsigned char repeat )
  263. {
  264.     int        err, ret ;
  265.  
  266.     err = FALSE ;
  267.  
  268.     if ( CDflg.ready ) {
  269.         /*  変なＣＤ-ＲＯＭは除く    */
  270.         if ( Endtrack<=0 || Endtrack>99 ) goto close ;
  271.         if ( Endtime.frame<=0 && Endtime.sec<=0 && Endtime.min<=0 )
  272.              goto close ;
  273.     }
  274.  
  275.     if ( tocon ) {
  276.         if ( tocread() ) {                            /*  TOC 読み込み失敗！    */
  277.             err = TRUE ;
  278.             goto close ;
  279.         } else {                                    /*  TOC 読み込み成功♪    */
  280. /*
  281. **    CDDA のないコンパクトディスクには用がないので、プログラム終了！
  282. */
  283.             if ( Cdtype!=1 && Cdtype!=3 ) {
  284.                 goto close ;
  285.             }
  286.         }
  287.     }
  288.     
  289.     if ( startno > endno ) {                            /*  パラメタエラー    */
  290.         err = TRUE ;
  291.         goto close ;
  292.     }
  293.  
  294.     usestset( startno ) ;                        /*  演奏開始曲データ設定    */
  295.     useetset( endno ) ;                            /*  演奏終了曲データ設定    */
  296.  
  297.     timeplay( repeat ) ;
  298.  
  299. close:
  300.     return( err ) ;
  301.  
  302. }
  303.  
  304. /**************************  各曲の時間を求める  *****************************/
  305. void timecalc()
  306. {
  307.     int        c ;
  308.     char    minw, min2, sec2, frame2 ;
  309.  
  310. /*    一番上のﾋﾞｯﾄがONの場合には、曲ではなくﾃﾞｰﾀである。    */
  311.  
  312.     Totaltime.min = Totaltime.sec = Totaltime.frame = 0 ;
  313.     Datatime.min = Datatime.sec = Datatime.frame = 0 ;
  314.  
  315.     for ( c=0; c<Endtrack; c++ ) {
  316.  
  317.         minw = Trtime[c].min ;
  318.         if ( ( minw & 0x80 ) == 0x80 ) minw &= 0x7f ;
  319.  
  320.         if ( c+1 < Endtrack ) {                        /*  次の曲が最終曲ﾖﾘ前    */
  321.             frame2 = Trtime[c+1].frame ;
  322.             sec2 = Trtime[c+1].sec ;
  323.             min2 = Trtime[c+1].min ;
  324.             if ( ( min2 & 0x80 ) == 0x80 ) min2 &= 0x7f ;
  325.         } else {                                    /*  次の曲が最終曲        */
  326.             frame2 = Endtime.frame ;
  327.             sec2 = Endtime.sec ;
  328.             min2 = Endtime.min ;
  329.             if ( ( min2 & 0x80 ) == 0x80 ) min2 &= 0x7f ;
  330.             subtime( min2,sec2,frame2,0,0,1,&min2,&sec2,&frame2 ) ;
  331.                                                             /*  1ﾌﾚｰﾑ引く    */
  332.         }
  333.         subtime( min2,sec2,frame2,minw,Trtime[c].sec,Trtime[c].frame,
  334.                 &Trtime2[c].min,&Trtime2[c].sec,&Trtime2[c].frame ) ;
  335.                                                         /*  曲時間取得        */
  336.         minw = Trtime[c].min ;
  337.         if ( ( minw & 0x80 ) != 0x80 ) {                /*  CD-DA だけ加算    */
  338.             addtime( Totaltime.min,Totaltime.sec,Totaltime.frame,
  339.                     Trtime2[c].min,Trtime2[c].sec,Trtime2[c].frame,
  340.                     &Totaltime.min,&Totaltime.sec,&Totaltime.frame ) ;
  341.                                                         /*  合計時間取得    */
  342.         } else {                                        /*  ﾃﾞｰﾀ部分の合計    */
  343.             addtime( Datatime.min,Datatime.sec,Datatime.frame,
  344.                     Trtime2[c].min,Trtime2[c].sec,Trtime2[c].frame,
  345.                     &Datatime.min,&Datatime.sec,&Datatime.frame ) ;
  346.                                                         /*  合計時間取得    */
  347.         }
  348.     }
  349.  
  350.     return ;
  351. }
  352.  
  353. /*****************************  ｺﾏﾝﾄﾞ情報表示  *******************************/
  354. void cmdisp()
  355. {
  356.     cmddisp( CMD_ESC,STD,HELP ) ;                        /*  ESC:END(STOP)    */
  357.  
  358.     cmddisp( CMD_SHELL,STD,HELP ) ;                        /*  !:SHELL            */
  359.  
  360.     cmddisp( CMD_SPACE,STD,HELP ) ;                        /*  空白:選択        */
  361.  
  362.     cmddisp( CMD_CR,STD,HELP ) ;                        /*  改行:演奏        */
  363.  
  364.     cmddisp( CMD_FF,STD,HELP ) ;                        /*  ^F:FF            */
  365.  
  366.     cmddisp( CMD_REV,STD,HELP ) ;                        /*  ^R:REV            */
  367.  
  368.     cmddisp( CMD_STOP,STD,HELP ) ;                        /*  P:STOP            */
  369.  
  370.     cmddisp( CMD_TIME,STD,HELP ) ;                        /*  T:Time            */
  371.  
  372.     CRT_setcur( CURx,CURy ) ;
  373.     return ;
  374. }
  375.  
  376. /**************************  ＣＤ情報再取得表示  *****************************/
  377. void reset()
  378. {
  379.     tocread() ;                                                /*  TOC READ    */
  380.  
  381.     CDflg.change = FALSE ;                            /*  CD入れ換え情報ｸﾘｱ    */
  382.  
  383.     CURx = CUR_X0 ;
  384.     CURy = CUR_Y0 ;
  385.     if ( Cdtype == 3 ) CURy ++ ;
  386.  
  387.     return ;
  388. }
  389.  
  390. /*************************  ﾃｰﾌﾟ選択情報(ﾃﾞﾌｫﾙﾄ)  ****************************/
  391. void deftape()
  392. {
  393.     int        c, ret ;
  394.     char    minw ;
  395.  
  396.     if ( CDflg.tape ) return ;
  397.  
  398.     timecalc() ;                                    /*  各曲時間を求める｡    */
  399.  
  400.     Tapetime = 0 ;
  401.     Sidetotal.min = Sidetotal.sec = Sidetotal.frame = 0 ;
  402.     for ( c=0; c<NTape; c++ ) {
  403.         ret = cmptime( Tape[c],Tape2[c]+Tape2[c],0,
  404.                     Totaltime.min,Totaltime.sec,Totaltime.frame ) ;
  405.         if ( ret > 0 ) {
  406.             Tapetime = Tape[c] ;                    /*  テープ標準時間        */
  407.             Sidetotal.min   = Tapetime / 2 ;        /*  録音可能片面時間    */
  408.             Sidetotal.sec   = Tape2[c] ;
  409.             Sidetotal.frame = 0 ;
  410.             if ( Tapetime % 2 ) Sidetotal.sec += 30 ;
  411.             if ( Sidetotal.sec >= 60 ) {
  412.                 Sidetotal.sec -= 60 ;
  413.                 Sidetotal.min ++ ;
  414.             }
  415.             break ;
  416.         }
  417.     }
  418.  
  419.  
  420.     SideAtime.min = SideAtime.sec = SideAtime.frame = 0 ;
  421.     for ( c=0; c<Endtrack; c++ ) {
  422.         minw = Trtime[c].min ;
  423.         SideAon[c] = FALSE ;
  424.         if ( ( minw & 0x80 ) != 0x80 ) {                /*  CD-DA ならば    */
  425.             addtime( SideAtime.min,SideAtime.sec,SideAtime.frame,
  426.                     Trtime2[c].min,Trtime2[c].sec,Trtime2[c].frame,
  427.                     &SideAtime.min,&SideAtime.sec,&SideAtime.frame ) ;
  428.                                                         /*  合計時間取得    */
  429.             ret = cmptime( SideAtime.min,SideAtime.sec,SideAtime.frame,
  430.                     Sidetotal.min,Sidetotal.sec,Sidetotal.frame ) ;
  431.             if ( ret > 0 ) {                            /*  片面時間ｵｰﾊﾞｰ    */
  432.                 subtime( SideAtime.min,SideAtime.sec,SideAtime.frame,
  433.                         Trtime2[c].min,Trtime2[c].sec,Trtime2[c].frame,
  434.                         &SideAtime.min,&SideAtime.sec,&SideAtime.frame ) ;
  435.             } else {
  436.                 SideAon[c] = TRUE ;
  437.             }
  438.         }
  439.     }
  440.     CDflg.tape = TRUE ;
  441.  
  442.     return ;
  443. }
  444.  
  445. /*************************  ﾃｰﾌﾟ選択合計時間表示  ****************************/
  446. void tapedisp()
  447. {
  448.     TOC        sideBtime, worktime ;
  449.  
  450.     int        c, ret, err ;
  451.     char    minw ;
  452.  
  453.     subtime( Totaltime.min,Totaltime.sec,Totaltime.frame,
  454.             SideAtime.min,SideAtime.sec,SideAtime.frame,
  455.             &sideBtime.min,&sideBtime.sec,&sideBtime.frame ) ;
  456. /*
  457. **    ﾃｰﾌﾟ変更の必要あり？　チェック！
  458. */
  459.     ret = cmptime( SideAtime.min,SideAtime.sec,SideAtime.frame,
  460.                 sideBtime.min,sideBtime.sec,sideBtime.frame) ;
  461.     if ( ret > 0 ) {                            /*  SideAtime > sideBtime    */
  462.         worktime.min   = SideAtime.min ;
  463.         worktime.sec   = SideAtime.sec ;
  464.         worktime.frame = SideAtime.frame ;
  465.     } else {
  466.         worktime.min   = sideBtime.min ;
  467.         worktime.sec   = sideBtime.sec ;
  468.         worktime.frame = sideBtime.frame ;
  469.     }
  470.  
  471.     err = TRUE ;
  472.     for ( c=0; c<NTape; c++ ) {
  473.         Tapetime = Tape[c] ;
  474.         Sidetotal.min   = Tapetime / 2 ;
  475.         Sidetotal.sec   = Tape2[c] ;
  476.         Sidetotal.frame = 0 ;
  477.         if ( Tapetime % 2 ) Sidetotal.sec += 30 ;
  478.         if ( Sidetotal.sec >= 60 ) {
  479.             Sidetotal.sec -= 60 ;
  480.             Sidetotal.min ++ ;
  481.         }
  482.  
  483.         ret = cmptime( Sidetotal.min,Sidetotal.sec,Sidetotal.frame,
  484.                     worktime.min,worktime.sec,worktime.frame) ;
  485.  
  486.         if ( ret >= 0 ) {                    /*  Tape(片面) >= 選択片面    */
  487.             err = FALSE ;
  488.             break ;
  489.         }
  490.     }
  491.  
  492.     CRT_setcur( MSG_X,MSG_Y ) ;
  493.     strdisp( " SIDE 1 ",STD,YELLOW ) ;
  494.  
  495.     strdisp( ">",STD,WHITE ) ;
  496.     if ( CDflg.time ) {
  497.         sprintf( Strbuf," %02d分%02d秒%02d",
  498.                 SideAtime.min,SideAtime.sec,SideAtime.frame ) ;
  499.         strdisp( Strbuf,STD,YELLOW ) ;
  500.     } else {
  501.         subtime( Sidetotal.min,Sidetotal.sec,Sidetotal.frame,
  502.                 SideAtime.min,SideAtime.sec,SideAtime.frame,
  503.                 &worktime.min,&worktime.sec,&worktime.frame ) ;
  504.         if ( err )
  505.             sprintf( Strbuf," [**分**秒**]" ) ;
  506.         else
  507.             sprintf( Strbuf," [%02d分%02d秒%02d]",
  508.                     worktime.min,worktime.sec,worktime.frame ) ;
  509.         strdisp( Strbuf,STD,YELLOW ) ;
  510.     }
  511.     strdisp( "  -  ",STD,WHITE ) ;
  512.  
  513.     strdisp( "SIDE 2 ",STD,GREEN ) ;
  514.     strdisp( ">",STD,WHITE ) ;
  515.     if ( CDflg.time ) {
  516.         sprintf( Strbuf," %02d分%02d秒%02d      ",
  517.                 sideBtime.min,sideBtime.sec,sideBtime.frame ) ;
  518.         strdisp( Strbuf,STD,GREEN ) ;
  519.     } else {
  520.         subtime( Sidetotal.min,Sidetotal.sec,Sidetotal.frame,
  521.                 sideBtime.min,sideBtime.sec,sideBtime.frame,
  522.                 &worktime.min,&worktime.sec,&worktime.frame ) ;
  523.         if ( err )
  524.             sprintf( Strbuf," [**分**秒**]  " ) ;
  525.         else
  526.             sprintf( Strbuf," [%02d分%02d秒%02d]  ",
  527.                     worktime.min,worktime.sec,worktime.frame ) ;
  528.         strdisp( Strbuf,STD,GREEN ) ;
  529.     }
  530.  
  531.     if ( err )
  532.         sprintf( Strbuf,"Tape[**]" ) ;
  533.     else
  534.         sprintf( Strbuf,"Tape[%d]",Tapetime ) ;
  535.     strdisp( Strbuf,STD,SKYBLUE ) ;
  536.  
  537.     return ;
  538. }
  539.  
  540. /*****************************  各曲情報表示  ********************************/
  541. void mdisp( int cx, int cy )
  542. {
  543.     int        st ;
  544.     unsigned    c, line, clm ;
  545.  
  546.     cmdisp() ;                                            /*  ｺﾏﾝﾄﾞ状態表示    */
  547.  
  548.     nowstatus() ;                                        /*  演奏状態のﾁｪｯｸ    */
  549.  
  550.     if ( CDflg.change ) {                                /*  CD 入れ換え有り    */
  551.         wardisp( M_CHANGE ) ;
  552.  
  553.         reset() ;
  554.  
  555.         cx = CURx ;    cy = CURy ;
  556.         stddisp( M_CLS ) ;
  557.     }
  558.     if ( !CDflg.ready ) {                                /*  再表示の必要無    */
  559.         goto close ;
  560.     }
  561.  
  562.     if ( Cdtype != 1 && Cdtype != 3 ) {
  563.         wardisp( M_NOTDA ) ;
  564.         goto close ;
  565.     }
  566.  
  567.     CRT_setcur( 1,CUR_Y0-1 ) ;
  568.     deftape() ;                                    /*  各曲時間計算とﾃｰﾌﾟ選択    */
  569.  
  570.     CRT_defatr( STD,SKYBLUE ) ;
  571.     for ( c=0; c<5; c++ ) {
  572.         CRT_puts( " No ･･･TIME･･･ " ) ;
  573.     }
  574.  
  575.     for ( c=0; c<99; c++ ) {
  576.         clm  = ( c / 20 ) * XCNT ;
  577.         line = c % 20 ;
  578.         if ( c < Endtrack ) {
  579.             sprintf(&Trdata[line][clm]," %02d %02d分%02d秒%02d ",
  580.                 c+1,Trtime2[c].min,Trtime2[c].sec,Trtime2[c].frame) ;
  581.         } else {                                                /*  曲なし    */
  582.             sprintf(&Trdata[line][clm],"               ") ;
  583.         }
  584.     }
  585.  
  586.     CRT_defatr( STD,WHITE ) ;
  587.     for ( c=0; c<20; c++ ) {
  588.         CRT_cr() ;
  589.         CRT_puts( &Trdata[c][0] ) ;
  590.     }
  591.  
  592. /*
  593. **    特殊表示のｱﾄﾘﾋﾞｭｰﾄ変更
  594. */
  595.     for ( c=0; c<Endtrack; c++ ) {                            /*  特殊表示    */
  596.         sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  597.                 c+1,Trtime2[c].min,Trtime2[c].sec,Trtime2[c].frame ) ;
  598.         clm  = ( c / 20 ) * XCNT + 1 ;
  599.         line = c % 20 + CUR_Y0 ;
  600.         CRT_setcur( clm,line ) ;
  601.         if ( ( Trtime[c].min & 0x80 ) == 0x80 ) {            /*  ﾃﾞｰﾀ        */
  602.             strdisp( Strbuf,STD,BLUE ) ;
  603.         } else if ( SideAon[c] ) {                            /*  ﾃｰﾌﾟ選択    */
  604.             strdisp( Strbuf,STD,YELLOW ) ;
  605.         }
  606.     }
  607.  
  608.     tapedisp() ;
  609.  
  610. /*
  611. **    合計時間表示
  612. */
  613.     CRT_setcur( CUR_X2-2,CUR_Y2+1 ) ;
  614.     sprintf( Strbuf,"TOTAL %02d分%02d秒%02d",
  615.             Totaltime.min,Totaltime.sec,Totaltime.frame ) ;
  616.     strdisp( Strbuf,STD,GREEN ) ;
  617.  
  618. /*
  619. **    ｶｰｿﾙ初期表示
  620. */
  621.     st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  622.     sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  623.             st,Trtime2[st-1].min,Trtime2[st-1].sec,Trtime2[st-1].frame ) ;
  624.     clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  625.     line = (st-1) % 20 + CUR_Y0 ;
  626.     CRT_setcur( clm,line ) ;
  627.     if ( ( Trtime[st-1].min & 0x80 ) == 0x80 ) {            /*  ﾃﾞｰﾀ        */
  628.         strdisp( Strbuf,REV,BLUE ) ;
  629.     } else {
  630.         if ( SideAon[st-1] )
  631.             strdisp( Strbuf,REV,YELLOW ) ;
  632.         else
  633.             strdisp( Strbuf,REV,WHITE ) ;
  634.     }
  635.  
  636. close: ;
  637.     evoldisp( Evol,CDflg.mute ) ;
  638.     CRT_setcur( cx,cy ) ;
  639.  
  640.     return ;
  641. }
  642.  
  643. /*************************  選択された曲を演奏  ******************************/
  644. void sideselect()
  645. {
  646.     int        st ;                                    /*  選択された曲番号    */
  647.     unsigned    line, clm ;
  648.  
  649.     CRT_setcur( MSG_X,MSG_Y ) ;
  650.  
  651.     st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  652.  
  653.     if ( st <= Endtrack && ( ( Trtime[st-1].min & 0x80 ) != 0x80 ) ) {
  654.                                     /*  指定されたのが演奏できる曲の場合    */
  655.         if ( SideAon[st-1] ) {                            /*  選択 -> 非選択    */
  656.             SideAon[st-1] = FALSE ;
  657.             subtime( SideAtime.min,SideAtime.sec,SideAtime.frame,
  658.                     Trtime2[st-1].min,Trtime2[st-1].sec,Trtime2[st-1].frame,
  659.                     &SideAtime.min,&SideAtime.sec,&SideAtime.frame ) ;
  660.         } else {                                        /*  非選択 -> 選択    */
  661.             SideAon[st-1] = TRUE ;
  662.             addtime( SideAtime.min,SideAtime.sec,SideAtime.frame,
  663.                     Trtime2[st-1].min,Trtime2[st-1].sec,Trtime2[st-1].frame,
  664.                     &SideAtime.min,&SideAtime.sec,&SideAtime.frame ) ;
  665.         }
  666.  
  667.                                 /*  選択された曲情報を元のｱﾄﾘﾋﾞｭｰﾄに戻す    */
  668.         sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  669.                 st,Trtime2[st-1].min,Trtime2[st-1].sec,Trtime2[st-1].frame ) ;
  670.         clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  671.         line = (st-1) % 20 + CUR_Y0 ;
  672.         CRT_setcur( clm,line ) ;
  673.         if ( SideAon[st-1] )
  674.             strdisp( Strbuf,REV,YELLOW ) ;
  675.         else
  676.             strdisp( Strbuf,REV,WHITE ) ;
  677.  
  678.         tapedisp() ;
  679.  
  680.     } else {                    /*  演奏できない曲番号が指定された場合        */
  681.         wardisp( M_NOTPLAY ) ;
  682.         tapedisp() ;
  683.     }
  684.  
  685. close: ;
  686.  
  687.     CRT_setcur( CURx,CURy ) ;
  688.  
  689.     return ;
  690. }
  691.  
  692. /*************************  選択された曲を演奏  ******************************/
  693. void select()
  694. {
  695.     int        st, end, rep ;                                /*  演奏開始指示用    */
  696.     unsigned    line, clm ;
  697.  
  698.     if ( !CDflg.ready ) {                                    /*  NOT READY    */
  699.         wardisp( M_NOTREADY ) ;
  700.         CURx = CUR_X0 ;
  701.         CURy = CUR_Y0 ;
  702.         goto close ;
  703.     } else if ( Cdtype != 1 && Cdtype != 3 ) {                /*  CDDA なし    */
  704.         wardisp( M_NOTDA ) ;
  705.         CURx = CUR_X0 ;
  706.         CURy = CUR_Y0 ;
  707.         goto close ;
  708.     }
  709.  
  710.     /*    ﾒｯｾｰｼﾞ領域ｸﾘｱ    */
  711.     stddisp( M_CLS ) ;
  712.  
  713.     rep = 1 ;
  714.  
  715.     st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  716.  
  717.     if ( st <= Endtrack && ( ( Trtime[st-1].min & 0x80 ) != 0x80 ) ) {
  718.                                     /*  指定されたのが演奏できる曲の場合    */
  719.         sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  720.                 st,Trtime2[st-1].min,Trtime2[st-1].sec,Trtime2[st-1].frame ) ;
  721.         clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  722.         line = (st-1) % 20 + CUR_Y0 ;
  723.         CRT_setcur( clm,line ) ;
  724.         strdisp( Strbuf,REV,SKYBLUE ) ;
  725.  
  726.         end = st ;
  727.  
  728.         cdplay( FALSE,st,end,(unsigned char)rep ) ;        /*  演奏開始        */
  729.  
  730.         if ( CDflg.change ) {                            /*  CD 入れ換え有り    */
  731.             
  732.             mdisp( CURx,CURy ) ;                        /*  曲情報の再表示    */
  733.  
  734.             if ( !CDflg.ready || ( Cdtype != 1 && Cdtype != 3 ) ) {
  735.                                                         /*  演奏不可        */
  736.                 if ( Cdtype != 1 && Cdtype != 3 ) {
  737.                     wardisp( M_NOTDA ) ;
  738.                 } else {
  739.                     wardisp( M_NOTREADY ) ;
  740.                 }
  741.                 CURx = CUR_X0 ;
  742.                 CURy = CUR_Y0 ;
  743.             }
  744.  
  745.         } else {
  746.                                 /*  選択された曲情報を元のｱﾄﾘﾋﾞｭｰﾄに戻す    */
  747.             CRT_setcur( clm,line ) ;
  748.             if ( SideAon[st-1] )
  749.                 strdisp( Strbuf,REV,YELLOW ) ;
  750.             else
  751.                 strdisp( Strbuf,REV,WHITE ) ;
  752.         }
  753.  
  754.     } else {                    /*  演奏できない曲番号が指定された場合        */
  755.         wardisp( M_NOTPLAY ) ;
  756.         tapedisp() ;
  757.     }
  758.  
  759. close: ;
  760.  
  761.     CRT_setcur( CURx,CURy ) ;
  762.  
  763.     return ;
  764. }
  765.  
  766. /*****************************  演奏時間表示  ********************************/
  767. void timedisp()
  768. {
  769.     char    tmin, tsec, tframe ;                    /*  現在のTOTAL経過時間    */
  770.     char    tminw, tsecw, tframew ;                    /*  現在のTOTAL残り時間    */
  771.     char    minw, secw, framew ;                    /*  現在の曲の残り時間    */
  772.  
  773.     tframe = Disctime.frame ;
  774.     tsec   = Disctime.sec ;
  775.     tmin   = Disctime.min ;
  776.  
  777. /*
  778. **    TOC部分の時間を差し引く
  779. */
  780.     minw = Trtime[0].min ;
  781.     if ( ( minw & 0x80 ) == 0x80 ) minw &= 0x7f ;
  782.     subtime( tmin,tsec,tframe,minw,Trtime[0].sec,Trtime[0].frame,
  783.             &tmin,&tsec,&tframe ) ;
  784.  
  785. /*
  786. **    ﾃﾞｰﾀ部分の時間を差し引く
  787. */
  788.     subtime( tmin,tsec,tframe,Datatime.min,Datatime.sec,Datatime.frame,
  789.             &tmin,&tsec,&tframe ) ;
  790.  
  791. /*
  792. **    NOW TIME( 残り時間 )
  793. */
  794.     subtime( Trtime2[Nowmusicno-1].min,Trtime2[Nowmusicno-1].sec,
  795.             Trtime2[Nowmusicno-1].frame,
  796.             Nowtime.min,Nowtime.sec,Nowtime.frame,&minw,&secw,&framew ) ;
  797.  
  798. /*
  799. **    TOTAL TIME( 残り時間 )
  800. */
  801.     subtime( Totaltime.min,Totaltime.sec,Totaltime.frame,tmin,tsec,tframe,
  802.             &tminw,&tsecw,&tframew ) ;
  803.  
  804.     CRT_setcur( MSG_X,MSG_Y ) ;
  805.     strdisp( " ",STD,WHITE ) ;
  806.  
  807.     sprintf( Strbuf,"%02d",Nowmusicno ) ;                /*  現在の曲        */
  808.     strdisp( Strbuf,REV,WHITE ) ;
  809.  
  810.     strdisp( " >",STD,WHITE ) ;
  811.  
  812.     sprintf( Strbuf,"%02d分%02d秒",Nowtime.min,Nowtime.sec ) ;
  813.                                                         /*  現在の時間        */
  814.     strdisp( Strbuf,STD,SKYBLUE ) ;
  815.  
  816.     sprintf( Strbuf,"[-%02d分%02d秒]",minw,secw ) ;        /*  残り時間        */
  817.     strdisp( Strbuf,STD,YELLOW ) ;
  818.  
  819.     strdisp( "                          ",STD,WHITE ) ;
  820.  
  821.     return ;
  822. }
  823.  
  824. /************************  演奏状態表示のクリア  *****************************/
  825. void musicdispcls( int musicno )
  826. {
  827.     stddisp( M_CLS ) ;
  828.  
  829.     CRT_setcur( CURx,CURy ) ;
  830.  
  831.     return ;
  832. }
  833.  
  834. /****************************  演奏状態の表示  *******************************/
  835. void musicdisp( char playflg )
  836. /*
  837. **    playflg が TRUE ならば・・・
  838. **            ●演奏中であれば、曲が変わった時 & 時間が変わった時 のフラグに
  839. **            　関係なく、時間表示を行う。
  840. */
  841. {
  842.     static int    musicno = FALSE ;        /*  演奏中の曲番号                    */
  843.     unsigned    line, clm ;                /*  演奏中の曲番号表示位置用        */
  844.     static int    errdisp=TRUE ;            /*  NOT READY のﾒｯｾｰｼﾞ出力制御用    */
  845.     static signed char    secw   = -1 ;    /*  時間表示は秒が変化した時のみ    */
  846.     char    onplay = FALSE ;            /*  曲演奏中 ﾌﾗｸﾞ                    */
  847.  
  848.     nowstatus() ;                                    /*  演奏状態のﾁｪｯｸ        */
  849.  
  850.     if ( !CDflg.ready ) {                                    /*  NOT READY    */
  851.         musicno = FALSE ;
  852.         secw   = -1 ;
  853.         if ( errdisp ) {
  854.             wardisp( M_NOTREADY ) ;
  855.             CURx = CUR_X0 ;
  856.             CURy = CUR_Y0 ;
  857.             CRT_setcur( CURx,CURy ) ;
  858.             errdisp = FALSE ;
  859.         }
  860.         return ;
  861.     }
  862.     errdisp = TRUE ;
  863.  
  864.     onplay = FALSE ;
  865.     if ( (CDnows==NOW_PLAY) && (Nowmusicno>0) && (Nowmusicno<100) ) {
  866.         onplay = TRUE ;
  867.     }
  868.  
  869.     if ( onplay ) {                                                /*  演奏中    */
  870. /*
  871. **    演奏情報
  872. */
  873.         if ( musicno != Nowmusicno && !playflg && musicno ) {
  874.             return ;
  875.         }
  876.         musicno = Nowmusicno ;
  877. /*        if ( secw != Nowtime.sec || playflg ) {*/
  878.             timedisp() ;
  879.             secw   = Nowtime.sec ;
  880. /*        }*/
  881.  
  882.     } else {                                                /*  演奏なし    */
  883.         if ( musicno > 0 ) {
  884.             tapedisp() ;
  885.             musicno = FALSE ;
  886.             secw   = -1 ;
  887.  
  888.         }
  889.     }
  890.  
  891.     CRT_setcur( CURx,CURy ) ;
  892.  
  893.     return ;
  894. }
  895.  
  896. /*****************************  次の曲を選択  ********************************/
  897. void next_select()
  898. {
  899.     int        st ;                                    /*  選択された曲番号    */
  900.     unsigned    line, clm ;
  901.     char    moveflg ;
  902.     unsigned    cx, cy ;
  903.  
  904.     if ( !CDflg.ready ) return ;                             /*  NOT READY    */
  905.  
  906.     moveflg = FALSE ;
  907.     cx = CURx ;        cy = CURy ;
  908.  
  909.     if ( (CURy+1) > CUR_Y2 ) {                                    /*  最下行    */
  910.         if ( ( 1 + ((CURx/XCNT)+1)*20 ) <= Endtrack ) {
  911.             CURx += XCNT ;
  912.             CURy = CUR_Y1 ;
  913.             moveflg = TRUE ;
  914.         }
  915.     } else {
  916.         st = ( (CURy+1)-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  917.         if ( st > Endtrack ) {
  918.             ;
  919.         } else {
  920.             CURy ++ ;
  921.             moveflg = TRUE ;
  922.         }
  923.     }
  924.  
  925.     if ( !moveflg ) {
  926.         CRT_setcur( CURx,CURy ) ;
  927.         return ;
  928.     }
  929.  
  930. /*
  931. **    元のｱﾄﾘﾋﾞｭｰﾄに戻す｡
  932. */
  933.     st = ( cy-CUR_Y0+1 ) + ( cx/XCNT ) * 20 ;
  934.     sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  935.             st,Trtime2[st-1].min,Trtime2[st-1].sec,Trtime2[st-1].frame ) ;
  936.     clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  937.     line = (st-1) % 20 + CUR_Y0 ;
  938.     CRT_setcur( clm,line ) ;
  939.     if ( ( Trtime[st-1].min & 0x80 ) == 0x80 ) {            /*  ﾃﾞｰﾀ        */
  940.         strdisp( Strbuf,STD,BLUE ) ;
  941.     } else {
  942.         if ( SideAon[st-1] )
  943.             strdisp( Strbuf,STD,YELLOW ) ;
  944.         else
  945.             strdisp( Strbuf,STD,WHITE ) ;
  946.     }
  947.  
  948. /*
  949. **    ｶｰｿﾙ位置のｱﾄﾘﾋﾞｭｰﾄを設定する。
  950. */
  951.     st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  952.     sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  953.             st,Trtime2[st-1].min,Trtime2[st-1].sec,Trtime2[st-1].frame ) ;
  954.     clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  955.     line = (st-1) % 20 + CUR_Y0 ;
  956.     CRT_setcur( clm,line ) ;
  957.     if ( ( Trtime[st-1].min & 0x80 ) == 0x80 ) {            /*  ﾃﾞｰﾀ        */
  958.         strdisp( Strbuf,REV,BLUE ) ;
  959.     } else {
  960.         if ( SideAon[st-1] )
  961.             strdisp( Strbuf,REV,YELLOW ) ;
  962.         else
  963.             strdisp( Strbuf,REV,WHITE ) ;
  964.     }
  965.  
  966.     CRT_setcur( CURx,CURy ) ;
  967. }
  968.  
  969. /*****************************  前の曲を選択  ********************************/
  970. void before_select()
  971. {
  972.     int        st ;                                    /*  選択された曲番号    */
  973.     unsigned    line, clm ;
  974.     char    moveflg ;
  975.     unsigned    cx, cy ;
  976.  
  977.     if ( !CDflg.ready ) return ;                             /*  NOT READY    */
  978.  
  979.     moveflg = FALSE ;
  980.     cx = CURx ;        cy = CURy ;
  981.  
  982.     if ( (CURy-1) < CUR_Y1 ) {                                    /*  最上行    */
  983.         if ( ( (CUR_Y2-CUR_Y1+1)+((CURx/XCNT)-1)*20 ) >= Sttrack ) {
  984.             CURx -= XCNT ;
  985.             CURy = CUR_Y2 ;
  986.             moveflg = TRUE ;
  987.         }
  988.     } else {
  989.         st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  990.         if ( st != 2 || Cdtype != 3 ) {
  991.             CURy -- ;
  992.             moveflg = TRUE ;
  993.         }
  994.     }
  995.  
  996.     if ( !moveflg ) {
  997.         CRT_setcur( CURx,CURy ) ;
  998.         return ;
  999.     }
  1000.  
  1001. /*
  1002. **    元のｱﾄﾘﾋﾞｭｰﾄに戻す｡
  1003. */
  1004.     st = ( cy-CUR_Y0+1 ) + ( cx/XCNT ) * 20 ;
  1005.     sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  1006.             st,Trtime2[st-1].min,Trtime2[st-1].sec,Trtime2[st-1].frame ) ;
  1007.     clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  1008.     line = (st-1) % 20 + CUR_Y0 ;
  1009.     CRT_setcur( clm,line ) ;
  1010.     if ( ( Trtime[st-1].min & 0x80 ) == 0x80 ) {            /*  ﾃﾞｰﾀ        */
  1011.         strdisp( Strbuf,STD,BLUE ) ;
  1012.     } else {
  1013.         if ( SideAon[st-1] )
  1014.             strdisp( Strbuf,STD,YELLOW ) ;
  1015.         else
  1016.             strdisp( Strbuf,STD,WHITE ) ;
  1017.     }
  1018.  
  1019. /*
  1020. **    ｶｰｿﾙ位置のｱﾄﾘﾋﾞｭｰﾄを設定する。
  1021. */
  1022.     st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  1023.     if ( st == 1 && Cdtype == 3 ) {
  1024.         CURy ++ ;
  1025.         st ++ ;
  1026.     }
  1027.     sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  1028.             st,Trtime2[st-1].min,Trtime2[st-1].sec,Trtime2[st-1].frame ) ;
  1029.     clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  1030.     line = (st-1) % 20 + CUR_Y0 ;
  1031.     CRT_setcur( clm,line ) ;
  1032.     if ( ( Trtime[st-1].min & 0x80 ) == 0x80 ) {            /*  ﾃﾞｰﾀ        */
  1033.         strdisp( Strbuf,REV,BLUE ) ;
  1034.     } else {
  1035.         if ( SideAon[st-1] )
  1036.             strdisp( Strbuf,REV,YELLOW ) ;
  1037.         else
  1038.             strdisp( Strbuf,REV,WHITE ) ;
  1039.     }
  1040.  
  1041.     CRT_setcur( CURx,CURy ) ;
  1042. }
  1043.  
  1044. /**************************  CD 先送り演奏処理  ******************************/
  1045. void ffplay()
  1046. {
  1047.     int        st, end ;                                /*  演奏開始指示用        */
  1048.     signed char    nmin, nsec, nframe ;                /*  演奏時間表示用        */
  1049.     signed char    nminw, nsecw, nframew ;                /*  残り時間表示用        */
  1050.     int        cmp ;
  1051.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  1052.     char    keyrepflg ;                                /*  ｷｰﾘﾋﾟｰﾄ用ﾌﾗｸﾞ        */
  1053.  
  1054.     nowstatus() ;                                    /*  演奏状態のﾁｪｯｸ        */
  1055.  
  1056.     if ( CDnows ) {                                            /*  演奏中        */
  1057.  
  1058.         st = Nowmusicno ;
  1059.         nsec   = Nowtime.sec ;
  1060.         nmin   = Nowtime.min ;
  1061.         nframe = 0 ;
  1062.         CDR_pause( Cddrv ) ;
  1063.  
  1064.         keyrepflg = FALSE ;
  1065.         do {
  1066.             addtime( nmin,nsec,nframe,0,FFREVSEC,0,&nmin,&nsec,&nframe ) ;
  1067.  
  1068.             cmp = cmptime( nmin,nsec,0,
  1069.                     Trtime2[st-1].min,Trtime2[st-1].sec,0 ) ;
  1070.  
  1071.             if ( cmp > 0 ) {                        /*  次の曲時間に突入    */
  1072.                 st ++ ;
  1073.                 nmin = nsec = 0 ;
  1074.             }
  1075. /*
  1076. **    残り時間の計算
  1077. */
  1078.             subtime( Trtime2[st-1].min,Trtime2[st-1].sec,0,
  1079.                     nmin,nsec,0,&nminw,&nsecw,&nframew ) ;
  1080.  
  1081.             if ( st == Nowmusicno ) {
  1082.                 CRT_setcur( MSG_X,MSG_Y ) ;
  1083.                 strdisp( " ",STD,WHITE ) ;
  1084.  
  1085.                 sprintf( Strbuf,"%02d",st ) ;                /*  現在の曲    */
  1086.                 strdisp( Strbuf,REV,WHITE ) ;
  1087.  
  1088.                 strdisp( " >",STD,WHITE ) ;
  1089.  
  1090.                 sprintf( Strbuf,"%02d分%02d秒",nmin,nsec ) ;
  1091.                 strdisp( Strbuf,STD,SKYBLUE ) ;
  1092.                                                             /*  現在の時間    */
  1093.  
  1094.                 sprintf( Strbuf,"[-%02d分%02d秒]",nminw,nsecw ) ;
  1095.                 strdisp( Strbuf,STD,YELLOW ) ;
  1096.                                                             /*  残り時間    */
  1097.  
  1098.                 strdisp( "                          ",STD,WHITE ) ;
  1099.  
  1100.             } else {
  1101.                 do {                            /*  キーが放されるまで待つ    */
  1102.                     KEY_bufcls() ;
  1103.                     KEY_matrix( matrix ) ;
  1104.                 } while ( KEY_test( matrix,KEY_F ) ) ;
  1105.                 break ;
  1106.             }
  1107.  
  1108.             if ( keyrepflg ) {
  1109.                 ;                                        /*  ｷｰﾘﾋﾟｰﾄ間隔 0    */
  1110.             } else {
  1111.                 soft_time( KEY_wait ) ;
  1112.                 keyrepflg = TRUE ;
  1113.             }
  1114.  
  1115.             KEY_bufcls() ;
  1116.             KEY_matrix( matrix ) ;
  1117.                 
  1118.         } while ( KEY_test( matrix,KEY_F ) ) ;
  1119.         KEY_bufcls() ;
  1120.  
  1121.         if ( st == Nowmusicno ) {
  1122.             end = st ;
  1123.  
  1124.             usestset( st ) ;                    /*  演奏開始曲データ設定    */
  1125.             addtime( Usest.min,Usest.sec,Usest.frame,nmin,nsec,0,
  1126.                     &Usest.min,&Usest.sec,&Usest.frame ) ;
  1127.             useetset( end ) ;                    /*  演奏終了曲データ設定    */
  1128.             timeplay( 1 ) ;
  1129.         }
  1130.  
  1131.         stddisp( M_CLS ) ;
  1132.         CRT_setcur( CURx,CURy ) ;
  1133.     } else {                                        /*  停止中 or NOT READY    */
  1134.         ;
  1135.     }
  1136.  
  1137.     nowstatus() ;                                    /*  演奏状態のﾁｪｯｸ        */
  1138.     return ;
  1139. }
  1140.  
  1141. /**************************  CD 後戻り演奏処理  ******************************/
  1142. void revplay()
  1143. {
  1144.     int        st, end ;                                /*  演奏開始指示用        */
  1145.     signed char    nmin, nsec, nframe ;                /*  演奏時間表示用        */
  1146.     signed char    nminw, nsecw, nframew ;                /*  残り時間表示用        */
  1147.     int        cmp ;
  1148.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  1149.     char    keyrepflg ;                                /*  ｷｰﾘﾋﾟｰﾄ用ﾌﾗｸﾞ        */
  1150.  
  1151.     nowstatus() ;                                    /*  演奏状態のﾁｪｯｸ        */
  1152.  
  1153.     if ( CDnows ) {                                            /*  演奏中        */
  1154.  
  1155.         st = Nowmusicno ;
  1156.         nsec   = Nowtime.sec ;
  1157.         nmin   = Nowtime.min ;
  1158.         nframe = 0 ;
  1159.         CDR_pause( Cddrv ) ;
  1160.  
  1161.         keyrepflg = FALSE ;
  1162.         do {
  1163.             subtime( nmin,nsec,nframe,0,FFREVSEC,0,&nmin,&nsec,&nframe ) ;
  1164.  
  1165.             cmp = cmptime( nmin,nsec,0,0,0,0 ) ;
  1166.  
  1167.             if ( cmp < 0 ) {                        /*  前の曲時間に突入    */
  1168.                 st -- ;
  1169.                 nmin = nsec = 0 ;
  1170.             }
  1171.  
  1172. /*
  1173. **    残り時間の計算
  1174. */
  1175.             subtime( Trtime2[st-1].min,Trtime2[st-1].sec,0,
  1176.                     nmin,nsec,0,&nminw,&nsecw,&nframew ) ;
  1177.  
  1178.             if ( st == Nowmusicno ) {
  1179.                 CRT_setcur( MSG_X,MSG_Y ) ;
  1180.                 sprintf( Strbuf," " ) ;
  1181.                 strdisp( " ",STD,WHITE ) ;
  1182.  
  1183.                 sprintf( Strbuf,"%02d",st ) ;                /*  現在の曲    */
  1184.                 strdisp( Strbuf,REV,WHITE ) ;
  1185.  
  1186.                 strdisp( " >",STD,WHITE ) ;
  1187.  
  1188.                 sprintf( Strbuf,"%02d分%02d秒",nmin,nsec ) ;
  1189.                 strdisp( Strbuf,STD,SKYBLUE ) ;
  1190.                                                             /*  現在の時間    */
  1191.  
  1192.                 sprintf( Strbuf,"[-%02d分%02d秒]",nminw,nsecw ) ;
  1193.                 strdisp( Strbuf,STD,YELLOW ) ;
  1194.                                                             /*  残り時間    */
  1195.  
  1196.                 strdisp( "                          ",STD,WHITE ) ;
  1197.  
  1198.             } else {
  1199.                 do {                            /*  キーが放されるまで待つ    */
  1200.                     KEY_bufcls() ;
  1201.                     KEY_matrix( matrix ) ;
  1202.                 } while ( KEY_test( matrix,KEY_R ) ) ;
  1203.                 break ;
  1204.  
  1205.             }
  1206.  
  1207.             if ( keyrepflg ) {
  1208.                 ;                                        /*  ｷｰﾘﾋﾟｰﾄ間隔 0    */
  1209.             } else {
  1210.                 soft_time( KEY_wait ) ;
  1211.                 keyrepflg = TRUE ;
  1212.             }
  1213.  
  1214.             KEY_bufcls() ;
  1215.             KEY_matrix( matrix ) ;
  1216.                 
  1217.         } while ( KEY_test( matrix,KEY_R ) ) ;
  1218.         KEY_bufcls() ;
  1219.  
  1220.         if ( st != Nowmusicno )
  1221.             st  = Nowmusicno ;
  1222.         end = st ;
  1223.  
  1224.         usestset( st ) ;                        /*  演奏開始曲データ設定    */
  1225.         addtime( Usest.min,Usest.sec,Usest.frame,nmin,nsec,0,
  1226.                 &Usest.min,&Usest.sec,&Usest.frame ) ;
  1227.         useetset( end ) ;                        /*  演奏終了曲データ設定    */
  1228.         timeplay( 1 ) ;
  1229.  
  1230.         stddisp( M_CLS ) ;
  1231.         CRT_setcur( CURx,CURy ) ;
  1232.     } else {                                        /*  停止中 or NOT READY    */
  1233.         ;
  1234.     }
  1235.  
  1236.     nowstatus() ;                                    /*  演奏状態のﾁｪｯｸ        */
  1237.     return ;
  1238. }
  1239.  
  1240. /**************************  電子ﾎﾞﾘｭｰﾑを上げる  *****************************/
  1241. void evolup()
  1242. {
  1243.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  1244.     char    keyrepflg ;                                /*  ｷｰﾘﾋﾟｰﾄ用ﾌﾗｸﾞ        */
  1245.  
  1246.     CDflg.mute = FALSE ;
  1247.  
  1248.     keyrepflg = FALSE ;
  1249.     do {
  1250.         if ( Evol+3 < VOL_MAX )
  1251.             Evol += 3 ;
  1252.         else
  1253.             Evol = VOL_MAX ;
  1254.         evs( Evol ) ;
  1255.         evoldisp( Evol,CDflg.mute ) ;
  1256.  
  1257.         if ( keyrepflg ) {
  1258.             soft_time( KEY_repeat ) ;
  1259.         } else {
  1260.             soft_time( KEY_wait ) ;
  1261.             keyrepflg = TRUE ;
  1262.         }
  1263.  
  1264.          KEY_bufcls() ;
  1265.         KEY_matrix( matrix ) ;
  1266.  
  1267.     } while ( KEY_test( matrix,KEY_U ) ) ;
  1268.     KEY_bufcls() ;
  1269.  
  1270.     return ;
  1271. }
  1272.  
  1273. /**************************  電子ﾎﾞﾘｭｰﾑを下げる  *****************************/
  1274. void evoldown()
  1275. {
  1276.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  1277.     char    keyrepflg ;                                /*  ｷｰﾘﾋﾟｰﾄ用ﾌﾗｸﾞ        */
  1278.  
  1279.     CDflg.mute = FALSE ;
  1280.  
  1281.     keyrepflg = FALSE ;
  1282.     do {
  1283.         if ( Evol-3 > VOL_MIN )
  1284.             Evol -= 3 ;
  1285.         else
  1286.             Evol = VOL_MIN ;
  1287.         evs( Evol ) ;
  1288.         evoldisp( Evol,CDflg.mute ) ;
  1289.  
  1290.         if ( keyrepflg ) {
  1291.             soft_time( KEY_repeat ) ;
  1292.         } else {
  1293.             soft_time( KEY_wait ) ;
  1294.             keyrepflg = TRUE ;
  1295.         }
  1296.  
  1297.          KEY_bufcls() ;
  1298.         KEY_matrix( matrix ) ;
  1299.  
  1300.     } while ( KEY_test( matrix,KEY_D ) ) ;
  1301.     KEY_bufcls() ;
  1302.  
  1303.     return ;
  1304. }
  1305.  
  1306. /*****************************  シェル起動  **********************************/
  1307. void shell()
  1308. {
  1309.     CRT_cursw( FALSE ) ;
  1310.     CRT_defatr( STD,WHITE ) ;
  1311.     CRT_cls() ;
  1312.  
  1313.     CRT_cr() ;
  1314.     msgdisp( M_SHELL,STD,MC_STD ) ;
  1315.     CRT_cr() ;
  1316.  
  1317.     CRT_defatr( STD,WHITE ) ;
  1318.     CRT_cursw( TRUE ) ;
  1319.     KEY_bufcls() ;
  1320.     system( "command" ) ;
  1321.  
  1322.     CRT_cursw( FALSE ) ;
  1323.     CRT_cr() ;
  1324.     msgdisp( M_SHELLEND,STD,MC_STD ) ;
  1325.     CRT_cr() ;
  1326.  
  1327.     system( "pause > nul" ) ;
  1328.  
  1329.     KEY_bufcls() ;
  1330.     titledisp() ;
  1331.     nowstatus() ;                                        /*  演奏状態のﾁｪｯｸ    */
  1332.     if ( !CDnows && !CDflg.change ) {                /*  停止中 or NOT READY    */
  1333.         tocread() ;
  1334.         CURx = CUR_X0 ;
  1335.         CURy = CUR_Y0 ;
  1336.         if ( Cdtype == 3 ) CURy ++ ;
  1337.     }
  1338.     mdisp( CURx,CURy ) ;
  1339.  
  1340.     return ;
  1341. }
  1342.  
  1343. /**************************  CD 演奏 MMI 処理  *******************************/
  1344. void play()
  1345. {
  1346.     int        st, end, rep ;                            /*  演奏開始指示用        */
  1347.     char    keyrepflg ;                                /*  ｷｰﾘﾋﾟｰﾄ用ﾌﾗｸﾞ        */
  1348.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  1349.     char    wmatrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得(作業)用    */
  1350.     char    endflg = FALSE ;                        /*  終了ﾌﾗｸﾞ            */
  1351.     char    playflg ;                                /*  演奏指示ｱﾘ ﾌﾗｸﾞ        */
  1352.     unsigned short    color ;
  1353.     unsigned    line, clm ;
  1354.  
  1355. /*
  1356. **    各ﾌﾗｸﾞの初期化
  1357. */
  1358.     CDflg.ready  = TRUE ;        /*  CD はREADY状態か？                        */
  1359.     CDflg.change = FALSE ;        /*  CD が入れ換えられたか？                    */
  1360.     CDflg.stop   = TRUE ;        /*  STOPするのか？                            */
  1361.     CDflg.mute   = FALSE ;        /*  ミュートしているのか？                    */
  1362.     CDflg.tape   = FALSE ;        /*  ﾃｰﾌﾟ選択済か？                            */
  1363.     CDflg.time   = TRUE ;        /*  時間表示切り換え : TRUE = 標準            */
  1364.  
  1365.     CURx = CUR_X0 ;
  1366.     CURy = CUR_Y0 ;
  1367.     if ( Cdtype == 3 ) CURy ++ ;
  1368.     mdisp( CURx,CURy ) ;
  1369.  
  1370.     for ( ;; ) {
  1371.  
  1372.          KEY_bufcls() ;
  1373.         KEY_matrix( matrix ) ;
  1374.  
  1375.         playflg = FALSE ;
  1376.  
  1377.         if ( KEY_test( matrix,KEY_CTRL ) ) {            /*  CTRL ｷｰ ON        */
  1378.  
  1379.             if ( KEY_test( matrix,KEY_Q ) || KEY_test( matrix,KEY_E ) ) {
  1380.                                                             /*  END            */
  1381.                 endflg = TRUE ;
  1382.                 CDflg.stop = FALSE ;
  1383.  
  1384.             } else if ( KEY_test( matrix,KEY_P ) ) {        /*  CD STOP        */
  1385.                 if ( CDflg.ready ) {
  1386.                     stddisp( M_CDSTOP ) ;
  1387.  
  1388.                     if ( CDR_mstop( Cddrv ) ) CDR_mstop( Cddrv ) ;
  1389.                     tapedisp() ;
  1390.                     CRT_setcur( CURx,CURy ) ;
  1391.                 }
  1392.  
  1393.             } else if ( KEY_test( matrix,KEY_R ) ) {        /*  Reset        */
  1394.                 stddisp( M_READING ) ;
  1395.  
  1396.                 CDflg.time = TRUE ;
  1397.                 reset() ;
  1398.                 mdisp( CURx,CURy ) ;
  1399.             }
  1400.  
  1401.         } else {                                        /*  CTRL ｷｰ OFF        */
  1402.  
  1403.             if ( KEY_test( matrix,KEY_CR )
  1404.                 || KEY_test( matrix,KEY_EXEC )
  1405.                 || KEY_test( matrix,TKEY_CR ) ) {            /*  1PLAY        */
  1406.                 if ( CDflg.ready ) {
  1407.                     playflg = TRUE ;
  1408.                     select() ;
  1409.                 }
  1410.  
  1411.             } else if ( KEY_test( matrix,KEY_F ) ) {        /*  FF            */
  1412.                 if ( CDflg.ready ) {
  1413.                     ffplay() ;
  1414.                     playflg = TRUE ;
  1415.                 }
  1416.  
  1417.             } else if ( KEY_test( matrix,KEY_R ) ) {        /*  REV            */
  1418.                 if ( CDflg.ready ) {
  1419.                     revplay() ;
  1420.                     playflg = TRUE ;
  1421.                 }
  1422.  
  1423.             } else if ( KEY_test( matrix,KEY_T ) ) {        /*  Time        */
  1424.                 if ( CDflg.ready ) {
  1425.                     if ( CDflg.time )
  1426.                         CDflg.time = FALSE ;
  1427.                     else
  1428.                         CDflg.time = TRUE ;
  1429.                     tapedisp() ;
  1430.                     CRT_setcur( CURx,CURy ) ;
  1431.                                                 /*  キーが放されるのを待つ    */
  1432.                     do {
  1433.                          KEY_bufcls() ;
  1434.                         KEY_matrix( wmatrix ) ;
  1435.                     } while ( KEY_test( wmatrix,KEY_T ) ) ;
  1436.                 }
  1437.  
  1438.             } else if ( KEY_test( matrix,KEY_SPACE ) ) {    /*  Select A/B    */
  1439.                 if ( CDflg.ready ) {
  1440.                     sideselect() ;
  1441.                                                 /*  キーが放されるのを待つ    */
  1442.                     do {
  1443.                          KEY_bufcls() ;
  1444.                         KEY_matrix( wmatrix ) ;
  1445.                     } while ( KEY_test( wmatrix,KEY_SPACE ) ) ;
  1446.                 }
  1447.  
  1448.             } else if ( KEY_test( matrix,KEY_HOME ) ) {        /*  MUTE ON/OFF    */
  1449.                 if ( CDflg.mute ) {                        /*  MUTE ON -> OFF    */
  1450.                     muteoff() ;
  1451.                     CDflg.mute = FALSE ;
  1452.                 } else {                                /*  MUTE OFF -> ON    */
  1453.                     muteon() ;
  1454.                     CDflg.mute = TRUE ;
  1455.                 }
  1456.                 evoldisp( Evol,CDflg.mute ) ;
  1457.                                                 /*  キーが放されるのを待つ    */
  1458.                 do {
  1459.                      KEY_bufcls() ;
  1460.                     KEY_matrix( wmatrix ) ;
  1461.                 } while ( KEY_test( wmatrix,KEY_HOME ) ) ;
  1462.  
  1463.             } else if ( KEY_test( matrix,KEY_U ) ) {        /*  Vol. UP        */
  1464.                 evolup() ;
  1465.  
  1466.             } else if ( KEY_test( matrix,KEY_D ) ) {        /*  Vol. DOWN    */
  1467.                 evoldown() ;
  1468.  
  1469.             } else if ( KEY_test( matrix,KEY_UNDO ) ) {        /*  Vol. MAX    */
  1470.                 CDflg.mute = FALSE ;
  1471.                 Evol = VOL_MAX ;
  1472.                 evs( Evol ) ;
  1473.                 evoldisp( Evol,CDflg.mute ) ;
  1474.  
  1475.             } else if ( KEY_test( matrix,KEY_UP ) ) {        /*  CUR up        */
  1476.                 if ( CDflg.ready ) {
  1477.                     keyrepflg = FALSE ;
  1478.                     do {
  1479.                         before_select() ;
  1480.  
  1481.                         if ( keyrepflg ) {
  1482.                             soft_time( KEY_repeat ) ;
  1483.                         } else {
  1484.                             soft_time( KEY_wait ) ;
  1485.                             keyrepflg = TRUE ;
  1486.                         }
  1487.  
  1488.                          KEY_bufcls() ;
  1489.                         KEY_matrix( wmatrix ) ;
  1490.  
  1491.                     } while ( KEY_test( wmatrix,KEY_UP ) ) ;
  1492.                 }
  1493.  
  1494.             } else if ( KEY_test( matrix,KEY_DOWN ) ) {        /*  CUR down    */
  1495.                 if ( CDflg.ready ) {
  1496.                     keyrepflg = FALSE ;
  1497.                     do {
  1498.                         next_select() ;
  1499.  
  1500.                         if ( keyrepflg ) {
  1501.                             soft_time( KEY_repeat ) ;
  1502.                         } else {
  1503.                             soft_time( KEY_wait ) ;
  1504.                             keyrepflg = TRUE ;
  1505.                         }
  1506.  
  1507.                          KEY_bufcls() ;
  1508.                         KEY_matrix( wmatrix ) ;
  1509.  
  1510.                     } while ( KEY_test( wmatrix,KEY_DOWN ) ) ;
  1511.                 }
  1512.  
  1513.             } else if ( KEY_test( matrix,KEY_RIGHT ) ) {    /*  CUR right    */
  1514.                 if ( CDflg.ready ) {
  1515.                     keyrepflg = FALSE ;
  1516.                     do {
  1517.                         if ( (CURx+XCNT) > CUR_X2 ) {
  1518.                             ;
  1519.                         } else {
  1520.                             st = ( CURy-CUR_Y0+1 )
  1521.                                 + ( (CURx+XCNT)/XCNT ) * 20 ;
  1522.                             if ( st > Endtrack ) {
  1523.                                 ;
  1524.                             } else {
  1525.                                 st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  1526.                                 sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  1527.                                         st,Trtime2[st-1].min,Trtime2[st-1].sec,
  1528.                                         Trtime2[st-1].frame ) ;
  1529.                                 clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  1530.                                 line = (st-1) % 20 + CUR_Y0 ;
  1531.                                 CRT_setcur( clm,line ) ;
  1532.                                 if ( ( Trtime[st-1].min & 0x80 ) == 0x80 ) {
  1533.                                                             /*  ﾃﾞｰﾀ        */
  1534.                                     strdisp( Strbuf,STD,BLUE ) ;
  1535.                                 } else {
  1536.                                     if ( SideAon[st-1] )
  1537.                                         strdisp( Strbuf,STD,YELLOW ) ;
  1538.                                     else
  1539.                                         strdisp( Strbuf,STD,WHITE ) ;
  1540.                                 }
  1541.  
  1542.                                 CURx += XCNT ;
  1543.  
  1544.                                 st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  1545.                                 sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  1546.                                         st,Trtime2[st-1].min,Trtime2[st-1].sec,
  1547.                                         Trtime2[st-1].frame ) ;
  1548.                                 clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  1549.                                 line = (st-1) % 20 + CUR_Y0 ;
  1550.                                 CRT_setcur( clm,line ) ;
  1551.                                 if ( ( Trtime[st-1].min & 0x80 ) == 0x80 ) {
  1552.                                                             /*  ﾃﾞｰﾀ        */
  1553.                                     strdisp( Strbuf,REV,BLUE ) ;
  1554.                                 } else {
  1555.                                     if ( SideAon[st-1] )
  1556.                                         strdisp( Strbuf,REV,YELLOW ) ;
  1557.                                     else
  1558.                                         strdisp( Strbuf,REV,WHITE ) ;
  1559.                                 }
  1560.                             }
  1561.                         }
  1562.  
  1563.                         if ( keyrepflg ) {
  1564.                             soft_time( KEY_repeat ) ;
  1565.                         } else {
  1566.                             soft_time( KEY_wait ) ;
  1567.                             keyrepflg = TRUE ;
  1568.                         }
  1569.  
  1570.                          KEY_bufcls() ;
  1571.                         KEY_matrix( wmatrix ) ;
  1572.  
  1573.                     } while ( KEY_test( wmatrix,KEY_RIGHT ) ) ;
  1574.                 }
  1575.  
  1576.             } else if ( KEY_test( matrix,KEY_LEFT ) ) {        /*  CUR left    */
  1577.                 if ( CDflg.ready ) {
  1578.                     keyrepflg = FALSE ;
  1579.                     do {
  1580.                         if ( (CURx-XCNT) < CUR_X1 ) {
  1581.                             ;
  1582.                         } else {
  1583.                             st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  1584.                             sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  1585.                                     st,Trtime2[st-1].min,Trtime2[st-1].sec,
  1586.                                     Trtime2[st-1].frame ) ;
  1587.                             clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  1588.                             line = (st-1) % 20 + CUR_Y0 ;
  1589.                             CRT_setcur( clm,line ) ;
  1590.                             if ( ( Trtime[st-1].min & 0x80 ) == 0x80 ) {
  1591.                                                             /*  ﾃﾞｰﾀ        */
  1592.                                 strdisp( Strbuf,STD,BLUE ) ;
  1593.                             } else {
  1594.                                 if ( SideAon[st-1] )
  1595.                                     strdisp( Strbuf,STD,YELLOW ) ;
  1596.                                 else
  1597.                                     strdisp( Strbuf,STD,WHITE ) ;
  1598.                             }
  1599.  
  1600.                             CURx -= XCNT ;
  1601.  
  1602.                             st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  1603.                             if ( st == 1 && Cdtype == 3 ) {
  1604.                                 CURx += XCNT ;
  1605.                                 st = ( CURy-CUR_Y0+1 ) + ( CURx/XCNT ) * 20 ;
  1606.                             }
  1607.                             sprintf( Strbuf," %02d %02d分%02d秒%02d ",
  1608.                                     st,Trtime2[st-1].min,Trtime2[st-1].sec,
  1609.                                     Trtime2[st-1].frame ) ;
  1610.                             clm  = ( (st-1) / 20 ) * XCNT + 1 ;
  1611.                             line = (st-1) % 20 + CUR_Y0 ;
  1612.                             CRT_setcur( clm,line ) ;
  1613.                             if ( ( Trtime[st-1].min & 0x80 ) == 0x80 ) {
  1614.                                                             /*  ﾃﾞｰﾀ        */
  1615.                                 strdisp( Strbuf,REV,BLUE ) ;
  1616.                             } else {
  1617.                                 if ( SideAon[st-1] )
  1618.                                     strdisp( Strbuf,REV,YELLOW ) ;
  1619.                                 else
  1620.                                     strdisp( Strbuf,REV,WHITE ) ;
  1621.                             }
  1622.                         }
  1623.  
  1624.                         if ( keyrepflg ) {
  1625.                             soft_time( KEY_repeat ) ;
  1626.                         } else {
  1627.                             soft_time( KEY_wait ) ;
  1628.                             keyrepflg = TRUE ;
  1629.                         }
  1630.  
  1631.                          KEY_bufcls() ;
  1632.                         KEY_matrix( wmatrix ) ;
  1633.  
  1634.                     } while ( KEY_test( wmatrix,KEY_LEFT ) ) ;
  1635.                 }
  1636.  
  1637.             } else if ( KEY_test( matrix,KEY_ESC ) ) {        /*  STOP END    */
  1638.                 endflg = TRUE ;
  1639.                 CDflg.stop = TRUE ;
  1640.  
  1641.                 cmddisp( CMD_ESC,STD,YELLOW ) ;
  1642.  
  1643.             } else if ( KEY_test( matrix,KEY_SHIFT ) 
  1644.                         && KEY_test( matrix,KEY_1 ) ) {        /*  SHELL        */
  1645.                 shell() ;
  1646.                 playflg = TRUE ;
  1647.  
  1648.             }
  1649.         }
  1650.  
  1651.         if ( endflg ) break ;
  1652.  
  1653. /*
  1654. **    ＣＤが入れ換えられた
  1655. */
  1656.         if ( CDflg.change ) {
  1657.             CURx = CUR_X0 ;
  1658.             CURy = CUR_Y0 ;
  1659.             mdisp( CURx,CURy ) ;
  1660.         }
  1661. /*
  1662. **    演奏状態の表示
  1663. */
  1664.         if ( ITcount > CDC_wait ) {
  1665.             musicdisp( playflg ) ;
  1666.             ITcount = 0 ;
  1667.         }
  1668.  
  1669.     }
  1670.  
  1671. close: ;
  1672.     return ;
  1673. }
  1674.  
  1675. /*************************  演奏中にSTOPするのか？ ***************************/
  1676. int playcheck()
  1677. {
  1678.     int        ret, loopon ;
  1679.     char    key ;
  1680.  
  1681.     ret = TRUE ;
  1682.     if ( CDnows == NOW_PLAY ) {
  1683.         CRT_setcur( MSG_X,CUR_Y0 ) ;
  1684.         msgdisp( M_NOWPLAY,STD,MC_WAR ) ;
  1685.         warbeep() ;
  1686.  
  1687.         loopon = TRUE ;
  1688.         do {
  1689.             key = inkey() ;
  1690.             switch ( key ) {
  1691.                 case 'y' :
  1692.                 case 'Y' :
  1693.                     ret = TRUE ;
  1694.                     loopon = FALSE ;
  1695.                     break ;
  1696.                 case 'n' :
  1697.                 case 'N' :
  1698.                     ret = FALSE ;
  1699.                     loopon = FALSE ;
  1700.                     break ;
  1701.             }
  1702.         } while ( loopon ) ;
  1703.     }
  1704.  
  1705.     return( ret ) ;
  1706. }
  1707.  
  1708. /***************************  ★ メインだよ～ ★  ****************************/
  1709. void main( int ac, char *av[] )
  1710. {
  1711.     int        ret ;
  1712.  
  1713.     titledisp() ;
  1714.  
  1715.     ret = nowstatus() ;
  1716.     if ( ret == DEVERR ) {
  1717.         CDflg.stop = FALSE ;
  1718.         deverr() ;
  1719.         goto close ;
  1720.     }
  1721.  
  1722.     if ( !playcheck() ) goto close ;
  1723.  
  1724.     CRT_setcur( MSG_X,CUR_Y0 ) ;
  1725.     msgdisp( M_READING,STD,MC_STD ) ;
  1726.  
  1727.     if ( tocread() ) {                                        /*  TOC READ    */
  1728.         CRT_setcur( MSG_X,CUR_Y0 ) ;
  1729.         msgdisp( M_NOTREADY,STD,MC_WAR ) ;
  1730.         warbeep() ;
  1731.         goto close ;
  1732.     }
  1733.  
  1734. /*
  1735. **    CDDA のないコンパクトディスクには用がないので、プログラム終了！
  1736. */
  1737.     if ( Cdtype!=1 && Cdtype!=3 ) {
  1738.         CRT_setcur( MSG_X,CUR_Y0 ) ;
  1739.         msgdisp( M_NOTDA,STD,MC_WAR ) ;
  1740.         warbeep() ;
  1741.         goto close ;
  1742.     }
  1743.  
  1744. /*
  1745. **    割り込み処理
  1746. */
  1747.     int23_init() ;
  1748.  
  1749.     ITcount = 0 ;
  1750.     ITIMER_init() ;
  1751.  
  1752. /*
  1753. **    プレイ開始
  1754. */
  1755.     KEY_bufcls() ;
  1756.     VolMax() ;
  1757.     play() ;
  1758.  
  1759.     if ( CDflg.stop )
  1760.         stddisp( M_STOPEND ) ;
  1761.     else
  1762.         stddisp( M_PGEND ) ;
  1763.  
  1764. /*
  1765. **    割り込み終了処理
  1766. */
  1767.     ITIMER_release() ;
  1768.     int23_release() ;
  1769.  
  1770.     KEY_bufcls() ;
  1771. /*
  1772. **    ﾌﾟﾛｸﾞﾗﾑ終了処理
  1773. */
  1774. close: ;
  1775.     if ( CDflg.stop ) {
  1776.         if ( CDR_mstop( Cddrv ) ) CDR_mstop( Cddrv ) ;
  1777.     }
  1778.     CRT_cr() ;
  1779.     CRT_cursw( TRUE ) ;
  1780.     CRT_defatr( STD,WHITE ) ;
  1781.  
  1782. }
  1783.  
  1784.