API tools faq
paste
Advertisement
Kitomas

kit_w32_audio.c (scrapped)

Kitomas
Jul 14th, 2023
740
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 24.31 KB | Source Code | 0 0
raw download clone embed print report
  1. //compile with kernel32, and ole32
  2.  /**
  3.   * \file kit_w32_audio.c
  4.   * \brief Header file for KIT Win32's audio module
  5.   */
  6.  
  7. #include <kit_w32_audio.h>
  8. #include <_kit_w32_audioCOM.h>
  9. #include <_kit_w32_audioPropKeyDef.h> //#include <Functiondiscoverykeys_devpkey.h>
  10.  
  11.  
  12. #define _KIT_AUDIO_MMONO   (SPEAKER_FRONT_LEFT)
  13. #define _KIT_AUDIO_MSTEREO (_KIT_AUDIO_MMONO  |SPEAKER_FRONT_RIGHT  )
  14. #define _KIT_AUDIO_M2_1S   (_KIT_AUDIO_MSTEREO|SPEAKER_LOW_FREQUENCY)
  15. #define _KIT_AUDIO_MQUAD   (_KIT_AUDIO_MSTEREO|SPEAKER_BACK_LEFT    |SPEAKER_BACK_RIGHT)
  16. #define _KIT_AUDIO_M4_1S   (_KIT_AUDIO_MQUAD  |SPEAKER_LOW_FREQUENCY)
  17. #define _KIT_AUDIO_M5_1S   (_KIT_AUDIO_M4_1S  |SPEAKER_FRONT_CENTER )
  18. #define _KIT_AUDIO_M6_1S   (_KIT_AUDIO_M2_1S  |SPEAKER_FRONT_CENTER |SPEAKER_SIDE_LEFT |SPEAKER_SIDE_RIGHT)
  19. #define _KIT_AUDIO_M7_1S   (_KIT_AUDIO_M5_1S  |SPEAKER_SIDE_LEFT    |SPEAKER_SIDE_RIGHT)
  20.  
  21.  
  22. #define _KIT_AUDIO_LOCKCALLBACKTHREAD(_device) \
  23.   EnterCriticalSection(&_device->_callback_mutex);
  24. #define _KIT_AUDIO_UNLOCKCALLBACKTHREAD(_device) \
  25.   LeaveCriticalSection(&_device->_callback_mutex);
  26.  
  27.  
  28. #define _IS_ERROR(_value,_before_goto) \
  29.   { returnStatus=_value; _before_goto; goto _error_; }
  30. #define _IF_ERROR(_condition,_value,_before_goto) \
  31.   if(_condition){ _IS_ERROR(_value,_before_goto); }
  32.  
  33. #define _KIT_AUDIO_FREE(_action,_pointer) \
  34.   if(_pointer != NULL){ _action(_pointer); }
  35. #define _KIT_AUDIO_RELEASE(_action,_pointer) \
  36.   if(_pointer != NULL){ while(numRefs){ \
  37.     numRefs=_action(_pointer); \
  38.   }} \
  39.   numRefs=1;
  40.  
  41.  
  42. #define _LOCK_GLOBALS_AUDIO EnterCriticalSection(&_kit_audioGlobals.lock);
  43. #define _UNLOCK_GLOBALS_AUDIO LeaveCriticalSection(&_kit_audioGlobals.lock);
  44. /*
  45. typedef struct {
  46.   union {
  47.     WAVEFORMATEX         device_format;
  48.     WAVEFORMATEXTENSIBLE device_format_ext;
  49.   };
  50.   IMMDeviceCollection* devices;
  51.   IMMDevice*            device;
  52.   IPropertyStore*        props;
  53.   IAudioClient*         client;
  54.   LPWSTR             device_id; //aka wide char* (wchar_t*)!
  55.   LPWSTR          device_iname;
  56.   LPWSTR           device_name;
  57.   LPWSTR           device_desc;
  58.   size_t      device_iname_len;
  59.   size_t       device_name_len;
  60.   size_t       device_desc_len;
  61.   UINT            device_index;
  62.   EDataFlow          data_flow; //read-only; set by init
  63.   int                data_type; //1,2,3 = pcm&format, float&format_ext, pcm&format_ext
  64.   int     event_driven_support; //might not be used
  65. } _kit_audioGlobalsDevInfo;
  66. struct _kit_audioGlobals_s {
  67.   CRITICAL_SECTION           lock;
  68.   IMMDeviceEnumerator* enumerator;
  69.   kit_audioDevice**   kit_devices;
  70.   UINT            kit_devices_len;
  71.   _kit_audioGlobalsDevInfo      i;
  72.   _kit_audioGlobalsDevInfo      o;
  73.   int                        init;
  74. };
  75. */
  76. //(todo: eventually make this struct opaque and anonymous)
  77. struct _kit_audioGlobals_s _kit_audioGlobals={0};
  78. //KSDATAFORMAT_SUBTYPE_IEEE_FLOAT="00000003-0000-0010-8000-00aa00389b71"
  79. const GUID    _SUBTYPE_IEEE_FLOAT={.Data1=0x00000003,.Data2=0x0000,.Data3=0x0010,.Data4={0x80,0x00, 0x00,0xaa,0x00,0x38,0x9b,0x71}};
  80. //KSDATAFORMAT_SUBTYPE_PCM       ="00000001-0000-0010-8000-00aa00389b71"
  81. const GUID    _SUBTYPE_PCM       ={.Data1=0x00000001,.Data2=0x0000,.Data3=0x0010,.Data4={0x80,0x00, 0x00,0xaa,0x00,0x38,0x9b,0x71}};
  82.  
  83.  
  84.  
  85. /* (private) INLINES */
  86.  
  87. static inline int _kit_audioCountBits(long long unsigned int bitState){
  88.   int bitCount=0;
  89.   while(bitState){ bitCount+=bitState&1; bitState>>=1; }
  90.   return bitCount;
  91. }
  92.  
  93.  
  94.  
  95. /* CALLBACK-RELATED FUNCTIONS */
  96.  
  97.  
  98.  
  99. /* COM-RELATED FUNCTIONS */
  100.  
  101. kit_audioSpec _kit_audioWaveFormatToSpec(WAVEFORMATEX* format_ex, int* returnStatus_p){ /*0 -> 5*/
  102.   int returnStatus=0; kit_audioSpec spec; //memset(&spec,0xff,sizeof(kit_audioSpec));
  103.   WAVEFORMATEXTENSIBLE* format_ext=(void*)format_ex;
  104.  
  105.   _IF_ERROR(format_ex==NULL,1,;);
  106.   WORD format_tag=format_ex->wFormatTag;
  107.  
  108.   kit_audioFormat format=0;
  109.   if(format_tag==WAVE_FORMAT_EXTENSIBLE){
  110.     _IF_ERROR(format_ext->Samples.wValidBitsPerSample>256,3,;);
  111.     format|=format_ext->Samples.wValidBitsPerSample-1;
  112.     _IF_ERROR(format_ex->cbSize!=(sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX)),4,;);
  113.  
  114.     GUID* subformat_tag=&format_ext->SubFormat;
  115.     if(IsEqualGUID(subformat_tag,&_SUBTYPE_IEEE_FLOAT)) format |= KIT_AUDIO_FMT_MFLOAT|KIT_AUDIO_FMT_MSIGNED;
  116.     else if(IsEqualGUID(subformat_tag,&_SUBTYPE_PCM)) format |= KIT_AUDIO_FMT_MSIGNED*(format>8);
  117.     else _IS_ERROR(5,;);
  118.   } else if(format_tag==WAVE_FORMAT_PCM){
  119.     _IF_ERROR(format_ex->wBitsPerSample>256,3,;);
  120.     format|=format_ex->wBitsPerSample-1;
  121.   } else _IS_ERROR(2,;);
  122.  
  123.   spec.format=format;
  124.   spec.frequency=format_ex->nSamplesPerSec;
  125.   spec.channels=format_ex->nChannels;
  126.  
  127.   spec.buffer_len=spec.buffer_size=0;
  128.   spec.callback=spec.userdata=0;
  129.   _error_:
  130.   if(returnStatus_p != NULL) *returnStatus_p=returnStatus;
  131.   return spec;
  132. }
  133.  
  134.  
  135. WAVEFORMATEXTENSIBLE _kit_audioSpecToWaveFormat(kit_audioSpec* spec, int* returnStatus_p){ /*0 -> 5*/
  136.   int returnStatus=0; WAVEFORMATEXTENSIBLE format={0}, null={0};
  137.   _IF_ERROR(spec==NULL,1,;);
  138.  
  139.   //get kit_audioFormat data
  140.   int bitsPerSample=(spec->format&KIT_AUDIO_FMT_MBITSIZE)+1;
  141.   int isFloat      =(spec->format&KIT_AUDIO_FMT_MFLOAT  )!=0;
  142.   int isBigEndian  =(spec->format&KIT_AUDIO_FMT_MENDIAN )!=0;
  143.   int isSigned     =(spec->format&KIT_AUDIO_FMT_MSIGNED )!=0;
  144.   _IF_ERROR(isBigEndian                 ,2,;);
  145.   _IF_ERROR(isFloat&&(!isSigned)        ,3,;);
  146.   _IF_ERROR(bitsPerSample<=8 && isSigned,4,;);
  147.  
  148.   //fill in WAVEFORMATEX info
  149.   format.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
  150.   format.Format.nChannels=spec->channels;
  151.   format.Format.nSamplesPerSec=spec->frequency;
  152.   format.Format.wBitsPerSample=(bitsPerSample>=8) ? ((bitsPerSample/8)*8) : 8;
  153.   format.Format.nBlockAlign=spec->channels*(format.Format.wBitsPerSample/8);
  154.   format.Format.nAvgBytesPerSec=spec->frequency*format.Format.nBlockAlign;
  155.   format.Format.cbSize=sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX);
  156.  
  157.   //fill in WAVEFORMATEXTENSIBLE info
  158.   format.Samples.wValidBitsPerSample=bitsPerSample;
  159.    //set guid
  160.   if(isFloat) memcpy(&format.SubFormat,&_SUBTYPE_IEEE_FLOAT,sizeof(GUID));
  161.   else        memcpy(&format.SubFormat,&_SUBTYPE_PCM       ,sizeof(GUID));
  162.    //set channel masks based on channel mapping
  163.   switch(spec->channels){
  164.   case 1: format.dwChannelMask=_KIT_AUDIO_MMONO;   break;
  165.   case 2: format.dwChannelMask=_KIT_AUDIO_MSTEREO; break;
  166.   case 3: format.dwChannelMask=_KIT_AUDIO_M2_1S;   break;
  167.   case 4: format.dwChannelMask=_KIT_AUDIO_MQUAD;   break;
  168.   case 5: format.dwChannelMask=_KIT_AUDIO_M4_1S;   break;
  169.   case 6: format.dwChannelMask=_KIT_AUDIO_M5_1S;   break;
  170.   case 7: format.dwChannelMask=_KIT_AUDIO_M6_1S;   break;
  171.   case 8: format.dwChannelMask=_KIT_AUDIO_M7_1S;   break;
  172.   default: _IS_ERROR(5,;); }
  173.  
  174.   _error_:
  175.   if(returnStatus_p != NULL) *returnStatus_p=returnStatus;
  176.   if(!returnStatus) return format;
  177.   else              return null;
  178. }
  179.  
  180.  
  181. int _kit_audioQueryDevice(unsigned int index, int isCapture){ /*0 -> 4*/ //assumes globals are already locked
  182.   int returnStatus=0; ULONG numRefs=1; UINT numDevices;
  183.  
  184.   //choose between capture and render
  185.   _kit_audioGlobalsDevInfo* info;
  186.   if(isCapture&1) info=&_kit_audioGlobals.i;
  187.   else            info=&_kit_audioGlobals.o;
  188.  
  189.   //is given id greater than maximum valid index?
  190.   _kit_audioCOM_IMMDeviceCollection_GetCount(info->devices, &numDevices);
  191.   _IF_ERROR((index>=numDevices) && (index!=0xffffffff),1,;);
  192.  
  193.   //retrieve IMMDevice & IAudioClient, only if given index is different to the last one retrieved
  194.   if(index!=info->device_index || info->device==NULL){
  195.     //retrieve IMMDevice
  196.      //clean up previous references
  197.     _KIT_AUDIO_RELEASE(_kit_audioCOM_IMMDevice_Release,info->device);
  198.     if(index != 0xffffffff){ // index!=-1
  199.       _kit_audioCOM_IMMDeviceCollection_Item(info->devices, (UINT)index, &info->device);
  200.     } else {
  201.       _kit_audioCOM_IMMDeviceEnumerator_GetDefaultAudioEndpoint(_kit_audioGlobals.enumerator,
  202.         info->data_flow, eConsole, &info->device);
  203.     }
  204.     info->device_index=index;
  205.  
  206.     //retrieve IAudioClient
  207.      //clean up previous references
  208.     _KIT_AUDIO_RELEASE(_kit_audioCOM_IAudioClient_Release,info->client);
  209.     printf("!A!last Win32 error=%lu\n",GetLastError());
  210.     switch(_kit_audioCOM_IMMDevice_Activate(info->device,
  211.       &IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&info->client)
  212.     ){
  213.     case AUDCLNT_E_DEVICE_INVALIDATED: _IS_ERROR(2,;);
  214.     case E_NOINTERFACE:                _IS_ERROR(3,;);
  215.     case E_OUTOFMEMORY:                _IS_ERROR(4,;);
  216.     case S_OK:;
  217.     }
  218.     printf("!B!last Win32 error=%lu\n",GetLastError());
  219.   }
  220.  
  221.   _error_: return returnStatus;
  222. }
  223.  
  224.  
  225. int _kit_audioQueryDeviceProps(unsigned int index, int isCapture){ /*0 -> 14*/ //assumes globals are already locked
  226.   int returnStatus=0, property_init=0; ULONG numRefs=1;
  227.  
  228.   //choose between capture and render
  229.   _kit_audioGlobalsDevInfo* info;
  230.   if(isCapture&=1) info=&_kit_audioGlobals.i;
  231.   else             info=&_kit_audioGlobals.o;
  232.  
  233.   int equal_to_last_index = index==info->device_index;
  234.   returnStatus=_kit_audioQueryDevice(index,isCapture);
  235.   if(returnStatus) goto _error_; //errors 1 -> 4
  236.  
  237.   //retrieve property store unless current one is identical
  238.   if(!equal_to_last_index || info->props==NULL){
  239.     //clean up previous references
  240.     _KIT_AUDIO_RELEASE(_kit_audioCOM_IPropertyStore_Release,info->props);
  241.     _IF_ERROR(_kit_audioCOM_IMMDevice_OpenPropertyStore(info->device,
  242.       STGM_READ, &info->props) == E_OUTOFMEMORY,
  243.     5,;);
  244.   }
  245.  
  246.   //get WAVEFORMATEX(TENSIBLE) from device's property store
  247.   PROPVARIANT property;
  248.   _kit_audioCOM_IPropertyStore_GetValue(info->props, &PKEY_AudioEngine_DeviceFormat, &property);
  249.   if(property.blob.pBlobData==NULL){
  250.     PropVariantClear(&property);
  251.     //try oem format instead
  252.     _kit_audioCOM_IPropertyStore_GetValue(info->props, &PKEY_AudioEngine_OEMFormat, &property);
  253.     _IF_ERROR(property.blob.pBlobData==NULL,6,;);
  254.   }
  255.   WORD format_tag=((WAVEFORMATEX*)property.blob.pBlobData)->wFormatTag; /* --> */ property_init=1;
  256.  
  257.   if(format_tag == WAVE_FORMAT_EXTENSIBLE){
  258.     GUID* subformat_tag=&((WAVEFORMATEXTENSIBLE*)property.blob.pBlobData)->SubFormat;
  259.  
  260.     if(IsEqualGUID(subformat_tag,&_SUBTYPE_IEEE_FLOAT)) info->data_type=2;
  261.     else if(IsEqualGUID(subformat_tag,&_SUBTYPE_PCM)) info->data_type=3;
  262.     else { return returnStatus=8; goto _error_; }
  263.  
  264.     info->device_format_ext=*(WAVEFORMATEXTENSIBLE*)property.blob.pBlobData;
  265.   } else if(format_tag == WAVE_FORMAT_PCM){ /* --> */ info->data_type=1;
  266.     info->device_format=*(WAVEFORMATEX*)property.blob.pBlobData;
  267.   }
  268.   else{ returnStatus=7; goto _error_; }
  269.   if(property_init) PropVariantClear(&property);
  270.   property_init=0;
  271.  
  272.   //get whether device supports event-driven mode
  273.   _kit_audioCOM_IPropertyStore_GetValue(info->props, &PKEY_AudioEndpoint_Supports_EventDriven_Mode, &property);
  274.   info->event_driven_support=property.uintVal;
  275.   PropVariantClear(&property);
  276.  
  277.   //get name of device
  278.   _kit_audioCOM_IPropertyStore_GetValue(info->props, &PKEY_Device_FriendlyName, &property);
  279.   _IF_ERROR(property.pwszVal==NULL,9,;); /* --> */ property_init=1;
  280.   info->device_name_len=wcslen(property.pwszVal);
  281.   info->device_name=_kit_audioRealloc(info->device_name,wchar_t,info->device_name_len+1);
  282.   _IF_ERROR(info->device_name==NULL,10,;);
  283.   wcscpy(info->device_name,property.pwszVal);
  284.   PropVariantClear(&property); /* --> */ property_init=0;
  285.  
  286.   //get description of device
  287.   _kit_audioCOM_IPropertyStore_GetValue(info->props, &PKEY_Device_DeviceDesc, &property);
  288.   _IF_ERROR(property.pwszVal==NULL,11,;); /* --> */ property_init=1;
  289.   info->device_desc_len=wcslen(property.pwszVal);
  290.   info->device_desc=_kit_audioRealloc(info->device_desc,wchar_t,info->device_desc_len+1);
  291.   _IF_ERROR(info->device_desc==NULL,12,;);
  292.   wcscpy(info->device_desc,property.pwszVal);
  293.   PropVariantClear(&property); /* --> */ property_init=0;
  294.  
  295.   //get interface name of device
  296.   _kit_audioCOM_IPropertyStore_GetValue(info->props, &PKEY_DeviceInterface_FriendlyName, &property);
  297.   _IF_ERROR(property.pwszVal==NULL,13,;); /* --> */ property_init=1;
  298.   info->device_iname_len=wcslen(property.pwszVal);
  299.   info->device_iname=_kit_audioRealloc(info->device_iname,wchar_t,info->device_iname_len+1);
  300.   _IF_ERROR(info->device_iname==NULL,14,;);
  301.   wcscpy(info->device_iname,property.pwszVal);
  302.   PropVariantClear(&property); /* --> */ property_init=0;
  303.  
  304.   _error_:
  305.   if(property_init) PropVariantClear(&property);
  306.   return returnStatus;
  307. }
  308.  
  309.  
  310. int kit_audioQueryDevices(int isCapture, kit_audioDeviceStatus status){ /*0 -> 2*/
  311.   int returnStatus=0; ULONG numRefs=1;
  312.   _LOCK_GLOBALS_AUDIO;
  313.   _IF_ERROR(!(status&ADStatusAll),1,;); //error if status is not a valid enum value
  314.  
  315.   //choose between capture and render
  316.   _kit_audioGlobalsDevInfo* info;
  317.   if(isCapture&1) info=&_kit_audioGlobals.i;
  318.   else            info=&_kit_audioGlobals.o;
  319.  
  320.   //clean up previous references
  321.   _KIT_AUDIO_RELEASE(_kit_audioCOM_IMMDeviceCollection_Release,info->devices);
  322.  
  323.   if(_kit_audioCOM_IMMDeviceEnumerator_EnumAudioEndpoints(_kit_audioGlobals.enumerator,
  324.     info->data_flow, (DWORD)status, &info->devices) == E_OUTOFMEMORY
  325.   ) returnStatus=2;
  326.  
  327.   _error_:
  328.   _UNLOCK_GLOBALS_AUDIO;
  329.   return returnStatus;
  330. }
  331.  
  332.  
  333. unsigned int kit_audioGetNumDevices(int isCapture){
  334.   UINT numDevices;
  335.   _LOCK_GLOBALS_AUDIO;
  336.   IMMDeviceCollection* devices;
  337.   if(isCapture&1) devices=_kit_audioGlobals.i.devices;
  338.   else            devices=_kit_audioGlobals.o.devices;
  339.   _kit_audioCOM_IMMDeviceCollection_GetCount(devices,&numDevices);
  340.   _UNLOCK_GLOBALS_AUDIO;
  341.   return (unsigned int)numDevices;
  342. }
  343.  
  344.  
  345. wchar_t* kit_audioGetDeviceName(unsigned int index, int isCapture,
  346.                                 int mode, int* returnStatus_p){ /*0 -> 14*/
  347.   int returnStatus=0; wchar_t* deviceName=NULL;
  348.   _LOCK_GLOBALS_AUDIO;
  349.  
  350.   //choose between capture and render
  351.   _kit_audioGlobalsDevInfo* info;
  352.   if(isCapture&=1) info=&_kit_audioGlobals.i;
  353.   else             info=&_kit_audioGlobals.o;
  354.  
  355.   returnStatus=_kit_audioQueryDeviceProps(index,isCapture);
  356.   if(returnStatus) goto _error_; //errors 1 -> 14
  357.  
  358.   switch(mode%3){
  359.   case 0: deviceName=info->device_name;  break;
  360.   case 1: deviceName=info->device_desc;  break;
  361.   case 2: deviceName=info->device_iname; }
  362.  
  363.   _error_:
  364.   _UNLOCK_GLOBALS_AUDIO;
  365.   if(returnStatus_p != NULL) *returnStatus_p=returnStatus;
  366.   return deviceName;
  367. }
  368.  
  369.  
  370. wchar_t* kit_audioGetDeviceID(unsigned int index, int isCapture, int* returnStatus_p){ /*0 -> 5*/
  371.   int returnStatus=0; wchar_t* deviceID=NULL;
  372.   _LOCK_GLOBALS_AUDIO;
  373.  
  374.   //choose between capture and render
  375.   _kit_audioGlobalsDevInfo* info;
  376.   if(isCapture&=1) info=&_kit_audioGlobals.i;
  377.   else             info=&_kit_audioGlobals.o;
  378.  
  379.   int equal_to_last_index = index==info->device_index;
  380.   returnStatus=_kit_audioQueryDevice(index,isCapture);
  381.   if(returnStatus) goto _error_; //errors 1 -> 4
  382.  
  383.   //return already cached id if id is the same as the last
  384.   _IF_ERROR(equal_to_last_index,0, deviceID=info->device_id);
  385.   if(_kit_audioCOM_IMMDevice_GetId(info->device,(LPWSTR*)&deviceID) != E_OUTOFMEMORY){
  386.     _KIT_AUDIO_FREE(_kit_audioFree,info->device_id);
  387.     info->device_id=deviceID;
  388.   } else returnStatus=5;
  389.  
  390.   _error_:
  391.   _UNLOCK_GLOBALS_AUDIO;
  392.   if(returnStatus_p != NULL) *returnStatus_p=returnStatus;
  393.   return deviceID;
  394. }
  395.  
  396.  
  397. kit_audioDeviceStatus kit_audioGetDeviceStatus(unsigned int index, int isCapture, int* returnStatus_p){ /*0 -> 4*/
  398.   int returnStatus=0; kit_audioDeviceStatus deviceStatus;
  399.   _LOCK_GLOBALS_AUDIO;
  400.  
  401.   //choose between capture and render
  402.   IMMDevice* device;
  403.   if(isCapture) device=_kit_audioGlobals.i.device;
  404.   else          device=_kit_audioGlobals.o.device;
  405.  
  406.   returnStatus=_kit_audioQueryDevice(index,isCapture&=1);
  407.   if(returnStatus) goto _error_; //errors 1 -> 4
  408.  
  409.   _kit_audioCOM_IMMDevice_GetState(device, (DWORD*)&deviceStatus);
  410.  
  411.   _error_:
  412.   _UNLOCK_GLOBALS_AUDIO;
  413.   if(returnStatus){
  414.     deviceStatus=ADStatusInvalid;
  415.     if(returnStatus_p != NULL) *returnStatus_p=returnStatus;
  416.   }
  417.   return deviceStatus;
  418. }
  419.  
  420.  
  421. int kit_audioGetDeviceSpec(unsigned int index, int isCapture, kit_audioSpec* spec){ /*0 -> 20*/
  422.   int returnStatus=0; //ULONG numRefs=1; //HRESULT hr;
  423.   _LOCK_GLOBALS_AUDIO;
  424.   _IF_ERROR(spec==NULL,1,;);
  425.  
  426.   //choose between capture and render
  427.   WAVEFORMATEX* device_format;
  428.   if(isCapture&=1) device_format=&_kit_audioGlobals.i.device_format;
  429.   else             device_format=&_kit_audioGlobals.o.device_format;
  430.  
  431.   //retrieve relevant property store info
  432.   returnStatus=_kit_audioQueryDeviceProps(index,isCapture); //calls _kit_audioQueryDevice
  433.   if(returnStatus){ ++returnStatus; goto _error_; } //errors 2 -> 15
  434.  
  435.   //convert format info to kit_audioSpec
  436.   kit_audioSpec _spec=_kit_audioWaveFormatToSpec(device_format, &returnStatus);
  437.   if(returnStatus){ returnStatus+=15; goto _error_; } //errors 16 -> 20
  438.   *spec=_spec;
  439.  
  440.   _error_:
  441.   _UNLOCK_GLOBALS_AUDIO;
  442.   return returnStatus;
  443. }
  444.  
  445.  
  446. int kit_audioIsSpecSupported(unsigned int index, int isCapture, /*int exclusive,*/ /*-1 -> 17*/
  447.                              kit_audioSpec* spec, kit_audioSpec* closestMatch){
  448.   int returnStatus=0;
  449.   //AUDCLNT_SHAREMODE shareMode=(exclusive&1) ? AUDCLNT_SHAREMODE_EXCLUSIVE : AUDCLNT_SHAREMODE_SHARED;
  450.   AUDCLNT_SHAREMODE shareMode=AUDCLNT_SHAREMODE_SHARED;
  451.   WAVEFORMATEX* _closestMatch_WFE=NULL;
  452.   _LOCK_GLOBALS_AUDIO;
  453.   _IF_ERROR(spec==NULL,1,;);
  454.  
  455.   //choose between capture and render
  456.   IAudioClient* client;
  457.   if(isCapture&=1) client=_kit_audioGlobals.i.client;
  458.   else             client=_kit_audioGlobals.o.client;
  459.  
  460.   //retrieve device (as well as the associated audio client)
  461.   returnStatus=_kit_audioQueryDevice(index,isCapture);
  462.   if(returnStatus){ ++returnStatus; goto _error_; } //errors 2 -> 5
  463.  
  464.   //convert specification to wave format struct
  465.   WAVEFORMATEXTENSIBLE format=_kit_audioSpecToWaveFormat(spec,&returnStatus);
  466.   if(returnStatus){ returnStatus+=5; goto _error_; } //errors 6 -> 10
  467.  
  468.   switch(_kit_audioCOM_IAudioClient_IsFormatSupported(client,
  469.     shareMode, (WAVEFORMATEX*)&format, &_closestMatch_WFE)
  470.   ){
  471.   //case AUDCLNT_E_UNSUPPORTED_FORMAT: (only applicable in exclusive sharemode)
  472.   //i don't get how this would realistically happen in practice
  473.    //(like, the fundamental audio service isn't running at all?)
  474.   case AUDCLNT_E_SERVICE_NOT_RUNNING: _IS_ERROR(11,;);
  475.   case AUDCLNT_E_DEVICE_INVALIDATED:  _IS_ERROR(12,;);
  476.   case S_FALSE: returnStatus=-1;
  477.   case S_OK:;
  478.   }
  479.  
  480.   _error_:
  481.   _UNLOCK_GLOBALS_AUDIO;
  482.   if(_closestMatch_WFE != NULL){
  483.     kit_audioSpec _closestMatch=_kit_audioWaveFormatToSpec(_closestMatch_WFE,&returnStatus);
  484.     if(returnStatus){ returnStatus+=12; goto free_wfe_; } //errors 13 -> 17
  485.     *closestMatch=_closestMatch;
  486.   }
  487.   free_wfe_:
  488.   _KIT_AUDIO_FREE(_kit_audioFree,_closestMatch_WFE);
  489.   return returnStatus;
  490. }
  491.  
  492.  
  493. //this is more of a utility function, as everything used here is public anyway
  494. unsigned int kit_audioGetDeviceIndexFromID(wchar_t* deviceID, int isCapture, int* returnStatus_p){ /*-1 -> 9*/
  495.   int returnStatus=0, locked=0; unsigned int index=0xfffffffe; wchar_t *_deviceID=NULL, *deviceID2;
  496.   _IF_ERROR(deviceID==NULL,1,;);
  497.  
  498.   //copy id to a temporary location, to make sure globals aren't tripped over
  499.   _LOCK_GLOBALS_AUDIO; locked=1;
  500.   int IDLen=wcslen(deviceID);
  501.   _IF_ERROR(!IDLen,2,;);
  502.   _deviceID=_kit_audioMalloc(wchar_t,IDLen);
  503.   _IF_ERROR(_deviceID==NULL,3,;);
  504.   wcscpy(_deviceID,deviceID);
  505.   _UNLOCK_GLOBALS_AUDIO; locked=0;
  506.  
  507.   //do a linear search of ids
  508.   unsigned int numDevices=kit_audioGetNumDevices(isCapture&=1);
  509.   _IF_ERROR(!numDevices,4,;);
  510.   for(unsigned int i=-1; (i==-1)||(i<numDevices); ++i){
  511.     deviceID2=kit_audioGetDeviceID(i,isCapture,&returnStatus);
  512.     if(returnStatus){ returnStatus+=4; goto _error_; } //errors 5 -> 9
  513.     _LOCK_GLOBALS_AUDIO; locked=1;
  514.     if(wcscmp(_deviceID,deviceID2)){ index=i; break; }
  515.     _UNLOCK_GLOBALS_AUDIO; locked=0;
  516.   }
  517.   if(index == 0xfffffffe) returnStatus=-1; //index == -2
  518.  
  519.   _error_:
  520.   if(locked) _UNLOCK_GLOBALS_AUDIO;
  521.   _KIT_AUDIO_FREE(_kit_audioFree,_deviceID);
  522.   if(returnStatus_p != NULL) *returnStatus_p=returnStatus;
  523.   return index;
  524. }
  525.  
  526.  
  527.  
  528. /* kit_audioDevice-RELATED FUNCTIONS */
  529.  
  530. int kit_audioDevicePlay(kit_audioDevice* device, kit_audioDevicePState playState){
  531.   int returnStatus=0;
  532.   //_error_:
  533.   return returnStatus;
  534. }
  535.  
  536.  
  537. kit_audioDevicePState kit_audioGetDevicePlayState(kit_audioDevice* device){
  538.   kit_audioDevicePState returnStatus=ADPStateInvalid;
  539.   //_error_:
  540.   return returnStatus;
  541. }
  542.  
  543.  
  544.  
  545. /* (UN)INIT FUNCTIONS */
  546.  
  547. int kit_audioInit(int initCOM){
  548.   int returnStatus=0, critical_section_init=0;
  549.   //might cause race conditions, but i don't know how to structure this better
  550.   _IF_ERROR(_kit_audioGlobals.init,1,;);
  551.   InitializeCriticalSection(&_kit_audioGlobals.lock);
  552.   critical_section_init=1;
  553.   _LOCK_GLOBALS_AUDIO;
  554.   memset(((void*)&_kit_audioGlobals)+sizeof(CRITICAL_SECTION),0,
  555.          sizeof(_kit_audioGlobals)-sizeof(CRITICAL_SECTION));
  556.  
  557.   //set i and o's data_flow to eCapture and eRender respectively
  558.   _kit_audioGlobals.i.data_flow=eCapture;
  559.   _kit_audioGlobals.o.data_flow=eRender;
  560.  
  561.   //initialize com
  562.   if(initCOM&1) CoInitializeEx(NULL,COINIT_MULTITHREADED);
  563.  
  564.   //create enumerator object
  565.   HRESULT hr=CoCreateInstance(
  566.     &CLSID_MMDeviceEnumerator,
  567.     NULL, CLSCTX_ALL,
  568.     &IID_IMMDeviceEnumerator,
  569.     (void**)&_kit_audioGlobals.enumerator
  570.   ); _IF_ERROR(FAILED(hr),2,;);
  571.  
  572.   //get input device collection
  573.   hr=_kit_audioCOM_IMMDeviceEnumerator_EnumAudioEndpoints(_kit_audioGlobals.enumerator,
  574.     eCapture, DEVICE_STATEMASK_ALL, &_kit_audioGlobals.i.devices
  575.   ); _IF_ERROR(FAILED(hr),3,;);
  576.  
  577.   //get output device collection
  578.   hr=_kit_audioCOM_IMMDeviceEnumerator_EnumAudioEndpoints(_kit_audioGlobals.enumerator,
  579.     eRender, DEVICE_STATEMASK_ALL, &_kit_audioGlobals.o.devices
  580.   ); _IF_ERROR(FAILED(hr),4,;);
  581.  
  582.   _kit_audioGlobals.init=1;
  583.   _error_:
  584.   if(critical_section_init) _UNLOCK_GLOBALS_AUDIO;
  585.   return returnStatus;
  586. }
  587.  
  588.  
  589. int kit_audioQuit(int uninitCOM){
  590.   int returnStatus=0; ULONG numRefs=1;
  591.   _IF_ERROR(!_kit_audioGlobals.init,1,;);
  592.   _LOCK_GLOBALS_AUDIO;
  593.  
  594.   //free last i/o device names (wchar_t*)
  595.   _KIT_AUDIO_FREE(_kit_audioFree,_kit_audioGlobals.i.device_name);
  596.   _KIT_AUDIO_FREE(_kit_audioFree,_kit_audioGlobals.i.device_desc);
  597.   _KIT_AUDIO_FREE(_kit_audioFree,_kit_audioGlobals.i.device_iname);
  598.   _KIT_AUDIO_FREE(_kit_audioFree,_kit_audioGlobals.o.device_name);
  599.   _KIT_AUDIO_FREE(_kit_audioFree,_kit_audioGlobals.o.device_desc);
  600.   _KIT_AUDIO_FREE(_kit_audioFree,_kit_audioGlobals.o.device_iname);
  601.  
  602.   //free last i/o device ids (wchar_t*)
  603.   _KIT_AUDIO_FREE(_kit_audioFree,_kit_audioGlobals.i.device_id);
  604.   _KIT_AUDIO_FREE(_kit_audioFree,_kit_audioGlobals.o.device_id);
  605.  
  606.   //release last i/o device audio clients
  607.   _KIT_AUDIO_RELEASE(_kit_audioCOM_IAudioClient_Release,_kit_audioGlobals.i.client);
  608.   _KIT_AUDIO_RELEASE(_kit_audioCOM_IAudioClient_Release,_kit_audioGlobals.o.client);
  609.  
  610.   //release last i/o device property stores
  611.   _KIT_AUDIO_RELEASE(_kit_audioCOM_IPropertyStore_Release,_kit_audioGlobals.i.props);
  612.   _KIT_AUDIO_RELEASE(_kit_audioCOM_IPropertyStore_Release,_kit_audioGlobals.o.props);
  613.  
  614.   //release last i/o devices
  615.   _KIT_AUDIO_RELEASE(_kit_audioCOM_IMMDevice_Release,_kit_audioGlobals.i.device);
  616.   _KIT_AUDIO_RELEASE(_kit_audioCOM_IMMDevice_Release,_kit_audioGlobals.o.device);
  617.  
  618.   //release i/o device collections
  619.   _KIT_AUDIO_RELEASE(_kit_audioCOM_IMMDeviceCollection_Release,_kit_audioGlobals.i.devices);
  620.   _KIT_AUDIO_RELEASE(_kit_audioCOM_IMMDeviceCollection_Release,_kit_audioGlobals.o.devices);
  621.  
  622.   //release enumerator
  623.   _KIT_AUDIO_RELEASE(_kit_audioCOM_IMMDeviceEnumerator_Release,_kit_audioGlobals.enumerator);
  624.  
  625.   //todo: find out why CoUninitialize() makes GetLastError()=126 (ERROR_MOD_NOT_FOUND)
  626.   if(uninitCOM&1) CoUninitialize();
  627.   _kit_audioGlobals.init=0;
  628.   _error_:
  629.   _UNLOCK_GLOBALS_AUDIO;
  630.   if(!returnStatus) DeleteCriticalSection(&_kit_audioGlobals.lock);
  631.   return returnStatus;
  632. }
  633.  
  634.  
  635. kit_audioDevice* kit_audioDeviceOpen(kit_audioSpec* spec, unsigned int index,
  636.                                      int isCapture, int* returnStatus_p){
  637.   int returnStatus=0;
  638.   _IF_ERROR(spec==NULL,1,;);
  639.  
  640.   _error_:
  641.   if(returnStatus_p != NULL) *returnStatus_p=returnStatus;
  642.   return NULL;
  643. }
  644.  
  645.  
  646. int kit_audioDeviceClose(kit_audioDevice** device_p){
  647.   int returnStatus=0;
  648.   _IF_ERROR(device_p==NULL,1,;);
  649.  
  650.   _error_:
  651.   return returnStatus;
  652. }
  653.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!