Виртуальные кабеля, ASIO и задержки

[E.Sokol]

Попробовал использовать виртуальные аудио-кабеля отсюда и отсюда, чтобы обрабатывать аудио-поток через своё приложение. И всё вроде работает, только совершенно дикая задержка в 2-3 секунды. Проблема точно не в приложении, поскольку при использовании реальных устройств всё чётко. Может, кто-нибудь сталкивался?

Искал похожее для ASIO, но не нашёл. В принципе, не так уж и сложно написать самому, но не хочется заморачиваться, да и скорее всего, тут я тоже чего-то не догоняю.

---------- Сообщение добавлено 07.02.2022 в 13:17 ---------- Предыдущее сообщение было 06.02.2022 в 20:34 ----------

Всё-таки это я лошара! У меня проблема, весьма неочевидный баг оказался. Но тему пока не закрываю, потому что вопрос с ASIO всё ещё открытый.

[domician]

весьма неочевидный баг оказался.

Интересно, в чем была проблема? Ну а ASIO нужен только при создании музматериала, при прослушке WASAPI Exclusive за глаза.
Ну да, еще для автомата у некоторых ЗК. Несущественно.

[E.Sokol]

Интересно, в чем была проблема?

Идея такая - разработать максимально простой и интуитивно понятный SDK для обработки звука в виде графа из элементарных модулей. Идея далеко не новая, но в существующих решениях мне не нравится то одно, то другое, то третье, а самое главное - сложность программирования новых модулей или вообще невозможность добавления дополнительной функциональности (как в железных DSP-процессорах). К SDK прилагается визуальный редактор, в котором в режиме реального времени можно накидать/редактировать структуру, а затем, при желании, использовать её отдельно в другом приложении, службе, или даже плагине в чужом аудио-плеере.

Как-то так выглядит:


Обычно такую обработку реализуют буферами, что накладывает определённые сложности - когда входные данные приходят порциями по 1000 семплов (причём их количество может меняться), отдавать надо порциями по 1500, а в середине делать FFT по 4096. Поэтому у меня обработка происходит по одному семплу, а разбивка буферов на семплы и сборка их обратно отдана на откуп отдельным модулям (когда в этом есть необходимость. Для IIR-фильтра, в частности, такой необходимости нет).

Мне также не хотелось привязываться к какому-то одному протоколу ввода-вывода данных, поэтому они тоже реализованы в виде отдельных модулей. WASAPI OUT ничего не знает про WASAPI IN. Поэтому когда приходят данные, например, с микрофона - они записываются в кольцевой буфер (линия задержки по сути), в котором лежат до тех пор, пока WASAPI OUT не инициирует просчёт всей схемы для заполнения новой порции семплов в буфер.

Вот тут и закрался баг - у меня получалось, что позиция чтения из буфера в модуле WASAPI IN опережала позицию записи. Отсюда и задержка в размер всего буфера целиком.

---------- Сообщение добавлено 09:41 ---------- Предыдущее сообщение было 09:38 ----------

А когда я использовал просто WASAPI IN со спектроанализатором без вывода звука, бага не было - потому в таком режиме он сам инициировал просчёт схемы и линию задержки не использовал.

[domician]

Понятно.
А идея с SDK очень интересна. Надеюсь, нет, уверен, что у Вас получится.
Ну и потом поделитесь

[E.Sokol]

Поделиться-то не проблема - уже почти всё готово и я так и так предполагал выкладывать всё в open source. Проблема в том, кому это вообще нужно и в том, что существует труднопреодолимая граница между наколенной поделкой "для себя" и массовым продуктом, требующим соответствующей инфраструктуры - документация, сайт, поддержка, красивый GUI, обратная совместимость и всё такое, а собственно сама функциональность оказывается где-то на последнем месте.

---------- Сообщение добавлено 08:20 ---------- Предыдущее сообщение было 08:03 ----------

Ещё одна проблема - это названия, все адекватные варианты которого уже заняты. Что ES.Audio, что ES.Modules, что ES Audio Processor. Понятное дело, что мне их никто не мешает использовать - но в поисковой выборке гугла они будут далеко не на первом месте, если вообще будут.

[maxssau]

E.Sokol, а модули можно программировать в рукопашную? будет ли какая то минималистическая документация?

[E.Sokol]

Я предполагал писать статью, рассказывающую в общих чертах, что к чему. Но в целом всё настолько просто, что проще некуда. Вот, например, модуль для суммы-разности:

