first commit
This commit is contained in:
m.cirafisi committed
commit
4b1fc0835a
14 files changed
+1133
No files matched your search
@@ -0,0 +1,606 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
|
||||
namespace LoopbackCapture
|
||||
{
|
||||
class Program
|
||||
{
|
||||
const int SIO_UDP_CONNRESET = -1744830452;
|
||||
|
||||
static int selectedTargetPid = 0; // 0 = Tutto il sistema
|
||||
|
||||
static void Main(string[] args)
|
||||
{
|
||||
int port = 4242;
|
||||
int cmdPort = 4243;
|
||||
if (args.Length > 0)
|
||||
{
|
||||
int.TryParse(args[0], out port);
|
||||
cmdPort = port + 1;
|
||||
}
|
||||
|
||||
UdpClient udpSend = null;
|
||||
try
|
||||
{
|
||||
udpSend = new UdpClient();
|
||||
byte[] inValue = new byte[] { 0, 0, 0, 0 };
|
||||
byte[] outValue = new byte[] { 0, 0, 0, 0 };
|
||||
udpSend.Client.IOControl(SIO_UDP_CONNRESET, inValue, outValue);
|
||||
}
|
||||
catch { }
|
||||
|
||||
IPEndPoint remoteEp = new IPEndPoint(IPAddress.Loopback, port);
|
||||
|
||||
// Listener comandi di selezione processo inviati da Godot
|
||||
Thread cmdListenerThread = new Thread(() =>
|
||||
{
|
||||
UdpClient udpCmd = null;
|
||||
try
|
||||
{
|
||||
udpCmd = new UdpClient(cmdPort);
|
||||
IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
|
||||
while (true)
|
||||
{
|
||||
byte[] bytes = udpCmd.Receive(ref sender);
|
||||
string cmd = Encoding.UTF8.GetString(bytes).Trim();
|
||||
if (cmd.StartsWith("PID:"))
|
||||
{
|
||||
int pid;
|
||||
if (int.TryParse(cmd.Substring(4), out pid))
|
||||
{
|
||||
selectedTargetPid = pid;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
catch { }
|
||||
});
|
||||
cmdListenerThread.IsBackground = true;
|
||||
cmdListenerThread.Start();
|
||||
|
||||
IMMDeviceEnumerator enumerator = (IMMDeviceEnumerator)new MMDeviceEnumeratorComObject();
|
||||
IMMDevice device = null;
|
||||
int hr = enumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out device);
|
||||
if (hr != 0 || device == null)
|
||||
{
|
||||
hr = enumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eConsole, out device);
|
||||
if (hr != 0 || device == null) return;
|
||||
}
|
||||
|
||||
Guid iidMgr = typeof(IAudioSessionManager2).GUID;
|
||||
object oMgr;
|
||||
device.Activate(ref iidMgr, 1, IntPtr.Zero, out oMgr);
|
||||
IAudioSessionManager2 sessionManager = (IAudioSessionManager2)oMgr;
|
||||
|
||||
Guid iidAudioClient = typeof(IAudioClient).GUID;
|
||||
object oAudioClient;
|
||||
hr = device.Activate(ref iidAudioClient, 1, IntPtr.Zero, out oAudioClient);
|
||||
if (hr != 0 || oAudioClient == null) return;
|
||||
|
||||
IAudioClient audioClient = (IAudioClient)oAudioClient;
|
||||
IntPtr pMixFormat;
|
||||
hr = audioClient.GetMixFormat(out pMixFormat);
|
||||
if (hr != 0 || pMixFormat == IntPtr.Zero) return;
|
||||
|
||||
WAVEFORMATEX wf = (WAVEFORMATEX)Marshal.PtrToStructure(pMixFormat, typeof(WAVEFORMATEX));
|
||||
int channels = wf.nChannels;
|
||||
int bitsPerSample = wf.wBitsPerSample;
|
||||
int sampleRate = wf.nSamplesPerSec > 0 ? wf.nSamplesPerSec : 48000;
|
||||
bool isFloat = (wf.wFormatTag == 3);
|
||||
|
||||
if (wf.wFormatTag == -2)
|
||||
{
|
||||
WAVEFORMATEXTENSIBLE wfe = (WAVEFORMATEXTENSIBLE)Marshal.PtrToStructure(pMixFormat, typeof(WAVEFORMATEXTENSIBLE));
|
||||
if (wfe.SubFormat == new Guid("00000003-0000-0010-8000-00aa00389b71")) isFloat = true;
|
||||
}
|
||||
|
||||
if (bitsPerSample == 32 && !isFloat)
|
||||
{
|
||||
byte[] raw = new byte[40];
|
||||
Marshal.Copy(pMixFormat, raw, 0, 40);
|
||||
if (raw[24] == 3) isFloat = true;
|
||||
}
|
||||
|
||||
const int AUDCLNT_STREAMFLAGS_LOOPBACK = 0x00020000;
|
||||
const int AUDCLNT_SHAREMODE_SHARED = 0;
|
||||
Guid emptySession = Guid.Empty;
|
||||
|
||||
hr = audioClient.Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_LOOPBACK, 10000000, 0, pMixFormat, ref emptySession);
|
||||
if (hr != 0) return;
|
||||
|
||||
Guid iidCaptureClient = typeof(IAudioCaptureClient).GUID;
|
||||
object oCaptureClient;
|
||||
hr = audioClient.GetService(ref iidCaptureClient, out oCaptureClient);
|
||||
if (hr != 0 || oCaptureClient == null) return;
|
||||
|
||||
IAudioCaptureClient captureClient = (IAudioCaptureClient)oCaptureClient;
|
||||
audioClient.Start();
|
||||
|
||||
// Filtro Passa-Basso sui Sub-Bassi (cassa e basse frequenze: 120 Hz)
|
||||
float cutoffFreq = 120.0f;
|
||||
float alpha = (float)(2.0 * Math.PI * cutoffFreq / sampleRate);
|
||||
alpha = Math.Max(0.003f, Math.Min(0.08f, alpha));
|
||||
float lp1 = 0f;
|
||||
float lp2 = 0f;
|
||||
|
||||
float currentTotalRms = 0f;
|
||||
|
||||
// Buffer circolare onset flux temporizzato ai campioni audio reali (100 Hz = ogni 10ms esatti)
|
||||
int hopSize = sampleRate / 100;
|
||||
if (hopSize < 1) hopSize = 480;
|
||||
const int BUFFER_HOPS = 400; // 4.0 secondi di finestra temporale
|
||||
float[] onsetBuffer = new float[BUFFER_HOPS];
|
||||
int onsetHead = 0;
|
||||
int totalHopsRecorded = 0;
|
||||
|
||||
int hopFrameAccumulator = 0;
|
||||
double hopKickSumSq = 0;
|
||||
double hopTotalSumSq = 0;
|
||||
float prevHopKickRms = 0;
|
||||
float prevHopTotalRms = 0;
|
||||
|
||||
float detectedBpm = 0.0f;
|
||||
int candidateBpm = 0;
|
||||
int candidateStreak = 0;
|
||||
int bpmEvalCounter = 0;
|
||||
|
||||
long lastAppListBroadcast = 0;
|
||||
int myPid = Process.GetCurrentProcess().Id;
|
||||
|
||||
while (true)
|
||||
{
|
||||
// 1. Lettura campioni PCM WASAPI dal loopback di sistema
|
||||
uint packetLength = 0;
|
||||
hr = captureClient.GetNextPacketSize(out packetLength);
|
||||
|
||||
while (packetLength > 0 && hr == 0)
|
||||
{
|
||||
IntPtr pData;
|
||||
uint numFramesRead;
|
||||
int flags;
|
||||
ulong devPos, qpcPos;
|
||||
|
||||
hr = captureClient.GetBuffer(out pData, out numFramesRead, out flags, out devPos, out qpcPos);
|
||||
if (hr != 0) break;
|
||||
|
||||
if ((flags & 1) == 0 && numFramesRead > 0)
|
||||
{
|
||||
double totalSumSq = 0;
|
||||
double kickSumSq = 0;
|
||||
int frames = (int)numFramesRead;
|
||||
|
||||
unsafe
|
||||
{
|
||||
byte* ptr = (byte*)pData.ToPointer();
|
||||
for (int f = 0; f < frames; f++)
|
||||
{
|
||||
float monoSample = 0f;
|
||||
if (isFloat && bitsPerSample == 32)
|
||||
{
|
||||
float* fptr = (float*)ptr + (f * channels);
|
||||
for (int c = 0; c < channels; c++) monoSample += fptr[c];
|
||||
monoSample /= channels;
|
||||
}
|
||||
else if (!isFloat && bitsPerSample == 32)
|
||||
{
|
||||
int* iptr = (int*)ptr + (f * channels);
|
||||
for (int c = 0; c < channels; c++) monoSample += (iptr[c] / 2147483648.0f);
|
||||
monoSample /= channels;
|
||||
}
|
||||
else if (bitsPerSample == 16)
|
||||
{
|
||||
short* sptr = (short*)ptr + (f * channels);
|
||||
for (int c = 0; c < channels; c++) monoSample += (sptr[c] / 32768.0f);
|
||||
monoSample /= channels;
|
||||
}
|
||||
|
||||
totalSumSq += (monoSample * monoSample);
|
||||
|
||||
// Filtro IIR passa-basso a doppio polo per estrarre la cassa
|
||||
lp1 += alpha * (monoSample - lp1);
|
||||
lp2 += alpha * (lp1 - lp2);
|
||||
kickSumSq += (lp2 * lp2);
|
||||
|
||||
hopTotalSumSq += (monoSample * monoSample);
|
||||
hopKickSumSq += (lp2 * lp2);
|
||||
hopFrameAccumulator++;
|
||||
|
||||
// Ogni 10ms esatti di campioni audio registrati dal clock DAC
|
||||
if (hopFrameAccumulator >= hopSize)
|
||||
{
|
||||
float hopKickRms = (float)Math.Sqrt(hopKickSumSq / hopSize);
|
||||
float hopTotalRms = (float)Math.Sqrt(hopTotalSumSq / hopSize);
|
||||
|
||||
float kickFlux = Math.Max(0f, hopKickRms - prevHopKickRms);
|
||||
float totalFlux = Math.Max(0f, hopTotalRms - prevHopTotalRms);
|
||||
prevHopKickRms = hopKickRms;
|
||||
prevHopTotalRms = hopTotalRms;
|
||||
|
||||
// L'onset combina la spinta del sub-basso (3.5x) e l'impatto a banda intera
|
||||
float onset = (kickFlux * 3.5f) + totalFlux;
|
||||
onsetBuffer[onsetHead] = onset;
|
||||
onsetHead = (onsetHead + 1) % BUFFER_HOPS;
|
||||
if (totalHopsRecorded < BUFFER_HOPS) totalHopsRecorded++;
|
||||
|
||||
hopFrameAccumulator = 0;
|
||||
hopKickSumSq = 0;
|
||||
hopTotalSumSq = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (frames > 0)
|
||||
{
|
||||
float packetTotalRms = (float)Math.Sqrt(totalSumSq / frames);
|
||||
currentTotalRms = (currentTotalRms * 0.25f) + (packetTotalRms * 0.75f);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
currentTotalRms *= 0.7f;
|
||||
}
|
||||
|
||||
captureClient.ReleaseBuffer(numFramesRead);
|
||||
hr = captureClient.GetNextPacketSize(out packetLength);
|
||||
}
|
||||
|
||||
// 2. Volume mirato se selezionata una specifica applicazione (es. Spotify/Chrome)
|
||||
float displayRms = currentTotalRms;
|
||||
if (selectedTargetPid > 0 && sessionManager != null)
|
||||
{
|
||||
try
|
||||
{
|
||||
IAudioSessionEnumerator sessionEnum;
|
||||
sessionManager.GetSessionEnumerator(out sessionEnum);
|
||||
int count;
|
||||
sessionEnum.GetCount(out count);
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
object oSession;
|
||||
sessionEnum.GetSession(i, out oSession);
|
||||
var session2 = (IAudioSessionControl2)oSession;
|
||||
uint pid;
|
||||
session2.GetProcessId(out pid);
|
||||
if (pid == selectedTargetPid)
|
||||
{
|
||||
var meter = (IAudioMeterInformation)oSession;
|
||||
float peak = 0;
|
||||
meter.GetPeakValue(out peak);
|
||||
displayRms = peak;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch { }
|
||||
}
|
||||
|
||||
// 3. Autocorrelazione & Comb-Filter su spettro ritmico per rilevamento esatto del BPM
|
||||
bpmEvalCounter++;
|
||||
if (bpmEvalCounter >= 10) // Ogni ~80-100ms
|
||||
{
|
||||
bpmEvalCounter = 0;
|
||||
if (totalHopsRecorded >= 120) // Almeno 1.2 secondi di audio
|
||||
{
|
||||
// Srotola il buffer circolare e trova il valore massimo per normalizzare
|
||||
float[] env = new float[totalHopsRecorded];
|
||||
float maxOnset = 0.0000001f;
|
||||
for (int i = 0; i < totalHopsRecorded; i++)
|
||||
{
|
||||
int idx = (onsetHead - totalHopsRecorded + i + BUFFER_HOPS) % BUFFER_HOPS;
|
||||
float val = onsetBuffer[idx];
|
||||
env[i] = val;
|
||||
if (val > maxOnset) maxOnset = val;
|
||||
}
|
||||
|
||||
// Se c'è un segnale ritmico (anche con volume Windows molto basso)
|
||||
if (maxOnset > 0.00002f)
|
||||
{
|
||||
// Normalizzazione: rende l'autocorrelazione totalmente indipendente dal volume di Windows!
|
||||
for (int i = 0; i < totalHopsRecorded; i++)
|
||||
{
|
||||
env[i] /= maxOnset;
|
||||
}
|
||||
|
||||
double[] scores = new double[225];
|
||||
double[] weights = new double[] { 1.0, 0.5, 0.25, 0.125 };
|
||||
|
||||
// Valuta tutti i possibili BPM da 70 a 215
|
||||
for (int bpm = 70; bpm <= 215; bpm++)
|
||||
{
|
||||
double lag = (60.0 / bpm) * 100.0; // 100.0 Hz
|
||||
double score = 0;
|
||||
for (int h = 1; h <= 4; h++)
|
||||
{
|
||||
int l = (int)Math.Round(h * lag);
|
||||
if (l >= totalHopsRecorded) break;
|
||||
double weight = weights[h - 1];
|
||||
double dot = 0;
|
||||
int count = 0;
|
||||
for (int i = l; i < totalHopsRecorded; i++)
|
||||
{
|
||||
dot += env[i] * env[i - l];
|
||||
count++;
|
||||
}
|
||||
if (count > 0) score += weight * (dot / count);
|
||||
}
|
||||
scores[bpm] = score;
|
||||
}
|
||||
|
||||
// Bias di stabilità: leggero bonus al tempo attivo per assorbire micro-fill di 0.2s
|
||||
if (detectedBpm > 50.0f)
|
||||
{
|
||||
for (int bpm = 70; bpm <= 215; bpm++)
|
||||
{
|
||||
float diff = Math.Abs(bpm - detectedBpm);
|
||||
if (diff <= 6.0f)
|
||||
{
|
||||
scores[bpm] *= (1.0 + 0.20 * (1.0 - diff / 6.0));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int bestCandidateBpm = 70;
|
||||
double bestCandidateScore = 0;
|
||||
for (int bpm = 70; bpm <= 215; bpm++)
|
||||
{
|
||||
if (scores[bpm] > bestCandidateScore)
|
||||
{
|
||||
bestCandidateScore = scores[bpm];
|
||||
bestCandidateBpm = bpm;
|
||||
}
|
||||
}
|
||||
|
||||
// Risoluzione ottave: distingue brani lenti (90 BPM) da brani veloci (180-190 BPM).
|
||||
// Raddoppia solo se C'È EFFETTIVA energia percussiva al tempo veloce (rFast/rSlow >= 0.55),
|
||||
// evitando che i leggeri charleston a 1/8 di un pezzo a 90 BPM forzino il raddoppio a 180!
|
||||
if (bestCandidateBpm <= 105 && bestCandidateBpm * 2 <= 215)
|
||||
{
|
||||
int doubleBpm = bestCandidateBpm * 2;
|
||||
if (scores[doubleBpm] >= bestCandidateScore * 0.80)
|
||||
{
|
||||
int lagSlow = (int)Math.Round((60.0 / bestCandidateBpm) * 100.0);
|
||||
int lagFast = (int)Math.Round((60.0 / doubleBpm) * 100.0);
|
||||
double rSlow = 0, rFast = 0;
|
||||
int cSlow = 0, cFast = 0;
|
||||
for (int i = lagSlow; i < totalHopsRecorded; i++) { rSlow += env[i] * env[i - lagSlow]; cSlow++; }
|
||||
for (int i = lagFast; i < totalHopsRecorded; i++) { rFast += env[i] * env[i - lagFast]; cFast++; }
|
||||
if (cSlow > 0) rSlow /= cSlow;
|
||||
if (cFast > 0) rFast /= cFast;
|
||||
|
||||
if (rFast >= rSlow * 0.55)
|
||||
{
|
||||
bestCandidateBpm = doubleBpm;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (bestCandidateScore > 0.0005)
|
||||
{
|
||||
if (detectedBpm <= 10.0f)
|
||||
{
|
||||
// Primo aggancio immediato
|
||||
detectedBpm = bestCandidateBpm;
|
||||
candidateBpm = bestCandidateBpm;
|
||||
candidateStreak = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
float diff = Math.Abs(bestCandidateBpm - detectedBpm);
|
||||
if (diff <= 4.0f)
|
||||
{
|
||||
// Micro-fluttuazione naturale del brano: adatta dolcemente
|
||||
detectedBpm = (detectedBpm * 0.94f) + (bestCandidateBpm * 0.06f);
|
||||
candidateStreak = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Il candidato si discosta significativamente dal tempo attuale.
|
||||
// Per cambiare tempo (cambio canzone effettivo) deve rimanere stabile e confermato per almeno 10 cicli (~1 secondo)!
|
||||
if (Math.Abs(bestCandidateBpm - candidateBpm) <= 3)
|
||||
{
|
||||
candidateStreak++;
|
||||
if (candidateStreak >= 10)
|
||||
{
|
||||
detectedBpm = (detectedBpm * 0.4f) + (bestCandidateBpm * 0.6f);
|
||||
if (Math.Abs(detectedBpm - bestCandidateBpm) < 2.0f)
|
||||
{
|
||||
detectedBpm = bestCandidateBpm;
|
||||
candidateStreak = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
candidateBpm = bestCandidateBpm;
|
||||
candidateStreak = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 4. Invio lista applicazioni attive (FILTRANDO se stesso e Godot!)
|
||||
long nowTicks = DateTime.UtcNow.Ticks;
|
||||
if ((nowTicks - lastAppListBroadcast) >= (TimeSpan.TicksPerMillisecond * 1500) && sessionManager != null)
|
||||
{
|
||||
lastAppListBroadcast = nowTicks;
|
||||
try
|
||||
{
|
||||
IAudioSessionEnumerator sessionEnum;
|
||||
sessionManager.GetSessionEnumerator(out sessionEnum);
|
||||
int count;
|
||||
sessionEnum.GetCount(out count);
|
||||
StringBuilder sb = new StringBuilder("APPS:0:Tutto il sistema");
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
object oSession;
|
||||
sessionEnum.GetSession(i, out oSession);
|
||||
var session2 = (IAudioSessionControl2)oSession;
|
||||
uint pid;
|
||||
session2.GetProcessId(out pid);
|
||||
|
||||
if (pid > 0 && pid != myPid)
|
||||
{
|
||||
string name = "";
|
||||
try
|
||||
{
|
||||
Process p = Process.GetProcessById((int)pid);
|
||||
name = p.ProcessName;
|
||||
string lowerName = name.ToLower();
|
||||
// FILTRA: nasconde LoopbackCapture e Godot dal menu!
|
||||
if (lowerName.Contains("loopbackcapture") || lowerName.Contains("godot")) continue;
|
||||
}
|
||||
catch { }
|
||||
|
||||
if (!string.IsNullOrEmpty(name))
|
||||
{
|
||||
sb.AppendFormat(";{0}:{1}", pid, name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
byte[] appBytes = Encoding.UTF8.GetBytes(sb.ToString());
|
||||
udpSend.Send(appBytes, appBytes.Length, remoteEp);
|
||||
}
|
||||
catch { }
|
||||
}
|
||||
|
||||
// 5. Invio dati audio a Godot (8 byte: RMS + BPM)
|
||||
if (udpSend != null)
|
||||
{
|
||||
byte[] payload = new byte[8];
|
||||
Array.Copy(BitConverter.GetBytes(displayRms), 0, payload, 0, 4);
|
||||
Array.Copy(BitConverter.GetBytes(detectedBpm), 0, payload, 4, 4);
|
||||
try
|
||||
{
|
||||
udpSend.Send(payload, payload.Length, remoteEp);
|
||||
}
|
||||
catch { }
|
||||
}
|
||||
|
||||
Thread.Sleep(8);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[ComImport]
|
||||
[Guid("BCDE0395-E52F-467C-8E3D-C4579291692E")]
|
||||
class MMDeviceEnumeratorComObject { }
|
||||
|
||||
public enum EDataFlow { eRender, eCapture, eAll }
|
||||
public enum ERole { eConsole, eMultimedia, eCommunications }
|
||||
|
||||
[Guid("A95664D2-9614-4F35-A746-DE8DB63617E6"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
public interface IMMDeviceEnumerator
|
||||
{
|
||||
int EnumAudioEndpoints(EDataFlow dataFlow, int stateMask, out IntPtr devices);
|
||||
int GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role, out IMMDevice endpoint);
|
||||
int GetDevice(string id, out IMMDevice device);
|
||||
int RegisterEndpointNotificationCallback(IntPtr client);
|
||||
int UnregisterEndpointNotificationCallback(IntPtr client);
|
||||
}
|
||||
|
||||
[Guid("D666063F-1587-4E43-81F1-B948E807363F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
public interface IMMDevice
|
||||
{
|
||||
int Activate(ref Guid id, int clsCtx, IntPtr activationParams, [MarshalAs(UnmanagedType.IUnknown)] out object interfacePointer);
|
||||
int OpenPropertyStore(int stgmAccess, out IntPtr properties);
|
||||
int GetId([MarshalAs(UnmanagedType.LPWStr)] out string id);
|
||||
int GetState(out int state);
|
||||
}
|
||||
|
||||
[Guid("77AA99A0-1BD6-484F-8BC7-2C654C9A9B6F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
public interface IAudioSessionManager2
|
||||
{
|
||||
int GetAudioSessionControl(IntPtr sessionId, int priority, out IntPtr control);
|
||||
int GetSimpleAudioVolume(IntPtr sessionId, int priority, out IntPtr volume);
|
||||
int GetSessionEnumerator(out IAudioSessionEnumerator sessionEnum);
|
||||
}
|
||||
|
||||
[Guid("E2F5BB11-0570-40CA-ACDD-3AA01277DEE8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
public interface IAudioSessionEnumerator
|
||||
{
|
||||
int GetCount(out int sessionCount);
|
||||
int GetSession(int sessionIndex, [MarshalAs(UnmanagedType.IUnknown)] out object session);
|
||||
}
|
||||
|
||||
[Guid("bfb7ff88-7239-4fc9-8fa2-07c950be9c6d"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
public interface IAudioSessionControl2
|
||||
{
|
||||
int GetState(out int state);
|
||||
int GetDisplayName(out IntPtr name);
|
||||
int SetDisplayName(string value, IntPtr eventContext);
|
||||
int GetIconPath(out IntPtr path);
|
||||
int SetIconPath(string value, IntPtr eventContext);
|
||||
int GetGroupingParam(out Guid grouping);
|
||||
int SetGroupingParam(ref Guid grouping, IntPtr eventContext);
|
||||
int RegisterAudioSessionNotification(IntPtr client);
|
||||
int UnregisterAudioSessionNotification(IntPtr client);
|
||||
int GetSessionIdentifier(out IntPtr id);
|
||||
int GetSessionInstanceIdentifier(out IntPtr id);
|
||||
int GetProcessId(out uint processId);
|
||||
int IsSystemSoundsSession();
|
||||
int SetDuckingPreference(bool optOut);
|
||||
}
|
||||
|
||||
[Guid("C02216F6-8C67-4B5B-9D00-D008E73E0064"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
public interface IAudioMeterInformation
|
||||
{
|
||||
int GetPeakValue(out float peak);
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
||||
public struct WAVEFORMATEX
|
||||
{
|
||||
public short wFormatTag;
|
||||
public short nChannels;
|
||||
public int nSamplesPerSec;
|
||||
public int nAvgBytesPerSec;
|
||||
public short nBlockAlign;
|
||||
public short wBitsPerSample;
|
||||
public short cbSize;
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
||||
public struct WAVEFORMATEXTENSIBLE
|
||||
{
|
||||
public WAVEFORMATEX Format;
|
||||
public short wValidBitsPerSample;
|
||||
public int dwChannelMask;
|
||||
public Guid SubFormat;
|
||||
}
|
||||
|
||||
[Guid("1CB9AD4C-DBFA-4c32-B178-C2F568A703B2"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
public interface IAudioClient
|
||||
{
|
||||
int Initialize(int shareMode, int streamFlags, long hnsBufferDuration, long hnsPeriodicity, IntPtr pFormat, ref Guid audioSessionGuid);
|
||||
int GetBufferSize(out uint bufferFrameCount);
|
||||
int GetStreamLatency(out long hnsLatency);
|
||||
int GetCurrentPadding(out uint numPaddingFrames);
|
||||
int IsFormatSupported(int shareMode, IntPtr pFormat, out IntPtr ppClosestMatch);
|
||||
int GetMixFormat(out IntPtr ppDeviceFormat);
|
||||
int GetDevicePeriod(out long hnsDefaultDevicePeriod, out long hnsMinimumDevicePeriod);
|
||||
int Start();
|
||||
int Stop();
|
||||
int Reset();
|
||||
int SetEventHandle(IntPtr eventHandle);
|
||||
int GetService(ref Guid interfaceId, [MarshalAs(UnmanagedType.IUnknown)] out object interfacePointer);
|
||||
}
|
||||
|
||||
[Guid("C8ADBD64-E71E-48a0-A4DE-185C395CD317"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
public interface IAudioCaptureClient
|
||||
{
|
||||
int GetBuffer(out IntPtr dataPointer, out uint numFramesToRead, out int bufferFlags, out ulong devicePosition, out ulong qpcPosition);
|
||||
int ReleaseBuffer(uint numFramesRead);
|
||||
int GetNextPacketSize(out uint numFramesInNextPacket);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user