home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / cdplay2 / chinon.c < prev    next >
C/C++ Source or Header  |  1993-05-26  |  11KB  |  358 lines
  1. /*
  2.  
  3.  a program to play audio CDs on the Chinon CDX-431 drive
  4.  and any other player that follows the SCSI-II spec.
  5.  NOTE NEC players DO NOT follow the spec.
  6.  
  7. */
  8. #include <aes.h>
  9. #include <vdi.h>
  10. #include <tos.h>
  11. #include <time.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include "dma.h"
  16. #include "chinon.h"
  17. #include "cdplayer.h"
  18. #include "globals.h"
  19.  
  20. #define DESKTOP 0         /* the window handle for the desktop */
  21.  
  22. char *DISC_STOPPED = "T 00  00:00" ;
  23. char *REPEAT_STRINGS[3] = { "            ",
  24.                             "Repeat: SONG",
  25.                             "Repeat: DISC" } ;
  26.  
  27. main(int argc,char *argv[],char *enpv[])
  28. {
  29. int          disp_id ;
  30. int          rept_id ;
  31. int          diag_id ;
  32. int          repeat_mode = 0 ;
  33. int          complete ;
  34. int          panel_id ;
  35. int          result ;
  36. int          play_mode ;
  37. int          tmp_trk ;
  38. int          tmp_time ;
  39. time_t       stime = 0 ;
  40. time_t       tmptime = 0 ;
  41. FILE       * fp ;
  42.  
  43. char       * tmp_addr ;
  44.  
  45.   ID = 0 ;
  46.   LUN = 0 ;
  47.   cur_index = -1 ;
  48.   play_mode = INIT_MODE ;
  49.   if (appl_init() == -1)
  50.     return 1 ;
  51.  
  52.   if (rsrc_load("cdplayer.rsc") == 0)
  53.   {
  54.     appl_exit() ;
  55.     return 2 ;
  56.   }
  57.   wind_get(DESKTOP, WF_FULLXYWH, &cx, &cy, &cw, &ch) ;
  58.  
  59.   if (ch >= 300)
  60.   {
  61.     diag_id = HIGH ;
  62.     panel_id = PANELH ;
  63.     disp_id = DISPH ;
  64.     rept_id = REPTH ;
  65.   }
  66.   else
  67.   {
  68.     diag_id = MEDIUM ;
  69.     panel_id = PANELM ;
  70.     disp_id = DISPM ;
  71.     rept_id = REPTM ;
  72.   }
  73.  
  74.   if (rsrc_gaddr(0, diag_id, &form_addr) == 0)
  75.   {
  76.     rsrc_free() ;
  77.     appl_exit() ;
  78.     return 3 ;
  79.   }
  80.  
  81.   disp_text = form_addr[disp_id].ob_spec.tedinfo->te_ptext ;
  82.  
  83.   rept_text = form_addr[rept_id].ob_spec.tedinfo->te_ptext ;
  84.  
  85.   strcpy(rept_text, REPEAT_STRINGS[repeat_mode]) ;
  86.  
  87.   rsrc_gaddr(0, MENUBAR, &menu_addr) ;
  88.  
  89.   menu_bar(menu_addr, 1) ;
  90.  
  91.   ID = 16 ;
  92.   if ((fp = fopen("CDPLAYER.DAT", "r")) != NULL)
  93.   {
  94.     fscanf(fp, "%d", &ID) ;
  95.     if ((ID < 0) || (ID > 15))
  96.     {
  97.       form_alert(1,"[1][File: CDPLAYER.DAT|ID out of range 0..15][Please Fix]") ;
  98.       ID = 16 ;
  99.     }
  100.   }
  101.  
  102.   if (ID == 16)
  103.     find_Chinon() ;  /* find the CDS-43x */
  104.  
  105.   if (ID == 16)
  106.   {
  107.     form_alert(1,"[3][Could not locate CD-Rom][Ok]") ;
  108.   }
  109.   else
  110.   {
  111. /*
  112.    check for playing already in progress and if disk is/isnot
  113.    an audio CD
  114. */
  115.     read_TOC(&toc) ;
  116.     time_remaining = Get_Time_Remain() ;
  117.     if (time_remaining == (double)0.0)
  118.       play_mode = INIT_MODE ;
  119.     else
  120.     {
  121.       play_mode = PLAY_MODE ;
  122.       stime = time(&tmptime) ;
  123.     }
  124.     Create_Window() ;
  125.     Update_Window(diag_id) ;
  126.  
  127.     bstate = 1 ;
  128.     complete = FALSE ;
  129.     while(complete != TRUE)
  130.     { 
  131.       event = evnt_multi(MU_BUTTON | MU_TIMER | MU_MESAG,
  132.                  1, 1, bstate,
  133.                  0, 0, 0, 0, 0,
  134.                  0, 0, 0, 0, 0,
  135.                  ev_buffer,
  136.                  2000, 0,
  137.                  &ev_mmox, &ev_mmoy,
  138.                  &ev_mmbutton, &ev_mmokstate, &dummy1, &dummy2) ;
  139.  
  140.       if (event == MU_MESAG)
  141.       {
  142.         complete = Process_Message() ;
  143.       }
  144.  
  145.       if ((event & MU_BUTTON) != 0)
  146.       {
  147.         if (bstate == 0)
  148.         {
  149.           bstate = 1 ;
  150.         }
  151.         else
  152.         {
  153. /* need to check if the disk was changed */
  154.           read_TOC(&toc_tmp) ;
  155.           if ( toc_cmp(&toc, &toc_tmp) != 0 )
  156.           {
  157.             play_mode = INIT_MODE ;  /* new disk... everything changes */
  158.             toc_copy(&toc, &toc_tmp) ;
  159.             current_track = next_track(-1) ;
  160.           }
  161.  
  162.           bstate = 0 ;
  163.           graf_mkstate(&ev_mmox, &ev_mmoy, &ev_mmbutton, &ev_mmokstate) ;
  164.           result = objc_find(form_addr, panel_id, 8, ev_mmox, ev_mmoy) ;
  165.           switch (result) {
  166.             case EXITH   : complete = TRUE ;
  167.                            break ;
  168.             case EJECTH  : stop_audio() ;
  169.                            eject_cd() ;
  170.                            play_mode = INIT_MODE ;
  171.                            break ;
  172.             case STOPH   : stop_audio() ;
  173.                            play_mode = INIT_MODE ;
  174.                            strcpy(disp_text, DISC_STOPPED) ;
  175.                            objc_draw(form_addr, disp_id, MAX_DEPTH, cx, cy, cw, ch) ;
  176.                            break ;
  177.             case PLAYH   : switch (play_mode) 
  178.                            {
  179.                              case INIT_MODE  : current_track = next_track(-1) ;
  180.                                                if (current_track != -1)
  181.                                                {
  182.                                                  play_audio(current_track) ;
  183.                                                  time_remaining = t_sec(&(toc.tracks[current_track + 1].addr)) 
  184.                                                                 - t_sec(&(toc.tracks[current_track].addr)) ;
  185.                                                  play_mode = PLAY_MODE ;
  186.                                                  stime = time(&tmptime) ;
  187.                                                }
  188.                                                break ;
  189.                              case PLAY_MODE  : stop_audio() ;
  190.                                                play_mode = PAUSE_MODE ;
  191.                                                break ;
  192.                              case PAUSE_MODE : continue_audio() ;
  193.                                                time_remaining = t_sec(&(toc.tracks[current_track + 1].addr)) 
  194.                                                               - t_sec(&(sub_channel.abs_addr)) ;
  195.                                                play_mode = PLAY_MODE ;
  196.                                                stime = time(&tmptime) ;
  197.                                                break ;
  198.                            }
  199.                            break ;
  200.             case BACKH   : if (play_mode != INIT_MODE)
  201.                            {
  202.                              tmp_trk = prev_track(current_track) ;
  203.                              if (tmp_trk != -1)
  204.                              {
  205.                                stop_audio() ;
  206.                                current_track = tmp_trk ;
  207.                                play_audio(current_track) ;
  208.                                time_remaining = t_sec(&(toc.tracks[current_track + 1].addr)) 
  209.                                               - t_sec(&(toc.tracks[current_track].addr)) ;
  210.                                play_mode = PLAY_MODE ;
  211.                                stime = time(&tmptime) ;
  212.                              }
  213.                            }
  214.                            break ;
  215.             case FWDH    : if (play_mode != INIT_MODE)
  216.                            {
  217.                              tmp_trk = next_track(current_track) ;
  218.                              if (tmp_trk != -1)
  219.                              {
  220.                                stop_audio() ;
  221.                                current_track = tmp_trk ;
  222.                                play_audio(current_track) ;
  223.                                time_remaining = t_sec(&(toc.tracks[current_track + 1].addr)) 
  224.                                               - t_sec(&(toc.tracks[current_track].addr)) ;
  225.                                play_mode = PLAY_MODE ;
  226.                                stime = time(&tmptime) ;
  227.                              }
  228.                            }
  229.                            break ;
  230.             case RPTH    : repeat_mode++ ;
  231.                            if (repeat_mode > 2)
  232.                               repeat_mode = 0 ;
  233.                            strcpy(rept_text, REPEAT_STRINGS[repeat_mode]) ;
  234.                            objc_draw(form_addr, rept_id, MAX_DEPTH, cx, cy, cw, ch) ;
  235.                            break ;
  236.           }
  237.           form_addr[result].ob_state &= ~SELECTED ;
  238.         }       
  239.       }
  240.       if ((event & MU_TIMER) != 0)
  241.       {
  242.         if (time_remaining < difftime(time(&tmptime), stime))
  243.         {
  244.           switch (repeat_mode)
  245.           {
  246.             case 1: current_track = prev_track(current_track) ;
  247.                     break ;
  248.             case 2: if (next_track(current_track) == -1)
  249.                       current_track = -1 ;
  250.                     break ;
  251.           }
  252.           current_track = next_track(current_track) ;
  253.           if (current_track == -1)
  254.             play_mode = INIT_MODE ;   /* no more audio tracks */
  255.           else
  256.           {
  257.             if (play_mode == PLAY_MODE)
  258.             {
  259.               stop_audio() ;
  260.               play_audio(current_track) ;
  261.               time_remaining = t_sec(&(toc.tracks[current_track + 1].addr)) 
  262.                              - t_sec(&(toc.tracks[current_track].addr)) ;
  263.               stime = time(&tmptime) ;
  264.             }
  265.           }
  266.         }
  267.       }
  268. /*
  269.    It is time to update the display
  270. */
  271.       if (play_mode == PLAY_MODE)
  272.       {
  273.         tmp_time = (int) time_remaining - difftime(time(&tmptime), stime) ;
  274.         sprintf(disp_text, "T %2.2d  %2.2d:%2.2d", current_track+1,
  275.                 (tmp_time / 60), (tmp_time % 60)) ;
  276.         Update_Window(disp_id) ;
  277.       }
  278.     }
  279.   }
  280.  
  281.   menu_bar(menu_addr, 0) ;
  282.   Remove_Window() ;
  283.   rsrc_free() ;
  284.   appl_exit() ;
  285.   return (0) ;
  286. }
  287.  
  288. double t_sec(ABS_CD_ROM_ADDR * addr)
  289. {
  290. double result ;
  291.  
  292.   result = (double)(addr->minute * 60) ;
  293.   result += (double)(addr->second) ;
  294.   result += ((double)addr->field / (double)256.0 ) ;
  295.   return (result) ;
  296. }
  297.  
  298. void toc_copy(TOC_DATA_FORMAT * dest, TOC_DATA_FORMAT * src) 
  299. {
  300. int i ;
  301. char * d ;
  302. char * s ;
  303.  
  304.   d = (char *)dest ;
  305.   s = (char *)src ;
  306.  
  307.   for ( i=0; i < sizeof(TOC_DATA_FORMAT); i++)
  308.     *d++ = *s++ ;
  309. }
  310.  
  311. int toc_cmp(TOC_DATA_FORMAT * toc1, TOC_DATA_FORMAT * toc2) 
  312. {
  313. int i ;
  314. char * d ;
  315. char * s ;
  316.  
  317.   d = (char *)toc1 ;
  318.   s = (char *)toc2 ;
  319.  
  320.   i=0 ;
  321.   while ((*d++ == *s++) && (i < sizeof(TOC_DATA_FORMAT)) )
  322.     i++ ;
  323.  
  324.   if (i < sizeof(TOC_DATA_FORMAT) )
  325.     return (1) ;
  326.   else
  327.     return (0) ;
  328. }
  329.  
  330. int next_track(int cur_trk)
  331. {
  332. loop:
  333.   cur_trk++ ;
  334.   if (cur_trk >= toc.header.last_track)
  335.     return -1 ;
  336. /*
  337.   make sure that the new track is an audio track
  338. */
  339.   if ((toc.tracks[cur_trk].addr_cntrl &0xf) != 0)
  340.     goto loop ;
  341.  
  342.   return cur_trk ;
  343. }
  344.  
  345. int prev_track(int cur_trk)
  346. {
  347. loop:
  348.   cur_trk-- ;
  349.   if (cur_trk < (toc.header.first_track-1))
  350.     return -1 ;
  351. /*
  352.   make sure that the new track is an audio track
  353. */
  354.   if ((toc.tracks[cur_trk].addr_cntrl &0xf) != 0)
  355.     goto loop ;
  356.  
  357.   return cur_trk ;
  358. }