[Serializable]
public class MSMatrix : Module
{
	public MSMatrix() : base(2, 2)
	{
		CommentIn[0] = "L";
		CommentIn[1] = "R";
		CommentOut[0] = "M";
		CommentOut[1] = "S";
	}

	public override void Process()
	{
		Output[0].Value = 0.5 * (Input[0].Value + Input[1].Value);
		Output[1].Value = 0.5 * (Input[0].Value - Input[1].Value);
	}
}

[maxssau]

софт на самом деле очень интересный и сильно бы помог в написании и отладки прошивки с ДСП на общепромышленных процессорах вроде СТМ32, без использования АДАУ. буду ждать выхода софта и сдк к нему

[E.Sokol]

На промышленные процессоры он вряд ли подойдёт, потому что заточен под C# и ООП. Версия для с++ есть, но она пока не развивается. На другие языки в принципе тоже можно портировать, но только если они поддерживают ООП. Язык си и прочее низкоуровневое к ним точно не относятся.

[maxssau]

мне только для отладки самой математики дсп, а в какоую оболочку будет завернуто не особо важно

[domician]

Проблема в том, кому это вообще нужно и в том, что существует труднопреодолимая граница между наколенной поделкой "для себя" и массовым продуктом, требующим соответствующей инфраструктуры - документация, сайт, поддержка, красивый GUI, обратная совместимость и всё такое, а собственно сама функциональность оказывается где-то на последнем месте.

Нужно
А наколенными поделками мы здесь все занимаемся, но то и хобби. Красивый GUI ? Ну не знаю. Для меня GUI , например, 7zip - эталон, как надо. А то ныне часто он занимает 99% проги. Вот последние версии iZotope Ozone - типа красиво (по ихнему разумению), а в действительности жрущий ресурсы вырвиглаз.

[mellowman]

Я предполагал писать статью, рассказывающую в общих чертах, что к чему. Но в целом всё настолько просто, что проще некуда. Вот, например, модуль для суммы-разности:

[Serializable]
public class MSMatrix : Module
{
	public MSMatrix() : base(2, 2)
	{
		CommentIn[0] = "L";
		CommentIn[1] = "R";
		CommentOut[0] = "M";
		CommentOut[1] = "S";
	}

	public override void Process()
	{
		Output[0].Value = 0.5 * (Input[0].Value + Input[1].Value);
		Output[1].Value = 0.5 * (Input[0].Value - Input[1].Value);
	}
}

Чем это лучше VST?

[E.Sokol]

Чем это лучше VST?

Не помню, чтобы я говорил что-то про "лучше" - просто делаю так, как кажется правильным (и интересным) лично мне. Опыт написания VST-плагина не оставил у меня положительных эмоций, и вообще программировать на c/c++ - не моё.

[mellowman]

Не помню, чтобы я говорил что-то про "лучше" - просто делаю так, как кажется правильным (и интересным) лично мне.

Напоминаю

Идея далеко не новая, но в существующих решениях мне не нравится то одно, то другое, то третье, а самое главное - сложность программирования новых модулей или вообще невозможность добавления дополнительной функциональности (как в железных DSP-процессорах)

Опыт написания VST-плагина не оставил у меня положительных эмоций, и вообще программировать на c/c++ - не моё.

[E.Sokol]

В частности оказалось, что далеко не все VST-хосты поддерживают многоканальные входы-выходы, и мой плагин там попросту не работал. Ещё оказалось, что далеко не все VST-хосты поддерживают настройку параметров без встроенного гуя.

Ещё можно сравнить по количеству кода. Вот, например, как выглядит плагин с задержкой из официального SDK:

adelaymain.cpp

//-------------------------------------------------------------------------------------------------------
// VST Plug-Ins SDK
// Version 2.4		$Date: 2005/11/30 13:04:21 $
//
// Category     : VST 2.x SDK Samples
// Filename     : adelaymain.cpp
// Created by   : Steinberg Media Technologies
// Description  : Simple Delay plugin (Mono->Stereo)
//
// © 2005, Steinberg Media Technologies, All Rights Reserved
//-------------------------------------------------------------------------------------------------------

#ifndef __adelay__
#include "adelay.h"
#endif

//-------------------------------------------------------------------------------------------------------
AudioEffect* createEffectInstance (audioMasterCallback audioMaster)
{
	return new ADelay (audioMaster);
}

[свернуть]

adelay.h

