home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mmpm21tk.zip / TK / ADMCT / ADMCSTGC.C < prev    next >
C/C++ Source or Header  |  1992-11-18  |  20KB  |  542 lines
  1. /********************* START OF SPECIFICATIONS *********************
  2. *
  3. * SUBROUTINE NAME: MCISTAT
  4. *
  5. * DESCRIPTIVE NAME: Audio MCD Status Routine
  6. *
  7. * FUNCTION:Get Instance Status
  8. *
  9. * NOTES:
  10. *
  11. * ENTRY POINTS:
  12. *     LINKAGE:   CALL FAR
  13. *
  14. * INPUT: MCI_STATUS message.
  15. *
  16. * EXIT-NORMAL:Lo Word Return  Code MCIERR_SUCCESS, HighWord Contains
  17. *             constant defining type of quantity returned.
  18. *
  19. * EXIT_ERROR:  Error Code.
  20. *
  21. * EFFECTS:
  22. *
  23. *
  24. * INTERNAL REFERENCES:
  25. *                        ConvertTimeUnits ().
  26. *                        ConVertToMM
  27. *                        SetAudioDevice().
  28. *                        InitAudioDevice().
  29. *                        SetWaveDeviceDefaults().
  30. *                        CheckMem ().
  31. *
  32. * EXTERNAL REFERENCES:
  33. *                        SpiGetTime       ()        - MME API
  34. *                        mciSendCommand   ()        - MME API
  35. *
  36. *********************** END OF SPECIFICATIONS **********************/
  37. /*static char *SCCSID = "@(#)admcstgc.c 13.110 92/04/16";*/
  38. #define INCL_BASE                       // Base Dos APIs.
  39. #define INCL_ERRORS                     // All the errors.
  40.  
  41. #include <os2.h>                        // OS2 includes.
  42. #include <string.h>                     // String Functions
  43. #include <math.h>                       // Math Functions
  44. #include <os2medef.h>                   // MME includes files.
  45. #include <ssm.h>                        // SSM spi includes.
  46. #include <meerror.h>                    // MM Error Messages.
  47. #include <mmsystem.h>                   // MM System Include.
  48. #include <audio.h>                      // Audio DD Defines
  49. #include <mcidrv.h>                     // Mci Driver include.
  50. #include <mmio.h>                       // MMIO Include.
  51. #include <mcd.h>                        // AUDIO IF DriverInterface.
  52. #include <hhpheap.h>                    // Heap Manager Definitions.
  53. #include <audiomcd.h>                   // Component Definitions.
  54. #include <admcfunc.h>                   // Function Prototypes
  55.  
  56. /********************* START OF SPECIFICATIONS *******************************
  57. *
  58. * SUBROUTINE NAME: MCISTAT.C
  59. *
  60. * DESCRIPTIVE NAME: Waveform Status Routine.
  61. *
  62. * FUNCTION: Get Current Status of an Waveform Instance.
  63. *
  64. * NOTES: After the status is obtained from the device specific DLL
  65. *        the corresponding field in the instance structure is updated
  66. *        to reflect the most recent state.
  67. *
  68. * ENTRY POINTS:
  69. *     LINKAGE:   CALL FAR
  70. *
  71. * INPUT:
  72. *
  73. * EXIT-NORMAL: Return Code 0.
  74. *
  75. * EXIT_ERROR:  Error Code.
  76. *
  77. * EFFECTS:
  78. *
  79. * INTERNAL REFERENCES: VSDIDriverEntry().
  80. *
  81. * EXTERNAL REFERENCES: DosQueryProcAddr - OS/2 API.
  82. *
  83. *********************** END OF SPECIFICATIONS *******************************/
  84.  
  85. RC MCIStat (FUNCTION_PARM_BLOCK *pFuncBlock)
  86.  
  87. {
  88.  
  89.   ULONG               ulrc;                // Error Value
  90.   ULONG               ulParam1;            // MCI Msg Flags
  91.   ULONG               ulParam2;            // MCI Msg Data
  92.   INSTANCE*           ulpInstance;         // Local Instance
  93.   DWORD               dwFileSize;          // Length of the file
  94.   ULONG               ulTemp1;             // Temporary Stuff
  95.   ULONG               ulTemp2;             // Temporary Stuff
  96.   ULONG               ulErr;               // RC
  97.   DWORD               dwStatFlags;         // Mask For Incoming Flags
  98.   MCI_STATUS_PARMS    WaveStat;            // Internal Use
  99.   LPMCI_STATUS_PARMS  pParams;             // Msg Data Ptr
  100.  
  101.   /*****************************
  102.   * Intialize The vars
  103.   ******************************/
  104.   ulrc = MCIERR_SUCCESS;
  105.   dwFileSize = 0;
  106.   ulTemp1 = 0;
  107.  
  108.   /******************************
  109.   * Derefernce Pointers
  110.   *******************************/
  111.   ulParam1 =   pFuncBlock->ulParam1;
  112.   ulParam2 =   pFuncBlock->ulParam2;
  113.   ulpInstance= (INSTANCE *)(pFuncBlock->ulpInstance);
  114.  
  115.   /*****************************
  116.   * Check for Invalid Flags
  117.   *****************************/
  118.   dwStatFlags = ulParam1;
  119.  
  120.   dwStatFlags &= ~ (MCI_STATUS_ITEM + MCI_TRACK + MCI_WAIT + MCI_NOTIFY);
  121.  
  122.   if (dwStatFlags > 0 )
  123.           return MCIERR_INVALID_FLAG;
  124.  
  125.   ulrc = CheckMem ((PVOID)pFuncBlock->ulParam2,
  126.                    sizeof (MCI_STATUS_PARMS), PAG_READ);
  127.  
  128.   if (ulrc != MCIERR_SUCCESS)
  129.           return MCIERR_MISSING_PARAMETER;
  130.  
  131.   if (ulParam1 & MCI_TRACK)
  132.           return MCIERR_UNSUPPORTED_FLAG;
  133.  
  134.  
  135.   pParams =    (LPMCI_STATUS_PARMS)ulParam2;
  136.  
  137.   if (ulpInstance == (ULONG)NULL )
  138.           return MCIERR_INSTANCE_INACTIVE;
  139.  
  140.   /*****************************************************************
  141.   * Send a status request over to the devspcfc DLL
  142.   * over the VSD Interface. All device specific status fields get
  143.   * updated by DevSpcfc DLL. Status flags cannot be ORed.
  144.   *****************************************************************/
  145.   if (ulParam1 & MCI_STATUS_ITEM ) {
  146.  
  147.       switch (pParams->dwItem)
  148.       {
  149.       case MCI_STATUS_POSITION:
  150.            {
  151.            if (ulpInstance->ulCreateFlag != CREATE_STATE ) {
  152.                STREAM.mmStreamTime = 0;
  153.                /********************************************
  154.                * Query the stream for current stream time
  155.                *********************************************/
  156.                ulrc = SpiGetTime (STREAM.hStream,
  157.                                   (PMMTIME)&(STREAM.mmStreamTime));
  158.                if (!ulrc)
  159.  
  160.                    /*****************************************
  161.                    * Convert MMTIME units to current Time base
  162.                    ******************************************/
  163.                   ConvertTimeUnits (ulpInstance, (DWORD*)&(ulTemp1),
  164.                                     (DWORD) (STREAM.mmStreamTime));
  165.  
  166.                pParams->dwReturn = (DWORD)ulTemp1;
  167.            }
  168.            else
  169.                pParams->dwReturn = 0;  // No Stream Alive
  170.  
  171.            ulrc = MAKEULONG (ulrc, MCI_INTEGER_RETURNED);
  172.  
  173.           }
  174.           break;
  175.  
  176.       case MCI_STATUS_LENGTH:
  177.            {
  178.  
  179.            if (ulpInstance->usFileExists == UNUSED)
  180.                return (MCIERR_FILE_NOT_FOUND);
  181.  
  182.            if (ulpInstance->usPlayLstStrm == TRUE)
  183.                return MCIERR_INDETERMINATE_LENGTH;
  184.  
  185.            if (AMPMIX.ulOperation == OPERATION_PLAY)
  186.               {
  187.               if ( ulpInstance->mmioHndlPrvd )
  188.                  {
  189.                  /*****************************************************
  190.                  *  if the user passed in the handle, they may have
  191.                  *  updated the size of the file so update our instance
  192.                  *****************************************************/
  193.  
  194.                  ulrc = GetAudioHeader( ulpInstance );
  195.                  if ( ulrc )
  196.                    {
  197.                    return MCIERR_DRIVER_INTERNAL;
  198.                    }
  199.                  }
  200.  
  201.               /******************************************
  202.               * the function ConvertTimeUnits also
  203.               * returns media element length in the
  204.               * current time units.
  205.               ******************************************/
  206.               ConvertTimeUnits (ulpInstance, &ulTemp1, FILE_LENGTH);
  207.  
  208.               pParams->dwReturn = ulTemp1;
  209.  
  210.               }      /* Play Back case */
  211.  
  212.            else
  213.                if (ulpInstance->ulCreateFlag == PREROLL_STATE)
  214.                    {
  215.                    if ( STRMSTATE == MCI_RECORD )
  216.                       {
  217.                       ulrc = SpiGetTime ( STREAM.hStream,
  218.                                           ( PMMTIME)&(STREAM.mmStreamTime));
  219.  
  220.                       if (!ulrc)
  221.                          {
  222.                          ulTemp2 = STREAM.mmStreamTime;
  223.                          }
  224.  
  225.                       ConvertTimeUnits (ulpInstance, &ulTemp1, ulTemp2);
  226.  
  227.                       /******************************************
  228.                       * the function ConvertTimeUnits also
  229.                       * returns media element length in the
  230.                       * current time units.
  231.                       ******************************************/
  232.                       ConvertTimeUnits (ulpInstance, &ulTemp2, FILE_LENGTH);
  233.  
  234.                       /******************************************
  235.                       * if the current record position is smaller
  236.                       * tham the file length, then report the
  237.                       * file length.
  238.                       ******************************************/
  239.                       if ( ulTemp1 < ulTemp2 )
  240.                          {
  241.                          ulTemp1 = ulTemp2;
  242.                          }
  243.  
  244.                       pParams->dwReturn = ulTemp1;
  245.                       }
  246.                    else
  247.                       {
  248.                       if ( ulpInstance->mmioHndlPrvd )
  249.                          {
  250.                          /*****************************************************
  251.                          *  if the user passed in the handle, they may have
  252.                          *  updated the size of the file so update our instance
  253.                          *****************************************************/
  254.  
  255.                          ulrc = GetAudioHeader( ulpInstance );
  256.                          if ( ulrc )
  257.                            {
  258.                            return MCIERR_DRIVER_INTERNAL;
  259.                            }
  260.                          }
  261.  
  262.                       /******************************************
  263.                       * the function ConvertTimeUnits also
  264.                       * returns media element length in the
  265.                       * current time units.
  266.                       *******************************************/
  267.                       ConvertTimeUnits (ulpInstance, &ulTemp1, FILE_LENGTH);
  268.  
  269.                       pParams->dwReturn = ulTemp1;
  270.                       }
  271.  
  272.                    } /* Stream Created and Recording */
  273.  
  274.            else
  275.               {
  276.  
  277.               if ( ulpInstance->mmioHndlPrvd )
  278.                  {
  279.                  /*****************************************************
  280.                  *  if the user passed in the handle, they may have
  281.                  *  updated the size of the file so update our instance
  282.                  *****************************************************/
  283.  
  284.                  ulrc = GetAudioHeader( ulpInstance );
  285.                  if ( ulrc )
  286.                    {
  287.                    return MCIERR_DRIVER_INTERNAL;
  288.                    }
  289.  
  290.                  /******************************************
  291.                  * the function ConvertTimeUnits also
  292.                  * returns media element length in the
  293.                  * current time units.
  294.                  ******************************************/
  295.                  ConvertTimeUnits (ulpInstance, &ulTemp1, FILE_LENGTH);
  296.  
  297.                  pParams->dwReturn = ulTemp1;
  298.  
  299.                  }
  300.               else
  301.                  {
  302.                  pParams->dwReturn = 0;         /* No Element Case */
  303.                  }
  304.  
  305.               }
  306.  
  307.            ulrc = MAKEULONG (ulrc, MCI_INTEGER_RETURNED);
  308.  
  309.            }
  310.            break;
  311.  
  312.       case MCI_STATUS_NUMBER_OF_TRACKS:
  313.             return MCIERR_UNSUPPORTED_FLAG;
  314.            break;
  315.  
  316.       case MCI_STATUS_SPEED_FORMAT:
  317.             return MCIERR_UNSUPPORTED_FLAG;
  318.            break;
  319.       case MCI_STATUS_CURRENT_TRACK:
  320.             return MCIERR_UNSUPPORTED_FLAG;
  321.            break;
  322.  
  323.       case MCI_STATUS_POSITION_IN_TRACK:
  324.             return MCIERR_UNSUPPORTED_FLAG;
  325.            break;
  326.  
  327.       case MCI_STATUS_VOLUME:
  328.             ulrc = mciSendCommand ( ulpInstance->wAmpDeviceID,
  329.                                     MCI_STATUS,
  330.                                     MCI_STATUS_ITEM | MCI_WAIT,
  331.                                     (DWORD) pParams,
  332.                                     pFuncBlock->usUserParm);
  333.  
  334.             ulrc = MAKEULONG (ulrc, MCI_COLONIZED2_RETURN);
  335.           break;
  336. // 5622
  337.      case MCI_STATUS_AUDIO:
  338.             ulrc = mciSendCommand ( ulpInstance->wAmpDeviceID,
  339.                                     MCI_STATUS,
  340.                                     MCI_STATUS_ITEM | MCI_WAIT,
  341.                                     (DWORD) pParams,
  342.                                     pFuncBlock->usUserParm);
  343.  
  344.             ulrc = MAKEULONG (ulrc, MCI_TRUE_FALSE_RETURN );
  345.           break;
  346.  
  347.       case MCI_AMP_STATUS_BALANCE:
  348.       case MCI_AMP_STATUS_BASS   :
  349.       case MCI_AMP_STATUS_TREBLE :
  350.       case MCI_AMP_STATUS_GAIN   :
  351.             ulrc = mciSendCommand ( ulpInstance->wAmpDeviceID,
  352.                                     MCI_STATUS,
  353.                                     MCI_STATUS_ITEM | MCI_WAIT,
  354.                                     (DWORD) pParams,
  355.                                     pFuncBlock->usUserParm );
  356.  
  357.             ulrc = MAKEULONG (ulrc, MCI_INTEGER_RETURNED );
  358.           break;
  359.  
  360.  
  361.       case MCI_WAVE_STATUS_CHANNELS:
  362.             WaveStat.dwItem = MCI_WAVE_STATUS_CHANNELS;
  363.             ulrc = ulpInstance->pfnVSD (&MIX,
  364.                                         MCI_STATUS,
  365.                                         MCI_STATUS_ITEM |
  366.                                         MCI_WAVE_STATUS_CHANNELS,
  367.                                         (LONG) &WaveStat,
  368.                                         0L);
  369.             pParams->dwReturn = WaveStat.dwReturn;
  370.             ulrc = MAKEULONG (ulrc, MCI_INTEGER_RETURNED);
  371.  
  372.           break;
  373.  
  374.       case MCI_WAVE_STATUS_SAMPLESPERSEC:
  375.             WaveStat.dwItem = MCI_WAVE_STATUS_SAMPLESPERSEC;
  376.             ulrc = ulpInstance->pfnVSD ( &MIX,
  377.                                          MCI_STATUS,
  378.                                          MCI_STATUS_ITEM |
  379.                                          MCI_WAVE_STATUS_SAMPLESPERSEC,
  380.                                          (LONG)&WaveStat,
  381.                                          0L);
  382.             pParams->dwReturn = WaveStat.dwReturn;
  383.             ulrc = MAKEULONG (ulrc, MCI_INTEGER_RETURNED);
  384.  
  385.           break;
  386.  
  387.       case MCI_WAVE_STATUS_AVGBYTESPERSEC:
  388.  
  389.              pParams->dwReturn = ulpInstance->ulAverageBytesPerSec;
  390.  
  391.              ulrc = MAKEULONG (ulrc, MCI_INTEGER_RETURNED);
  392.  
  393.           break;
  394.  
  395.       case MCI_WAVE_STATUS_BITSPERSAMPLE:
  396.             WaveStat.dwItem = MCI_WAVE_STATUS_BITSPERSAMPLE;
  397.             ulrc = ulpInstance->pfnVSD ( &MIX,
  398.                                          MCI_STATUS,
  399.                                          MCI_STATUS_ITEM |
  400.                                          MCI_WAVE_STATUS_BITSPERSAMPLE,
  401.                                          (LONG)&WaveStat,
  402.                                          0L );
  403.             pParams->dwReturn = WaveStat.dwReturn;
  404.             ulrc = MAKEULONG (ulrc, MCI_INTEGER_RETURNED);
  405.           break;
  406.  
  407.       case MCI_WAVE_STATUS_LEVEL:
  408.             pParams->dwReturn = 0;
  409.             ulrc = MAKEULONG (ulrc, MCI_INTEGER_RETURNED);
  410.           break;
  411.  
  412.       case MCI_WAVE_STATUS_FORMATTAG:
  413.             WaveStat.dwItem = MCI_WAVE_STATUS_FORMATTAG;
  414.             ulrc = ulpInstance->pfnVSD ( &MIX,
  415.                                          MCI_STATUS,
  416.                                          MCI_STATUS_ITEM |
  417.                                          MCI_WAVE_STATUS_FORMATTAG,
  418.                                          (LONG) &WaveStat,
  419.                                          0L );
  420.             pParams->dwReturn = WaveStat.dwReturn;
  421.             ulrc = MAKEULONG (ulrc, MCI_FORMAT_TAG_RETURN);
  422.           break;
  423.  
  424.       case MCI_STATUS_MEDIA_PRESENT:
  425.             pParams->dwReturn = MCI_TRUE;
  426.             ulrc = MAKEULONG(ulrc, MCI_TRUE_FALSE_RETURN);
  427.           break;
  428.  
  429.       case MCI_WAVE_STATUS_BLOCKALIGN:
  430.            pParams->dwReturn = AMPMIX.ulBlockAlignment;
  431.            ulrc = MAKEULONG(ulrc, MCI_INTEGER_RETURNED);
  432.           break;
  433.  
  434.       case MCI_STATUS_MODE:
  435.            {
  436.               /********************************************
  437.                * Always Return an Integer for this case
  438.               ********************************************/
  439.               ulrc = MAKEULONG (ulrc, MCI_MODE_RETURN);
  440.               if (ulpInstance->usMediaPresent != MCI_TRUE)
  441.                   pParams->dwReturn = MCI_MODE_NOT_READY;
  442.               else
  443.                   {
  444.                      switch (STRMSTATE)
  445.                      {
  446.                       case MCI_PLAY:
  447.                             pParams->dwReturn = MCI_MODE_PLAY;
  448.                            break;
  449.  
  450.                       case MCI_RECORD:
  451.                             pParams->dwReturn = MCI_MODE_RECORD;
  452.                            break;
  453.  
  454.                       case MCI_STOP:
  455.                             pParams->dwReturn = MCI_MODE_STOP;
  456.                            break;
  457.  
  458.                       case MCI_PAUSE:
  459.                             pParams->dwReturn = MCI_MODE_PAUSE;
  460.                            break;
  461.  
  462.                       case MCI_SEEK:
  463.                             pParams->dwReturn = MCI_MODE_SEEK;
  464.                            break;
  465.  
  466.                       default:
  467.                            {
  468.                               /********************************
  469.                               * Check if Amp/Mixer is Ready
  470.                               *********************************/
  471.                               WaveStat.dwItem = MCI_STATUS_READY;
  472.                               ulErr = mciSendCommand ( ulpInstance->wAmpDeviceID,
  473.                                                        MCI_STATUS,
  474.                                                        MCI_STATUS_ITEM | MCI_WAIT,
  475.                                                        (DWORD)(&WaveStat),
  476.                                                        pFuncBlock->usUserParm );
  477.  
  478.                               if (WaveStat.dwReturn == MCI_FALSE)
  479.                                    pParams->dwReturn = MCI_MODE_NOT_READY;
  480.                               else
  481.                                    pParams->dwReturn = MCI_MODE_STOP;
  482.                            } /* Default Case */
  483.                      }    /* of Possible Modes (Switch) */
  484.                   }       /* The device was ready */
  485.            }  /* Status Mode */
  486.           break;
  487.  
  488.       case MCI_STATUS_TIME_FORMAT:
  489.            {
  490.             switch (ulpInstance->ulTimeUnits)
  491.             {
  492.              case lMMTIME:
  493.                    pParams->dwReturn = MCI_FORMAT_MMTIME;
  494.                   break;
  495.  
  496.              case lMILLISECONDS:
  497.                    pParams->dwReturn = MCI_FORMAT_MILLISECONDS;
  498.                   break;
  499.  
  500.              case lBYTES:
  501.                    pParams->dwReturn = MCI_FORMAT_BYTES;
  502.                   break;
  503.  
  504.              case lSAMPLES:
  505.                    pParams->dwReturn = MCI_FORMAT_SAMPLES;
  506.                   break;
  507.              } /* Switch */
  508.  
  509.              ulrc = MAKEULONG (ulrc, MCI_TIME_FORMAT_RETURN);
  510.  
  511.           }
  512.           break;
  513.  
  514.       case MCI_STATUS_READY:
  515.             if (ulpInstance->usMediaPresent == MCI_TRUE) {
  516.                  /*****************************************
  517.                  * Check if Amp/Mixer is Ready and active
  518.                  *****************************************/
  519.                  ulrc = mciSendCommand ( ulpInstance->wAmpDeviceID,
  520.                                          MCI_STATUS,
  521.                                          MCI_STATUS_ITEM | MCI_WAIT,
  522.                                          (DWORD) (pParams),
  523.                                          pFuncBlock->usUserParm );
  524.             }
  525.             else
  526.                  pParams->dwReturn = MCI_FALSE;
  527.  
  528.             ulrc = MAKEULONG(ulrc, MCI_TRUE_FALSE_RETURN);
  529.           break;
  530.  
  531.       default:
  532.              return (MCIERR_INVALID_FLAG);
  533.  
  534.       }       /* end of switch */
  535.   }   /* Status Item */
  536.   else
  537.         return  MCIERR_MISSING_FLAG;
  538.  
  539.   return (ulrc);
  540.  
  541. }        /* end of wavstat */
  542.