home *** CD-ROM | disk | FTP | other *** search
/ Delphi Programming Unleashed / Delphi_Programming_Unleashed_SAMS_Publishing_1995.iso / misc / cdmusicc / cdinfo.cpp next >
Encoding:
C/C++ Source or Header  |  1995-03-21  |  8.9 KB  |  379 lines
  1. //////////////////////////////////////
  2. // Program: CDINFO.CPP
  3. // Programmer: Charlie Calvert
  4. // Date: August 6, 1993
  5. // Description: DLL Module from Harmony program
  6. //////////////////////////////////////
  7.  
  8. #define STRICT
  9. #include <windows.h>
  10. #include <windowsx.h>
  11. #include <mmsystem.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14. #pragma warning (disable : 4068)
  15.  
  16. static HWND PlayWindow;
  17. static WORD wDeviceID;
  18. #define MsgLen 200
  19.  
  20.  
  21. //////////////////////////////////////
  22. // LibMain
  23. //////////////////////////////////////
  24. #pragma argsused
  25. int CALLBACK LibMain(HINSTANCE hInstance, WORD wDataSeg,
  26.                      WORD wHeapSize, LPSTR lpszCmdLine)
  27. {
  28.   if (wHeapSize > 0)
  29.        UnlockData(0);
  30.  
  31.   return 1;
  32. }
  33.  
  34. //////////////////////////////////////
  35. // Wep
  36. //////////////////////////////////////
  37. #pragma argsused
  38. int CALLBACK WEP (int nParameter)
  39. {
  40.   return 1;
  41. }
  42.  
  43. //////////////////////////////////////
  44. // GetErrorMessage
  45. //////////////////////////////////////
  46. LPSTR GetErrorMessage(DWORD RC, LPSTR S)
  47. {
  48.   if (!mciGetErrorString(RC, S, MsgLen))
  49.     strcpy(S, "No message available");
  50.   return S;
  51. }
  52.  
  53. //////////////////////////////////////
  54. // ErrorMsg
  55. //////////////////////////////////////
  56. BOOL CALLBACK _export ErrorMsg(DWORD Error,
  57.                                LPSTR CallingFunc)
  58. {
  59.   char S[MsgLen + 50];
  60.   char S1[MsgLen];
  61.  
  62.   GetErrorMessage(Error, S1);
  63.   sprintf(S, "Calling Func: %s\nReturn Code: %ld\n %s",
  64.           CallingFunc, Error, S1);
  65.   if (Error)
  66.   {
  67.     MessageBox(0, S, "Information",
  68.                MB_OK | MB_ICONINFORMATION);
  69.     return FALSE;
  70.   }
  71.   return TRUE;
  72. }
  73.  
  74. //////////////////////////////////////
  75. // OpenCD
  76. //////////////////////////////////////
  77. BOOL CALLBACK _export OpenCD(HWND PWindow)
  78. {
  79.   MCI_OPEN_PARMS Info;
  80.   DWORD Result, Flags;
  81.  
  82.   memset(&Info, 0, sizeof(MCI_OPEN_PARMS));
  83.   Info.dwCallback = DWORD(PWindow);
  84.   Info.lpstrDeviceType =
  85.                      MAKEINTRESOURCE(MCI_DEVTYPE_CD_AUDIO);
  86.   Flags = MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID;
  87.   Result = mciSendCommand(0, MCI_OPEN, Flags, DWORD(&Info));
  88.  
  89.   wDeviceID = Info.wDeviceID;
  90.  
  91.   if (Result)
  92.   {
  93.     ErrorMsg(Result, "OpenCD");
  94.     return FALSE;
  95.   }
  96.   return TRUE;
  97. }
  98.  
  99. //////////////////////////////////////
  100. // CloseCDMCI
  101. //////////////////////////////////////
  102. BOOL CALLBACK _export CloseCDMCI(void)
  103. {
  104.   DWORD ErrorNum;
  105.   MCI_GENERIC_PARMS Info;
  106.  
  107.   memset(&Info, 0, sizeof(MCI_GENERIC_PARMS));
  108.   ErrorNum = mciSendCommand(wDeviceID, MCI_CLOSE,
  109.                             MCI_NOTIFY, DWORD(&Info));
  110.   if (ErrorNum)
  111.   {
  112.     ErrorMsg(ErrorNum, "CloseCDMCI");
  113.     return FALSE;
  114.   }
  115.   return TRUE;
  116. }
  117.  
  118. //////////////////////////////////////
  119. // StopCDMCI
  120. //////////////////////////////////////
  121. BOOL CALLBACK _export StopCDMCI(void)
  122. {
  123.   DWORD ErrorNum;
  124.   MCI_GENERIC_PARMS Info;
  125.  
  126.   Info.dwCallback = 0;
  127.   ErrorNum = mciSendCommand(wDeviceID, MCI_STOP,
  128.                             MCI_NOTIFY, DWORD(&Info));
  129.   if (ErrorNum)
  130.   {
  131.     ErrorMsg(ErrorNum, "StopCDMCI");
  132.     return FALSE;
  133.   }
  134.   return TRUE;
  135. }
  136.  
  137. //////////////////////////////////////
  138. // PauseCDMCI
  139. //////////////////////////////////////
  140. BOOL CALLBACK _export PauseCDMCI(void)
  141. {
  142.   MCI_GENERIC_PARMS Info;
  143.   DWORD ErrorNum;
  144.   char S1[MsgLen];
  145.  
  146.   memset(&Info, 0, sizeof(MCI_GENERIC_PARMS));
  147.   ErrorNum = mciSendCommand(wDeviceID, MCI_PAUSE,
  148.                             0, DWORD(&Info));
  149.   if (ErrorNum)
  150.   {
  151.     ErrorMsg(ErrorNum, "PauseCDMCI");
  152.     return FALSE;
  153.   }
  154.   return TRUE;
  155. }
  156.  
  157. //////////////////////////////////////
  158. // SetTMSFasFormat
  159. //////////////////////////////////////
  160. void CALLBACK _export SetTMSFasFormat(void)
  161. {
  162.   MCI_SET_PARMS Info;
  163.   DWORD Result;
  164.  
  165.   Info.dwCallback = 0;
  166.   Info.dwTimeFormat = MCI_FORMAT_TMSF;
  167.   Info.dwAudio = 0;
  168.  
  169.   Result = mciSendCommand(wDeviceID, MCI_SET,
  170.                         MCI_SET_TIME_FORMAT, DWORD(&Info));
  171.  
  172.   if (Result)
  173.     ErrorMsg(Result, "SetTMSFasFormat");
  174. }
  175.  
  176. //////////////////////////////////////
  177. // PlayCDOneTrack
  178. //////////////////////////////////////
  179. void CALLBACK _export PlayCDOneTrack(BYTE StartTrack)
  180. {
  181.   MCI_PLAY_PARMS Info;
  182.   DWORD Flags, Result;
  183.  
  184.   memset(&Info, 0, sizeof(MCI_PLAY_PARMS));
  185.   Info.dwFrom = MCI_MAKE_TMSF(StartTrack,0,0,0);
  186.  
  187.   Flags = MCI_FROM | MCI_NOTIFY;
  188.   Result = mciSendCommand(wDeviceID, MCI_PLAY,
  189.                           Flags, DWORD(&Info));
  190.  
  191.   if (Result)
  192.     ErrorMsg(Result, "PlayCDOneTrack");
  193. }
  194.  
  195. //////////////////////////////////////
  196. // PlayMCICD
  197. //////////////////////////////////////
  198. void CALLBACK _export PlayMciCD(BYTE StartTrack, BYTE EndTrack)
  199. {
  200.   MCI_PLAY_PARMS Info;
  201.   DWORD Flags, Result;
  202.   char S1[MsgLen];
  203.  
  204.   memset(&Info, 0, sizeof(MCI_PLAY_PARMS));
  205.   Info.dwFrom = MCI_MAKE_TMSF(StartTrack,0,0,0);
  206.   Info.dwTo   = MCI_MAKE_TMSF(EndTrack,  0,0,0);
  207.  
  208.   Flags = MCI_FROM | MCI_TO | MCI_NOTIFY;
  209.   Result = mciSendCommand(wDeviceID, MCI_PLAY,
  210.                           Flags, DWORD(&Info));
  211.  
  212.   if (Result) ErrorMsg(Result, "PlayCDMCI");
  213. }
  214.  
  215. //////////////////////////////////////
  216. // GetCDNumTracks
  217. //////////////////////////////////////
  218. DWORD CALLBACK _export GetCDNumTracks(void)
  219. {
  220.   MCI_STATUS_PARMS Info;
  221.   DWORD Result;
  222.  
  223.  
  224.   Info.dwCallback = 0;
  225.   Info.dwReturn   = 0;
  226.   Info.dwItem     = MCI_STATUS_NUMBER_OF_TRACKS;
  227.   Info.dwTrack    = 0;
  228.   Result = mciSendCommand(wDeviceID, MCI_STATUS,
  229.                       MCI_STATUS_ITEM, DWORD(&Info));
  230.   if (Result)
  231.   {
  232.     ErrorMsg(Result, "GetCDNumTracks");
  233.     return -1;
  234.   }
  235.  
  236.   return Info.dwReturn;
  237. }
  238.  
  239. //////////////////////////////////////
  240. // GetCDTrackLength
  241. //////////////////////////////////////
  242. void CALLBACK _export GetCDTrackLength(DWORD TrackNum,
  243.                        BYTE *Min, BYTE *Sec, BYTE *Frame)
  244. {
  245.   MCI_STATUS_PARMS Info;
  246.   DWORD Result, MSF;
  247.   char MessageText[MsgLen];
  248.  
  249.   memset(&Info, 0, sizeof(MCI_STATUS_PARMS));
  250.   Info.dwTrack    = TrackNum;
  251.   Info.dwItem     = MCI_STATUS_LENGTH;
  252.  
  253.   Result = mciSendCommand(wDeviceID, MCI_STATUS,
  254.                      MCI_STATUS_ITEM | MCI_TRACK,
  255.                      DWORD(&Info));
  256.  
  257.   if (Result)
  258.   {
  259.     ErrorMsg(Result, "GetCDTrackLength");
  260.     return;
  261.   }
  262.  
  263.   MSF =Info.dwReturn;
  264.  
  265.   *Min = MCI_MSF_MINUTE(MSF);
  266.   *Sec = MCI_MSF_SECOND(MSF);
  267.   *Frame = MCI_MSF_FRAME(MSF);
  268. }
  269.  
  270. //////////////////////////////////////
  271. // GetLengthofEachTrack
  272. //////////////////////////////////////
  273. void CALLBACK _export GetLengthOfEachTrack(DWORD TrackNum, BYTE *Min, 
  274.                                            BYTE *Sec, BYTE *Frame)
  275. {
  276.   MCI_STATUS_PARMS Info;
  277.   DWORD Result, Flags, MSF;
  278.  
  279.   memset(&Info, 0, sizeof(MCI_STATUS_PARMS));
  280.   Info.dwTrack = TrackNum;
  281.   Info.dwItem = MCI_STATUS_LENGTH;
  282.   Flags = MCI_STATUS_ITEM | MCI_TRACK;
  283.   Result = mciSendCommand(wDeviceID, MCI_STATUS,
  284.                           Flags, DWORD(&Info));
  285.  
  286.   if (Result)
  287.   {
  288.     ErrorMsg(Result, "GetLengthOfEachTrack");
  289.     return;
  290.   }
  291.  
  292.   MSF = Info.dwReturn;
  293.   *Min = MCI_MSF_MINUTE(MSF);
  294.   *Sec = MCI_MSF_SECOND(MSF);
  295.   *Frame = MCI_MSF_FRAME(MSF);
  296. }
  297.  
  298. //////////////////////////////////////
  299. // GetCurrentCDTrack
  300. //////////////////////////////////////
  301. DWORD CALLBACK _export GetCurrentCDTrack(void)
  302. {
  303.   MCI_STATUS_PARMS Info;
  304.   DWORD Result;
  305.  
  306.   memset(&Info, 0, sizeof(MCI_STATUS_PARMS));
  307.   Info.dwItem     = MCI_STATUS_CURRENT_TRACK;
  308.  
  309.   Result = mciSendCommand(wDeviceID, MCI_STATUS,
  310.                        MCI_STATUS_ITEM, DWORD(&Info));
  311.  
  312.   if (Result)
  313.   {
  314.     ErrorMsg(Result, "GetCurrentCDTrack");
  315.     return FALSE;
  316.   }
  317.   return Info.dwReturn;
  318. }
  319.  
  320. //////////////////////////////////////
  321. // HasDiskInserted
  322. //////////////////////////////////////
  323. BOOL CALLBACK _export HasDiskInserted(void)
  324. {
  325.   MCI_STATUS_PARMS Info;
  326.   DWORD Flags, Result;
  327.  
  328.   memset(&Info, 0, sizeof(MCI_STATUS_PARMS));
  329.   Info.dwItem = MCI_STATUS_MEDIA_PRESENT;
  330.  
  331.   Flags = MCI_STATUS_ITEM;
  332.   Result=mciSendCommand(wDeviceID, MCI_STATUS,
  333.                         Flags, DWORD(&Info));
  334.  
  335.   if (Result)
  336.   {
  337.     ErrorMsg(Result, "HasDiskInserted");
  338.     return FALSE;
  339.   }
  340.  
  341.   return Info.dwReturn > 0;
  342. }
  343.  
  344. //////////////////////////////////////
  345. // EjectCD
  346. //////////////////////////////////////
  347. void CALLBACK _export EjectCD(void)
  348. {
  349.   MCI_SET_PARMS Info;
  350.   DWORD Flags, Result;
  351.  
  352.   memset(&Info, 0, sizeof(MCI_SET_PARMS));
  353.   Flags = MCI_SET_DOOR_OPEN;
  354.   Result = mciSendCommand( wDeviceID, MCI_SET,
  355.                            Flags, DWORD(&Info));
  356.   if (Result)
  357.     ErrorMsg(Result, "EjectCD");
  358. }
  359.  
  360. //////////////////////////////////////
  361. // GetCDLocation
  362. //////////////////////////////////////
  363. DWORD CALLBACK _export GetCDLocation(void)
  364. {
  365.   MCI_STATUS_PARMS Info;
  366.   DWORD Flags, ErrorNum;
  367.  
  368.   Info.dwItem = MCI_STATUS_POSITION;
  369.   Flags = MCI_STATUS_ITEM;
  370.   ErrorNum = mciSendCommand(wDeviceID, MCI_STATUS,
  371.                             Flags, DWORD(&Info));
  372.   if (ErrorNum)
  373.   {
  374.     ErrorMsg(ErrorNum, "GetLocation");
  375.     return -1;
  376.   }
  377.   return Info.dwReturn;
  378. }
  379.