//-------------------------------------------------------------------------------------------------------
// VST Plug-Ins SDK
// Version 2.4		$Date: 2005/12/06 09:09:26 $
//
// Category     : VST 2.x SDK Samples
// Filename     : adelay.h
// Created by   : Steinberg Media Technologies
// Description  : Simple Delay plugin (Mono->Stereo)
//
// © 2005, Steinberg Media Technologies, All Rights Reserved
//-------------------------------------------------------------------------------------------------------

#ifndef __adelay__
#define __adelay__

#include "public.sdk/source/vst2.x/audioeffectx.h"

#pragma comment(linker, "/OPT:NOWIN98")

enum
{
	// Global
	kNumPrograms = 16,

	// Parameters Tags
	kDelay = 0,
	kFeedBack,
	kOut,

	kNumParams
};

class ADelay;

//------------------------------------------------------------------------
class ADelayProgram
{
friend class ADelay;
public:
	ADelayProgram ();
	~ADelayProgram () {}

private:	
	float fDelay;
	float fFeedBack;
	float fOut;
	char name[24];
};

//------------------------------------------------------------------------
class ADelay : public AudioEffectX
{
public:
	ADelay (audioMasterCallback audioMaster);
	~ADelay ();

	virtual void processReplacing (float **inputs, float **outputs, VstInt32 sampleFrames);

	virtual void setProgram (long program);
	virtual void setProgramName (char *name);
	virtual void getProgramName (char *name);
	virtual bool getProgramNameIndexed (VstInt32 category, VstInt32 index, char* text);
	
	virtual void setParameter (VstInt32 index, float value);
	virtual float getParameter (VstInt32 index);
	virtual void getParameterLabel (VstInt32 index, char *label);
	virtual void getParameterDisplay (VstInt32 index, char *text);
	virtual void getParameterName (VstInt32 index, char *text);

	virtual void resume ();

	virtual bool getEffectName (char* name);
	virtual bool getVendorString (char* text);
	virtual bool getProductString (char* text);
	virtual VstInt32 getVendorVersion () { return 1000; }
	
	virtual VstPlugCategory getPlugCategory () { return kPlugCategEffect; }

protected:
	void setDelay (float delay);

	ADelayProgram *programs;
	
	float *buffer;
	float fDelay, fFeedBack, fOut;
	
	
	long delay;
	long size;
	long cursor;
};

#endif

[свернуть]

adelay.cpp

//-------------------------------------------------------------------------------------------------------
// VST Plug-Ins SDK
// Version 2.4		$Date: 2005/11/30 13:04:21 $
//
// Category     : VST 2.x SDK Samples
// Filename     : adelay.cpp
// Created by   : Steinberg Media Technologies
// Description  : Simple Delay plugin (Mono->Stereo)
//
// © 2005, Steinberg Media Technologies, All Rights Reserved
//-------------------------------------------------------------------------------------------------------

#include <stdio.h>
#include <string.h>

#ifndef __adelay__
#include "adelay.h"
#endif

//----------------------------------------------------------------------------- 
ADelayProgram::ADelayProgram ()
{
	// default Program Values
	fDelay = 0.5;
	fFeedBack = 0.5;
	fOut = 0.75;

	strcpy (name, "Init");
}

//-----------------------------------------------------------------------------
ADelay::ADelay (audioMasterCallback audioMaster)
	: AudioEffectX (audioMaster, kNumPrograms, kNumParams)
{
	// init
	size = 44100;
	cursor = 0;
	delay = 0;
	buffer = new float[size];
	
	programs = new ADelayProgram[numPrograms];
	fDelay = fFeedBack = fOut = 0;

	if (programs)
		setProgram (0);

	setNumInputs (1);	// mono input
	setNumOutputs (2);	// stereo output

	setUniqueID (*ADly*);

	resume ();		// flush buffer
}

//------------------------------------------------------------------------
ADelay::~ADelay ()
{
	if (buffer)
		delete[] buffer;
	if (programs)
		delete[] programs;
}

//------------------------------------------------------------------------
void ADelay::setProgram (long program)
{
	ADelayProgram* ap = &programs[program];

	curProgram = program;
	setParameter (kDelay, ap->fDelay);	
	setParameter (kFeedBack, ap->fFeedBack);
	setParameter (kOut, ap->fOut);
}

//------------------------------------------------------------------------
void ADelay::setDelay (float fdelay)
{
	fDelay = fdelay;
	programs[curProgram].fDelay = fdelay;
	cursor = 0;
	delay = (long)(fdelay * (float)(size - 1));
}

//------------------------------------------------------------------------
void ADelay::setProgramName (char *name)
{
	strcpy (programs[curProgram].name, name);
}

