home *** CD-ROM | disk | FTP | other *** search
/ Multimedia Classic / MultimediaClassic.mdf / audio_cd / cthugha.dos / cdmaster.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-19  |  7.9 KB  |  377 lines
  1. ;    /*\
  2. ;    |*|    cdmaster.c
  3. ;    |*|    
  4. ;    |*|    routines for c-interface to cdrom audio functions
  5. ;    |*|    contains routines accessing internal data structures
  6. ;    |*|
  7. ;    |*|    Copyright (c) 1992, Media Vision, Inc.  All Rights Reserved
  8. ;    |*|
  9. ;    \*/
  10.  
  11. #include <stdlib.h>
  12.  
  13. #include "cdmaster.h"
  14.  
  15. static struct cdtable OURCDTABLES[26];
  16.  
  17. ;    /*\
  18. ;    |*|    struct cdtable *createaudiotoc(int drive)
  19. ;    |*|
  20. ;    |*|    allocate memory for table of contents for audio disc in drive
  21. ;    |*|    call destroyaudiotoc() to free memory and clear internal table
  22. ;    |*|
  23. ;    |*|    Entry:    drive number, address of buffer
  24. ;    |*|
  25. ;    |*|    Exit:    return address of internal table of contents
  26. ;    |*|
  27. ;    \*/
  28.  
  29. struct cdtable *createaudiotoc(int drive)
  30. {
  31.     int status;
  32.     struct discinfo *di;
  33.     struct trackinfo *ti;
  34.  
  35.     /* destroy any existing toc for this drive */
  36.     destroyaudiotoc(drive);
  37.  
  38.     di= &OURCDTABLES[drive].di;
  39.     status= cddiscinfo(drive, di);
  40.  
  41.     if (status& 0x8000)
  42.         return((struct cdtable *) 0);
  43.  
  44.     ti= (struct trackinfo *) calloc(di->ltrk- di->strk+ 1+ 1, sizeof(struct trackinfo));
  45.  
  46.     if (!ti)
  47.         return((struct cdtable *) 0);
  48.  
  49.         {
  50.         int i;
  51.         struct trackinfo *dti;
  52.  
  53.         /* for now, do nothing;  we will cdtrackinfo(drive, i, dti); */
  54.         for (i= di->strk, dti= ti; i <= di->ltrk; i++, dti++)
  55.             ;    
  56.  
  57.             {
  58.             int dmin, dsec, dframe;
  59.             dmin= ((di->eodisc& 0x00FF0000)>> 16);
  60.             dsec= ((di->eodisc& 0x0000FF00)>> 8);
  61.             dframe= ((di->eodisc& 0x000000FF)>> 0);
  62.  
  63.             /* audio data starts 2 seconds into the disc */
  64.             /* dsec-= 2; !! removed and put into cdplay */
  65.  
  66.             fixmsf(&dmin, &dsec, &dframe);
  67.  
  68.             dti->track= i;
  69.             dti->min= (char) dmin;
  70.             dti->sec= (char) dsec;
  71.             dti->frame= (char) dframe;
  72.             }
  73.         }
  74.  
  75.     OURCDTABLES[drive].ti= ti;
  76.  
  77.     return(&OURCDTABLES[drive]);
  78. }
  79.  
  80. ;    /*\
  81. ;    |*|    struct cdtable *buildaudiotoc(int drive)
  82. ;    |*|
  83. ;    |*|    allocate memory and build table of contents for audio disc in drive
  84. ;    |*|    call destroyaudiotoc() to free memory and clear internal table
  85. ;    |*|
  86. ;    |*|    Entry:    drive number, address of buffer
  87. ;    |*|
  88. ;    |*|    Exit:    return address of internal table of contents
  89. ;    |*|
  90. ;    \*/
  91.  
  92. struct cdtable *buildaudiotoc(int drive)
  93. {
  94.     int i;
  95.     struct cdtable *cdt= createaudiotoc(drive);
  96.  
  97.     if (!cdt)
  98.         return(cdt);
  99.  
  100.     for (i= cdt->di.strk; i <= cdt->di.ltrk; i++)
  101.         gettrackframes(drive, i);
  102.  
  103.     return(cdt);
  104.  
  105. }
  106.  
  107. ;    /*\
  108. ;    |*|    void destroyaudiotoc(int drive)
  109. ;    |*|
  110. ;    |*|    free memory allocated by buildaudiotoc() and clear internal tables
  111. ;    |*|    if passed address is not the same as internal table
  112. ;    |*|
  113. ;    |*|    Entry:    drive number, address of buffer
  114. ;    |*|
  115. ;    |*|    Exit:    return 0 if table entry for drive was not 0, else -1
  116. ;    |*|
  117. ;    \*/
  118.  
  119. destroyaudiotoc(int drive)
  120. {
  121.     int notallocated= 0;
  122.  
  123.     if (OURCDTABLES[drive].ti)
  124.         free(OURCDTABLES[drive].ti);
  125.     else
  126.         notallocated= -1;
  127.  
  128.     OURCDTABLES[drive].ti= (struct trackinfo *) 0;
  129. //    OURCDTABLES[drive].di= (struct discinfo *) 0;
  130.  
  131.     return(notallocated);
  132. }
  133.  
  134. ;    /*\
  135. ;    |*|    struct cdtable *getcdtable(int drive)
  136. ;    |*|
  137. ;    |*|    return address of internal cd table for drive
  138. ;    |*|
  139. ;    |*|    Entry:    drive number
  140. ;    |*|
  141. ;    |*|    Exit:    address of internal cd table  
  142. ;    |*|
  143. ;    \*/
  144.  
  145. struct cdtable *getcdtable(int drive)
  146. {
  147.     return(&OURCDTABLES[drive]);
  148. }
  149.  
  150. ;    /*\
  151. ;    |*|    struct discinfo *getdiscinfotable(int drive)
  152. ;    |*|
  153. ;    |*|    return address of internal discinfo structure for drive
  154. ;    |*|
  155. ;    |*|    Entry:    drive number
  156. ;    |*|
  157. ;    |*|    Exit:    address of internal discinfo structure
  158. ;    |*|
  159. ;    \*/
  160.  
  161. struct discinfo *getdiscinfotable(int drive)
  162. {
  163.     return(&OURCDTABLES[drive].di);
  164. }
  165.  
  166. ;    /*\
  167. ;    |*|    struct trackinfo *gettrackinfotable(int drive)
  168. ;    |*|
  169. ;    |*|    return address of internal table of contents for drive
  170. ;    |*|
  171. ;    |*|    Entry:    drive number
  172. ;    |*|
  173. ;    |*|    Exit:    address of internal table of contents
  174. ;    |*|
  175. ;    \*/
  176.  
  177. struct trackinfo *gettrackinfotable(int drive)
  178. {
  179.     return(OURCDTABLES[drive].ti);
  180. }
  181.  
  182. ;    /*\
  183. ;    |*|    long gettrackframes(int drive, int track)
  184. ;    |*|
  185. ;    |*|    return the number of frames for given track on the disc
  186. ;    |*|
  187. ;    |*|    Entry: drive number, track number
  188. ;    |*|
  189. ;    |*|    Exit:    return length of track in frames, or
  190. ;    |*|            return 0 if internal tables not initialized or track
  191. ;    |*|            number out of range
  192. ;    |*|
  193. ;    \*/
  194.  
  195. long gettrackframes(int drive, int track)
  196. {
  197.     int lframe;
  198.     int lsec;
  199.     int lmin;
  200.     struct discinfo *di;
  201.     struct trackinfo *dti;
  202.     struct trackinfo *nti;
  203.     long tframe;
  204.  
  205.     di= &OURCDTABLES[drive].di;
  206.     dti= OURCDTABLES[drive].ti;
  207.  
  208.     if (!di || !dti || track < di->strk || track > di->ltrk)
  209.         return(0);
  210.  
  211.     dti+= track- di->strk;
  212.     nti= dti+ 1;
  213.  
  214.     if (!dti->track)
  215.         {
  216.         cdtrackinfo(drive, track, dti);
  217. //        dti->sec-= 2;    /* data starts 2 seconds into disc */
  218.         }
  219.  
  220.     if (!nti->track)
  221.         {
  222.         cdtrackinfo(drive, track+ 1, nti);
  223. //        nti->sec-= 2;    /* data starts 2 seconds into disc */
  224.         }
  225.  
  226.     lmin= nti->min- dti->min;
  227.     lsec= nti->sec- dti->sec;
  228.     lframe= nti->frame- dti->frame;
  229.  
  230.     if (fixmsf(&lmin, &lsec, &lframe) == -1)
  231.         return(-1);
  232.  
  233.     tframe= lmin;
  234.     tframe*= 60;
  235.     tframe+= lsec;
  236.     tframe*= 75;
  237.     tframe+= lframe;
  238.  
  239.     return(tframe);
  240. }
  241.  
  242. ;    /*\
  243. ;    |*|    playcdtrack(int drive, int track, int offset, int length)
  244. ;    |*|
  245. ;    |*|    begin audio play on disc for specified track at offset for length
  246. ;    |*|
  247. ;    |*|    Entry:    drive number, track number, offset in seconds in track,
  248. ;    |*|                length in seconds or -1 for rest of disc or -2 for track
  249. ;    |*|
  250. ;    |*|    Exit:    return -1 if no disc present, no internal table of contents,
  251. ;    |*|                track is out of range, offset is past end of track or disc
  252. ;    |*|            else return driver status
  253. ;    |*|
  254. ;    \*/
  255.  
  256. playcdtrack(int drive, int track, int offset, int length)
  257. {
  258.     int ourtrack;
  259.     int ourstatus;
  260.     struct discinfo *di;
  261.     struct trackinfo *ti, *sti, *dti;
  262.     int min, sec, frame;
  263.     int dmin, dsec, dframe;
  264.  
  265.     ourstatus= cdstatus(drive);
  266.  
  267.     if (!(ourstatus& CDISHERE))
  268.         return(-1);
  269.  
  270.     if (!OURCDTABLES[drive].ti)
  271.         return(-1);
  272.  
  273.     di= &OURCDTABLES[drive].di;
  274.  
  275.     ourtrack= track- di->strk;
  276.  
  277.     if (ourtrack < 0 || ourtrack >= di->ltrk)
  278.         return(-1);
  279.  
  280.     if (ourstatus& (CDISPLAYING| CDISPAUSED))
  281.         cdstop(drive);
  282.  
  283.     /* get starting MSF for our track
  284.     * sti points to first trackinfo structure for disc
  285.     * ti will point to the track to play
  286.     * dti will point to the ending point
  287.     */
  288.  
  289.     ti= dti= sti= OURCDTABLES[drive].ti;
  290.     ti+= ourtrack;
  291.  
  292.     if (!ti->track)
  293.         {
  294.         cdtrackinfo(drive, track, ti);
  295. //        ti->sec-= 2;
  296.         }
  297.  
  298.     /* min,sec,frame will hold the start m:s:f address */
  299.     min= ti->min;
  300.     sec= ti->sec;
  301.     frame= ti->frame;
  302.  
  303.     /* length is amount of seconds to play, a negative is special */
  304.     if (length < 0)
  305.         {
  306.         switch (length)
  307.             {
  308.             case -1: dti+= di->ltrk- di->strk+ 1; break;    /* rest of disc */
  309.             case -2: dti+= ourtrack+ 1; break;                /* rest of track */
  310.             }
  311.         length= 0;
  312.         }
  313.  
  314.     if (!dti->track)
  315.         {
  316.         cdtrackinfo(drive, dti- sti+ di->strk, dti);
  317. //        dti->sec-= 2;
  318.         }
  319.  
  320.     /* dmin,dsec,drame holds the amount of time to play */
  321.     dmin= dti->min- min;
  322.     dsec= dti->sec- sec;
  323.     dframe= dti->frame- frame;
  324.  
  325.     /* offset and length are passed as parameters as seconds, affect */
  326.     sec+= offset;
  327.     dsec+= length- offset;
  328.  
  329.     /* adjust length (endofdisc- startofdisc) */
  330.     dmin-= sti->min;
  331.     dsec-= sti->sec;
  332.     dframe-= sti->frame;
  333.  
  334.  
  335.     if (fixmsf(&min, &sec, &frame) < 0)
  336.         return(-1);
  337.     if (fixmsf(&dmin, &dsec, &dframe) < 0)
  338.         return(-1);
  339.  
  340.     return(cdplaymsf(drive, min, sec, frame, dmin, dsec, dframe));
  341. }
  342.  
  343. ;    /*\
  344. ;    |*|    seektotrack(int drive, int track)
  345. ;    |*|
  346. ;    |*|    move head on drive to specified track
  347. ;    |*|
  348. ;    |*|    Entry:    drive number, track number
  349. ;    |*|
  350. ;    |*|     Exit:   return 0 if no internal tables or track out of range,
  351. ;    |*|             else return driver status
  352. ;    |*|
  353. ;    \*/
  354.  
  355. seektotrack(int drive, int track)
  356. {
  357.     struct discinfo *d= &OURCDTABLES[drive].di;
  358.     struct trackinfo *t= OURCDTABLES[drive].ti;
  359.  
  360.     if (!d || !t)
  361.         return(0);
  362.  
  363.     if (track < d->strk || track > d->ltrk)
  364.         return(0);
  365.  
  366.     t+= track- d->strk;
  367.  
  368.     if (!t->track)
  369.         {
  370.         cdtrackinfo(drive, track, t);
  371. //        t->sec-= 2;
  372.         }
  373.  
  374.     return(cdseekmsf(drive, t->min, t->sec, t->frame));
  375. }
  376.  
  377.