//------------------------------------------------------------------------
void ADelay::getProgramName (char *name)
{
	if (!strcmp (programs[curProgram].name, "Init"))
		sprintf (name, "%s %d", programs[curProgram].name, curProgram + 1);
	else
		strcpy (name, programs[curProgram].name);
}

//-----------------------------------------------------------------------------------------
bool ADelay::getProgramNameIndexed (VstInt32 category, VstInt32 index, char* text)
{
	if (index < kNumPrograms)
	{
		strcpy (text, programs[index].name);
		return true;
	}
	return false;
}

//------------------------------------------------------------------------
void ADelay::resume ()
{
	memset (buffer, 0, size * sizeof (float));
	AudioEffectX::resume ();
}

//------------------------------------------------------------------------
void ADelay::setParameter (VstInt32 index, float value)
{
	ADelayProgram* ap = &programs[curProgram];

	switch (index)
	{
		case kDelay :    setDelay (value);					break;
		case kFeedBack : fFeedBack = ap->fFeedBack = value; break;
		case kOut :      fOut = ap->fOut = value;			break;
	}
}

//------------------------------------------------------------------------
float ADelay::getParameter (VstInt32 index)
{
	float v = 0;

	switch (index)
	{
		case kDelay :    v = fDelay;	break;
		case kFeedBack : v = fFeedBack; break;
		case kOut :      v = fOut;		break;
	}
	return v;
}

//------------------------------------------------------------------------
void ADelay::getParameterName (VstInt32 index, char *label)
{
	switch (index)
	{
		case kDelay :    strcpy (label, "Delay");		break;
		case kFeedBack : strcpy (label, "FeedBack");	break;
		case kOut :      strcpy (label, "Volume");		break;
	}
}

//------------------------------------------------------------------------
void ADelay::getParameterDisplay (VstInt32 index, char *text)
{
	switch (index)
	{
		case kDelay :    int2string (delay, text, kVstMaxParamStrLen);			break;
		case kFeedBack : float2string (fFeedBack, text, kVstMaxParamStrLen);	break;
		case kOut :      dB2string (fOut, text, kVstMaxParamStrLen);			break;
	}
}

//------------------------------------------------------------------------
void ADelay::getParameterLabel (VstInt32 index, char *label)
{
	switch (index)
	{
		case kDelay :    strcpy (label, "samples");	break;
		case kFeedBack : strcpy (label, "amount");	break;
		case kOut :      strcpy (label, "dB");		break;
	}
}

//------------------------------------------------------------------------
bool ADelay::getEffectName (char* name)
{
	strcpy (name, "Delay");
	return true;
}

//------------------------------------------------------------------------
bool ADelay::getProductString (char* text)
{
	strcpy (text, "Delay");
	return true;
}

//------------------------------------------------------------------------
bool ADelay::getVendorString (char* text)
{
	strcpy (text, "Steinberg Media Technologies");
	return true;
}

//---------------------------------------------------------------------------
void ADelay::processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames)
{
	float* in = inputs[0];
	float* out1 = outputs[0];
	float* out2 = outputs[1];

	while (--sampleFrames >= 0)
	{
		float x = *in++;
		float y = buffer[cursor];
		buffer[cursor++] = x + y * fFeedBack;
		if (cursor >= delay)
			cursor = 0;
		*out1++ = x;
		*out2++ = y;
	}
}

[свернуть]

А вот та же самая функциональность у меня:

Delay.cs

using System;
using ES.Dsp.Modules.Core;

namespace ES.Dsp.Modules
{
    [Serializable]
    public class Delay : Module
    {
        [NonSerialized]
        double[] delayline;
        [NonSerialized]
        int readpos = 0;
        [NonSerialized]
        int writepos = 0;

        private int maxDelay = 48000;
        public int MaxDelaySamples
        {
            get { return maxDelay; }
            set { lock (GlobalLocker) { maxDelay = Math.Max(1, value); Init(); } }
        }

        // конструктор
        public Delay() : base(3, 1) // количество входов и выходов
        {
            CommentIn[0] = "in";
            CommentIn[1] = "dly";
            CommentIn[2] = "feedback";
            CommentOut[0] = "out";

            Input[1].Value = maxDelay; // задержка по-умолчанию
            Input[2].Value = 0.5; // резонанс по-умолчанию
            Init();
        }

        // инициализация несохраняемых полей
        public override void Init()
        {
            if (delayline == null)
                delayline = new double[maxDelay + 1];
            if (delayline.Length != maxDelay + 1)
                delayline = new double[maxDelay + 1];
        }

        // сброс параметров 
        public override void Reset()
        {
            Array.Clear(delayline, 0, delayline.Length);
            readpos = 0;
            writepos = 0;
            Output[0].Value = 0.0;
        }

        // обработка потока
        public override void Process()
        {
            int delay = Math.Max(0, Math.Min(MaxDelaySamples, (int)Input[1].Value));

            readpos = (writepos - delay + delayline.Length) % delayline.Length;

            double feedback = Input[2].Value;
            double sample = Input[0].Value + feedback * delayline[readpos];
            delayline[writepos] = sample;
            Output[0].Value = sample;

            writepos = (writepos + 1) % delayline.Length;
        }
    }
}

[свернуть]

[mellowman]

Если в VST*шном примере закрыть глаза на С в плохом смысле слова, концептуально, передача input и output в process — получше, чем непонятно откуда взятые и что означающие числа в input*е. Плюс frame может быть полезен. Но идея, что maxDelay можно не крутить руками а воткнуть выход другого плагина интересная

[E.Sokol]

Непонятные числа в input и output - это очевидно порядковые номера этих самых input и output, вместо которых можно использовать строковые псевдонимы, задаваемых в конструкторе. Их можно использовать как для задания параметров, так и для задания связей, указывающих в качестве источника данных выход другого модуля:

var dly = new Delay();
dly["feedback"] = 0.99;
var waveout = new WasapiOut();
Module.Wire(dly, "out", "L", waveout);

Внутри метода Process они не используются в целях производительности (хотя можно при желании).

Плюс можно все модули сложить в один контейнер и оперировать ими как единым целым. А этот контейнер, в свою очередь, можно вложить в другой контейнер и оперировать им наравне с другими модулями. Такой функциональности в VST совершенно точно не предусмотрено.

[mellowman]

Плюс можно все модули сложить в один контейнер и оперировать ими как единым целым. А этот контейнер, в свою очередь, можно вложить в другой контейнер и оперировать им наравне с другими модулями. Такой функциональности в VST совершенно точно не предусмотрено.

Её и не надо предусматривать специально, https://youtu.be/hhfO9yYNlJY?list=PL...4NLYIfqA&t=193

Offтопик:
Вот интересная штука попадалась недавно: https://github.com/SamiPerttu/fundsp#graph-notation

[E.Sokol]

Её и не надо предусматривать специально, https://youtu.be/hhfO9yYNlJY?list=PL...4NLYIfqA&t=193

Ну так я сразу и сказал, что идея далеко не новая, и NI Reaktor (на который я и ориентировался в первую очередь) помощнее будет. Ну а в качестве интересных задач на готовых решениях могу предложить:

1) загрузить набранный граф в своё приложение без СМС и регистрации;
2) вывести сигнал на два разных устройства;
2.б) синхронизировать их программным способом (потому что хз, у кого там какая аппаратная задержка);
3) использовать в обработке комплексные числа (DSP же, а не просто музыкальная шкатулка);
4) обрабатывать сигнал непосредственно в частотном домене (я этого тоже ещё не сделал, но желание есть).

---------- Сообщение добавлено 08:09 ---------- Предыдущее сообщение было 08:08 ----------

А, и про обработку на разных частотах дискретизации забыл упомянуть.

---------- Сообщение добавлено 08:07 ---------- Предыдущее сообщение было 08:05 ----------

Поддержку VST тоже хотел как-нибудь потом реализовать. Вызывать нативный код из c# намного проще, чем наоборот.

---------- Сообщение добавлено 08:08 ---------- Предыдущее сообщение было 08:07 ----------

А за ссылку на FunDSP - спасибо, выглядит интересным. Жаль только, что на Rust. И могу поспорить, что количество людей со стороны, способных на нём реализовать кроссовер - чуть меньше нуля. Хотя бы потому, что реализация ввода/вывода аудиопотока в реалтайме отсутствует - можно только .wav файл записать.

[mellowman]

3) использовать в обработке комплексные числа (DSP же, а не просто музыкальная шкатулка);
4) обрабатывать сигнал непосредственно в частотном домене (я этого тоже ещё не сделал, но желание есть).

Это разными process*ами, или всё в одном?

А, и про обработку на разных частотах дискретизации забыл упомянуть.

А почему тогда maxDelay = 48k в примере?

И могу поспорить, что количество людей со стороны, способных на нём реализовать кроссовер - чуть меньше нуля.

Ну сегодня меньше, завтра больше Так всегда, сначала хорошая идея, потом народ подтянется