public AudioMaster(
int samplingRate,
int blockSize,
ILoggerFactory loggerFactory,
ElapsedTimeCounter counter,
IDllManager dllManager
)
{
_loggerFactory = loggerFactory;
_logger = _loggerFactory.CreateLogger <AudioMaster <T> >();
_counter = counter;
DllManager = dllManager;
_param = new("vstTimeInfo", 1, _loggerFactory);
var p = _param.AsSpan(0, 1);
p[0].vstTimeInfo.samplePos = 0.0;
p[0].vstTimeInfo.sampleRate = samplingRate;
p[0].vstTimeInfo.nanoSeconds = 0.0;
p[0].vstTimeInfo.ppqPos = 0.0;
p[0].vstTimeInfo.tempo = 240.0;
p[0].vstTimeInfo.barStartPos = 0.0;
p[0].vstTimeInfo.cycleStartPos = 0.0;
p[0].vstTimeInfo.cycleEndPos = 0.0;
p[0].vstTimeInfo.timeSigNumerator = 4;
p[0].vstTimeInfo.timeSigDenominator = 4;
p[0].vstTimeInfo.smpteOffset = 0;
p[0].vstTimeInfo.smpteFrameRate = VstTimeInfo.VstSmpteFrameRate.kVstSmpte24fps;
p[0].vstTimeInfo.samplesToNextClock = 0;
p[0].vstTimeInfo.flags = VstTimeInfo.VstTimeInfoFlags.kVstTempoValid | VstTimeInfo.VstTimeInfoFlags.kVstNanosValid;
p[0].vstProcessLevels = VstProcessLevels.kVstProcessLevelRealtime;
p[0].samplingRate = samplingRate;
p[0].blockSize = blockSize;
}
public void Test1()
{
var configuration =
new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var streamKey = configuration["MIXER_STREAM_KEY"];
var ingestHostname = configuration["MIXER_INGEST_HOSTNAME"];
var mixerApiClientId = configuration["MIXER_USER_NAME"];
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddFilter("Momiji", LogLevel.Debug);
builder.AddFilter("Microsoft", LogLevel.Warning);
builder.AddFilter("System", LogLevel.Warning);
builder.AddConsole();
builder.AddDebug();
});
var counter = new ElapsedTimeCounter();
using var dllManager = new DllManager(configuration, loggerFactory);
//using var ftl = new FtlIngest(streamKey, ingestHostname, loggerFactory, timer, 1000, 1000, true, mixerApiClientId);
//ftl.Connect();
}
private async Task RunConnect()
{
var ct = ProcessCancel.Token;
var taskSet = new HashSet <Task>();
var blockSize = (int)(Param.SamplingRate * Param.SampleLength);
Logger.LogInformation($"[loop3] blockSize {blockSize}");
var audioInterval = (long)(10_000_000.0 * Param.SampleLength);
Logger.LogInformation($"[loop3] audioInterval {audioInterval}");
var videoInterval = (long)(10_000_000.0 / Param.MaxFrameRate);
Logger.LogInformation($"[loop3] videoInterval {videoInterval}");
var counter = new ElapsedTimeCounter();
using var audioWaiter = new Waiter(counter, audioInterval);
using var videoWaiter = new Waiter(counter, videoInterval);
using var buf = new IPCBuffer <float>(Param.EffectName, blockSize * 2 * Param.BufferCount, LoggerFactory);
using var vstBufferPool = new BufferPool <VstBuffer2 <float> >(Param.BufferCount, () => new VstBuffer2 <float>(blockSize, 2, buf), LoggerFactory);
using var pcmPool = new BufferPool <PcmBuffer <float> >(Param.BufferCount, () => new PcmBuffer <float>(blockSize, 2), LoggerFactory);
using var audioPool = new BufferPool <OpusOutputBuffer>(Param.BufferCount, () => new OpusOutputBuffer(5000), LoggerFactory);
using var pcmDrowPool = new BufferPool <PcmBuffer <float> >(Param.BufferCount, () => new PcmBuffer <float>(blockSize, 2), LoggerFactory);
using var bmpPool = new BufferPool <H264InputBuffer>(Param.BufferCount, () => new H264InputBuffer(Param.Width, Param.Height), LoggerFactory);
using var videoPool = new BufferPool <H264OutputBuffer>(Param.BufferCount, () => new H264OutputBuffer(200000), LoggerFactory);
using var vst = new AudioMaster <float>(Param.SamplingRate, blockSize, LoggerFactory, counter, DllManager);
using var toPcm = new ToPcm <float>(LoggerFactory, counter);
using var opus = new OpusEncoder(SamplingRate.Sampling48000, Channels.Stereo, LoggerFactory, counter);
using var fft = new FFTEncoder(Param.Width, Param.Height, Param.MaxFrameRate, LoggerFactory, counter);
using var h264 = new H264Encoder(Param.Width, Param.Height, Param.TargetBitrate, Param.MaxFrameRate, LoggerFactory, counter);
var effect = vst.AddEffect(Param.EffectName);
using var ftl = new FtlIngest(StreamKey, IngestHostname, LoggerFactory, counter, audioInterval, videoInterval, default, CaInfoPath);
public void Test2()
{
var configuration =
new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddFilter("Momiji", LogLevel.Debug);
builder.AddFilter("Microsoft", LogLevel.Warning);
builder.AddFilter("System", LogLevel.Warning);
builder.AddConsole();
builder.AddDebug();
});
var logger = loggerFactory.CreateLogger <VstUnitTest>();
using var dllManager = new DllManager(configuration, loggerFactory);
var counter = new ElapsedTimeCounter();
var blockSize = 2880;
using var vst = new AudioMaster <float>(48000, blockSize, loggerFactory, counter, dllManager);
using var processCancel = new CancellationTokenSource();
var effect = vst.AddEffect("Synth1 VST.dll");
effect.OpenEditor(processCancel.Token);
processCancel.Cancel();
effect.CloseEditorAsync().Wait();
}
public void Test3()
{
var configuration =
new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddFilter("Momiji", LogLevel.Debug);
builder.AddFilter("Microsoft", LogLevel.Warning);
builder.AddFilter("System", LogLevel.Warning);
builder.AddConsole();
builder.AddDebug();
});
var logger = loggerFactory.CreateLogger <VstUnitTest>();
using var dllManager = new DllManager(configuration, loggerFactory);
var counter = new ElapsedTimeCounter();
var blockSize = 2880;
using var vst = new AudioMaster <float>(48000, blockSize, loggerFactory, counter, dllManager);
var effect = vst.AddEffect("Synth1 VST.dll");
vst.RemoveEffect(effect);
}
public OpusEncoder(
SamplingRate Fs,
Channels channels,
ILoggerFactory loggerFactory,
ElapsedTimeCounter counter
)
{
ArgumentNullException.ThrowIfNull(loggerFactory);
ArgumentNullException.ThrowIfNull(counter);
_logger = loggerFactory.CreateLogger <OpusEncoder>();
_counter = counter;
_logger.LogInformation($"opus version {NativeMethods.opus_get_version_string()}");
_encoder =
NativeMethods.opus_encoder_create(
Fs, channels, OpusApplicationType.Audio, out var error
);
if (error != OpusStatusCode.OK)
{
throw new OpusException($"[opus] opus_encoder_create error:{NativeMethods.opus_strerror((int)error)}({error})");
}
}
public void Test1()
{
int deviceID = 0;
short channels = 1;
int samplingRate = 4800;
int sampleLength = 10;
var blockSize = (samplingRate * sampleLength);
SPEAKER channelMask = SPEAKER.FrontLeft | SPEAKER.FrontRight;
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddFilter("Momiji", LogLevel.Debug);
builder.AddFilter("Microsoft", LogLevel.Warning);
builder.AddFilter("System", LogLevel.Warning);
builder.AddConsole();
builder.AddDebug();
});
var counter = new ElapsedTimeCounter();
using var pcmPool = new BufferPool <PcmBuffer <short> >(1, () => new PcmBuffer <short>(blockSize, 1), loggerFactory);
{
try
{
using var test = new WaveOutShort(deviceID, channels, samplingRate, channelMask, loggerFactory, counter, pcmPool);
test.Execute(pcmPool.Receive(), default);
}
catch (WaveException)
{
}
}
}
public void Test1()
{
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddFilter("Momiji", LogLevel.Debug);
builder.AddFilter("Microsoft", LogLevel.Warning);
builder.AddFilter("System", LogLevel.Warning);
builder.AddConsole();
builder.AddDebug();
});
var log = loggerFactory.CreateLogger("WaiterTest");
var counter = new ElapsedTimeCounter();
var start = counter.NowTicks;
var sample = 1;
var interval = 10_000 * sample;
var list = new List <(int, long, double, double)>();
using var waiter = new Waiter(counter, interval, true);
counter.Reset();
for (int i = 0; i < 100; i++)
{
var before = counter.NowTicks - start;
var r = waiter.Wait();
var after = counter.NowTicks - start;
while (--r > 1)
{
list.Add((i++, default, default, default));
public WaveOut(
int deviceID,
short channels,
int samplesPerSecond,
SPEAKER channelMask,
Guid formatSubType,
ILoggerFactory loggerFactory,
ElapsedTimeCounter counter,
ITargetBlock <PcmBuffer <T> > releaseQueue
)
{
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_counter = counter ?? throw new ArgumentNullException(nameof(counter));
ArgumentNullException.ThrowIfNull(releaseQueue);
_logger = _loggerFactory.CreateLogger <WaveOut <T> >();
_headerPool = new BufferPool <WaveHeaderBuffer>(1, () => { return(new WaveHeaderBuffer()); }, _loggerFactory);
_driverCallBack = new PinnedDelegate <DriverCallBack.Proc>(new DriverCallBack.Proc(DriverCallBackProc));
var format = new WaveFormatExtensible();
format.wfe.formatType = WaveFormatEx.FORMAT.EXTENSIBLE;
format.wfe.channels = (ushort)channels;
format.wfe.samplesPerSecond = (uint)samplesPerSecond;
format.wfe.bitsPerSample = (ushort)(SIZE_OF_T * 8);
format.wfe.blockAlign = (ushort)(format.wfe.channels * format.wfe.bitsPerSample / 8);
format.wfe.averageBytesPerSecond = format.wfe.samplesPerSecond * format.wfe.blockAlign;
format.wfe.size = (ushort)(Marshal.SizeOf <WaveFormatExtensiblePart>());
format.exp.validBitsPerSample = format.wfe.bitsPerSample;
format.exp.channelMask = ToSPEAKER(channelMask);
format.exp.subFormat = formatSubType;
//たまに失敗するので、ピン止めしておく
using var formatPin = new PinnedBuffer <WaveFormatExtensible>(format);
var mmResult =
NativeMethods.waveOutOpen(
out _handle,
deviceID,
ref format,
_driverCallBack.FunctionPointer,
IntPtr.Zero,
(
DriverCallBack.TYPE.FUNCTION
| DriverCallBack.TYPE.WAVE_FORMAT_DIRECT
)
);
if (mmResult != MMRESULT.NOERROR)
{
throw new WaveException(mmResult);
}
_releaseAction = new TransformBlock <IntPtr, PcmBuffer <T> >(headerPtr => Unprepare(headerPtr));
_releaseAction.LinkTo(releaseQueue);
}
public ToPcm(
ILoggerFactory loggerFactory,
ElapsedTimeCounter counter
)
{
ArgumentNullException.ThrowIfNull(loggerFactory);
ArgumentNullException.ThrowIfNull(counter);
_logger = loggerFactory.CreateLogger <ToPcm <T> >();
_counter = counter;
}
public WaveOutShort(
int deviceID,
short channels,
int samplesPerSecond,
SPEAKER channelMask,
ILoggerFactory loggerFactory,
ElapsedTimeCounter counter,
ITargetBlock <PcmBuffer <short> > sourceReleaseQueue
) : base(
deviceID,
channels,
samplesPerSecond,
channelMask,
new Guid("00000001-0000-0010-8000-00aa00389b71"),
loggerFactory,
counter,
sourceReleaseQueue
)
{
}
public void Test1()
{
var configuration =
new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddFilter("Momiji", LogLevel.Debug);
builder.AddFilter("Microsoft", LogLevel.Warning);
builder.AddFilter("System", LogLevel.Warning);
builder.AddConsole();
builder.AddDebug();
});
var counter = new ElapsedTimeCounter();
using var dllManager = new DllManager(configuration, loggerFactory);
using var opus = new OpusEncoder(SamplingRate.Sampling48000, Channels.Stereo, loggerFactory, counter);
}
public Waiter(ElapsedTimeCounter counter, long intervalTicks, bool highResolution)
{
_counter = counter ?? throw new ArgumentNullException(nameof(counter));
if (intervalTicks < 0)
{
throw new ArgumentOutOfRangeException(nameof(intervalTicks));
}
_intervalTicks = intervalTicks;
_handle =
NativeMethods.CreateWaitableTimerEx(
IntPtr.Zero,
IntPtr.Zero,
WaitableTimer.FLAGS.MANUAL_RESET | (highResolution ? WaitableTimer.FLAGS.HIGH_RESOLUTION : 0),
WaitableTimer.ACCESSES.SYNCHRONIZE | WaitableTimer.ACCESSES.TIMER_ALL_ACCESS
);
if (_handle.IsInvalid)
{
throw new TimerException($"CreateWaitableTimerEx failed [{Marshal.GetLastWin32Error()}]");
}
Reset();
}
public void Test1()
{
var configuration =
new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddFilter("Momiji", LogLevel.Debug);
builder.AddFilter("Microsoft", LogLevel.Warning);
builder.AddFilter("System", LogLevel.Warning);
builder.AddConsole();
builder.AddDebug();
});
var logger = loggerFactory.CreateLogger <VstUnitTest>();
using var dllManager = new DllManager(configuration, loggerFactory);
var counter = new ElapsedTimeCounter();
var blockSize = 2880;
var midiEventInput = new BufferBlock <MIDIMessageEvent2>();
using var buffer = new VstBuffer <double>(blockSize, 2);
using var vst = new AudioMaster <double>(48000, blockSize, loggerFactory, counter, dllManager);
var effect = vst.AddEffect("Dexed.dll");
var effect2 = vst.AddEffect("Synth1 VST.dll");
//var aeffect = effect.GetAEffect();
//for (int i = 0; i < 1/*aeffect.numParams*/; i++)
//{
// var label = effect.GetParameterLabel(i);
// var name = effect.GetParameterName(i);
// var display = effect.GetParameterDisplay(i);
// var value = effect.GetParameter(i);
// logger.LogInformation($"VST Parameter {i}:{label}:{name}:{display}:{value}");
//}
{
var nowTime = counter.NowTicks / 10;
midiEventInput.Post(new MIDIMessageEvent2()
{
midiMessageEvent =
{
receivedTime = nowTime,
data0 = 0x90,
data1 = 0x20,
data2 = 0x40,
data3 = 0
},
receivedTimeUSec = nowTime
});
midiEventInput.Post(new MIDIMessageEvent2()
{
midiMessageEvent =
{
receivedTime = nowTime,
data0 = 0x90,
data1 = 0x21,
data2 = 0x40,
data3 = 0
},
receivedTimeUSec = nowTime
});
effect.ProcessEvent(nowTime, midiEventInput);
effect.ProcessReplacing(nowTime, buffer);
}
{
var nowTime = counter.NowTicks / 10;
midiEventInput.Post(new MIDIMessageEvent2()
{
midiMessageEvent =
{
receivedTime = nowTime,
data0 = 0x90,
data1 = 0x30,
data2 = 0x40,
data3 = 0
},
receivedTimeUSec = nowTime
});
effect.ProcessEvent(nowTime, midiEventInput);
effect.ProcessReplacing(nowTime, buffer);
}
{
var nowTime = counter.NowTicks / 10;
midiEventInput.Post(new MIDIMessageEvent2()
{
midiMessageEvent =
{
receivedTime = nowTime,
data0 = 0x90,
data1 = 0x40,
data2 = 0x40,
data3 = 0
},
receivedTimeUSec = nowTime
});
effect.ProcessEvent(nowTime, midiEventInput);
effect.ProcessReplacing(nowTime, buffer);
}
{
var nowTime = counter.NowTicks / 10;
midiEventInput.Post(new MIDIMessageEvent2()
{
midiMessageEvent =
{
receivedTime = nowTime,
data0 = 0x90,
data1 = 0x50,
data2 = 0x40,
data3 = 0
},
receivedTimeUSec = nowTime
});
effect.ProcessEvent(nowTime, midiEventInput);
effect.ProcessReplacing(nowTime, buffer);
}
}
private async Task RunLocal()
{
var ct = ProcessCancel.Token;
var taskSet = new HashSet <Task>();
var blockSize = (int)(Param.SamplingRate * Param.SampleLength);
Logger.LogInformation($"[loop5] blockSize {blockSize}");
var audioInterval = (long)(10_000_000.0 * Param.SampleLength);
Logger.LogInformation($"[loop5] audioInterval {audioInterval}");
var videoInterval = (long)(10_000_000.0 / Param.MaxFrameRate);
Logger.LogInformation($"[loop5] videoInterval {videoInterval}");
var counter = new ElapsedTimeCounter();
using var audioWaiter = new Waiter(counter, audioInterval);
using var videoWaiter = new Waiter(counter, videoInterval);
using var buf = new IPCBuffer <float>(Param.EffectName, blockSize * 2 * Param.BufferCount, LoggerFactory);
using var vstBufferPool = new BufferPool <VstBuffer2 <float> >(Param.BufferCount, () => new VstBuffer2 <float>(blockSize, 2, buf), LoggerFactory);
using var pcmPool = new BufferPool <PcmBuffer <float> >(Param.BufferCount, () => new PcmBuffer <float>(blockSize, 2), LoggerFactory);
using var audioPool = new BufferPool <OpusOutputBuffer>(Param.BufferCount, () => new OpusOutputBuffer(5000), LoggerFactory);
using var pcmDrowPool = new BufferPool <PcmBuffer <float> >(Param.BufferCount, () => new PcmBuffer <float>(blockSize, 2), LoggerFactory);
using var bmpPool = new BufferPool <H264InputBuffer>(Param.BufferCount, () => new H264InputBuffer(Param.Width, Param.Height), LoggerFactory);
using var videoPool = new BufferPool <H264OutputBuffer>(Param.BufferCount, () => new H264OutputBuffer(200000), LoggerFactory);
using var vst = new AudioMaster <float>(Param.SamplingRate, blockSize, LoggerFactory, counter, DllManager);
using var toPcm = new ToPcm <float>(LoggerFactory, counter);
using var opus = new OpusEncoder(SamplingRate.Sampling48000, Channels.Stereo, LoggerFactory, counter);
using var fft = new FFTEncoder(Param.Width, Param.Height, Param.MaxFrameRate, LoggerFactory, counter);
using var h264 = new H264Encoder(Param.Width, Param.Height, Param.TargetBitrate, Param.MaxFrameRate, LoggerFactory, counter);
var effect = vst.AddEffect(Param.EffectName);
var options = new ExecutionDataflowBlockOptions
{
CancellationToken = ct,
MaxDegreeOfParallelism = 1,
MaxMessagesPerTask = DataflowBlockOptions.Unbounded
};
{
var audioBlock =
new ActionBlock <VstBuffer2 <float> >(async buffer =>
{
var pcmTask = pcmPool.ReceiveAsync(ct);
var audioTask = audioPool.ReceiveAsync(ct);
buffer.Log.Clear();
audioWaiter.Wait();
buffer.Log.Add("[audio] start", counter.NowTicks);
//VST
var nowTime = counter.NowTicks / 10;
effect.ProcessEvent(nowTime, MidiEventInput);
effect.ProcessReplacing(nowTime, buffer);
//trans
var pcm = await pcmTask.ConfigureAwait(false);
buffer.Log.Add("[audio] opus input get", counter.NowTicks);
toPcm.Execute(buffer, pcm);
vstBufferPool.Post(buffer);
var audio = await audioTask.ConfigureAwait(false);
pcm.Log.Add("[audio] opus output get", counter.NowTicks);
opus.Execute(pcm, audio);
pcmDrowPool.Post(pcm);
//FTL
// ftl.Execute(audio);
audioPool.Post(audio);
}, options);
taskSet.Add(audioBlock.Completion);
vstBufferPool.LinkTo(audioBlock);
}
{
var midiDataStoreBlock =
new ActionBlock <MIDIMessageEvent2>(buffer =>
{
fft.Receive(buffer);
}, options);
taskSet.Add(midiDataStoreBlock.Completion);
MidiEventOutput.LinkTo(midiDataStoreBlock);
var pcmDataStoreBlock =
new ActionBlock <PcmBuffer <float> >(buffer =>
{
fft.Receive(buffer);
pcmPool.Post(buffer);
}, options);
taskSet.Add(pcmDataStoreBlock.Completion);
pcmDrowPool.LinkTo(pcmDataStoreBlock);
var intraFrameCount = 0.0;
var videoBlock =
new ActionBlock <H264InputBuffer>(async buffer =>
{
var videoTask = videoPool.ReceiveAsync(ct);
buffer.Log.Clear();
videoWaiter.Wait();
buffer.Log.Add("[video] start", counter.NowTicks);
//FFT
fft.Execute(buffer);
//H264
var video = await videoTask.ConfigureAwait(false);
buffer.Log.Add("[video] h264 output get", counter.NowTicks);
var insertIntraFrame = (intraFrameCount <= 0);
h264.Execute(buffer, video, insertIntraFrame);
bmpPool.Post(buffer);
if (insertIntraFrame)
{
intraFrameCount = Param.IntraFrameIntervalUs;
}
intraFrameCount -= videoInterval;
//FTL
//ftl.Execute(video);
videoPool.Post(video);
}, options);
taskSet.Add(videoBlock.Completion);
bmpPool.LinkTo(videoBlock);
}
while (taskSet.Count > 0)
{
var task = await Task.WhenAny(taskSet).ConfigureAwait(false);
taskSet.Remove(task);
if (task.IsFaulted)
{
ProcessCancel.Cancel();
Logger.LogError(task.Exception, "Process Exception");
}
}
}
public H264Encoder(
int picWidth,
int picHeight,
int targetBitrate,
float maxFrameRate,
ILoggerFactory loggerFactory,
ElapsedTimeCounter counter
)
{
ArgumentNullException.ThrowIfNull(loggerFactory);
ArgumentNullException.ThrowIfNull(counter);
_logger = loggerFactory.CreateLogger <H264Encoder>();
_counter = counter;
_picWidth = picWidth;
_picHeight = picHeight;
_targetBitrate = targetBitrate;
_maxFrameRate = maxFrameRate;
{
NativeMethods.WelsGetCodecVersionEx(out var version);
_logger.LogInformation($"[h264] version {version.uMajor}.{version.uMinor}.{version.uReserved}.{version.uRevision}");
}
{
var result = NativeMethods.WelsCreateSVCEncoder(out var handle);
if (result != 0)
{
throw new H264Exception($"WelsCreateSVCEncoder failed {result}");
}
_encoder = handle;
}
var temp = Marshal.PtrToStructure <IntPtr>(_encoder.DangerousGetHandle());
var vtbl = Marshal.PtrToStructure <ISVCEncoderVtbl>(temp);
//if (vtbl.Initialize != IntPtr.Zero)
{
Initialize =
Marshal.GetDelegateForFunctionPointer <ISVCEncoderVtbl.InitializeProc>(vtbl.Initialize);
}
//if (vtbl.GetDefaultParams != IntPtr.Zero)
{
GetDefaultParams =
Marshal.GetDelegateForFunctionPointer <ISVCEncoderVtbl.GetDefaultParamsProc>(vtbl.GetDefaultParams);
}
//if (vtbl.Uninitialize != IntPtr.Zero)
{
Uninitialize =
Marshal.GetDelegateForFunctionPointer <ISVCEncoderVtbl.UninitializeProc>(vtbl.Uninitialize);
}
//if (vtbl.EncodeFrame != IntPtr.Zero)
{
EncodeFrame =
Marshal.GetDelegateForFunctionPointer <ISVCEncoderVtbl.EncodeFrameProc>(vtbl.EncodeFrame);
}
//if (vtbl.EncodeParameterSets != IntPtr.Zero)
{
EncodeParameterSets =
Marshal.GetDelegateForFunctionPointer <ISVCEncoderVtbl.EncodeParameterSetsProc>(vtbl.EncodeParameterSets);
}
//if (vtbl.ForceIntraFrame != IntPtr.Zero)
{
ForceIntraFrame =
Marshal.GetDelegateForFunctionPointer <ISVCEncoderVtbl.ForceIntraFrameProc>(vtbl.ForceIntraFrame);
}
//if (vtbl.SetOption != IntPtr.Zero)
{
SetOption =
Marshal.GetDelegateForFunctionPointer <ISVCEncoderVtbl.SetOptionProc>(vtbl.SetOption);
}
//if (vtbl.GetOption != IntPtr.Zero)
{
GetOption =
Marshal.GetDelegateForFunctionPointer <ISVCEncoderVtbl.GetOptionProc>(vtbl.GetOption);
}
using (var param = new PinnedBuffer <SEncParamBase>(new SEncParamBase()))
{
param.Target.iUsageType = EUsageType.CAMERA_VIDEO_REAL_TIME;
param.Target.iPicWidth = _picWidth;
param.Target.iPicHeight = _picHeight;
param.Target.iTargetBitrate = _targetBitrate;
param.Target.iRCMode = RC_MODES.RC_QUALITY_MODE;
param.Target.fMaxFrameRate = _maxFrameRate;
var result = Initialize(_encoder, param.AddrOfPinnedObject);
if (result != 0)
{
throw new H264Exception($"WelsCreateSVCEncoder Initialize failed {result}");
}
}
//using (var param = new PinnedBuffer<WELS_LOG>(WELS_LOG.WELS_LOG_WARNING))
using (var param = new PinnedBuffer <int>(1 << 1))
{
SetOption(_encoder, ENCODER_OPTION.ENCODER_OPTION_TRACE_LEVEL, param.AddrOfPinnedObject);
}
/*
* welsTraceCallback = new PinnedDelegate<WelsTraceCallback>(TraceCallBack);
* SetOption(Encoder, ENCODER_OPTION.ENCODER_OPTION_TRACE_CALLBACK, welsTraceCallback.FunctionPointer);
*/
_sFrameBSInfoBuffer = new SFrameBSInfoBuffer();
}
private const int COUNT_OF_EVENTS = 500; //サイズが適当
internal Effect(
string library,
AudioMaster <T> audioMaster,
ILoggerFactory loggerFactory,
ElapsedTimeCounter counter
)
{
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_counter = counter ?? throw new ArgumentNullException(nameof(counter));
_logger = _loggerFactory.CreateLogger <Effect <T> >();
_audioMaster = audioMaster;
//TODO IPCBufferにする
_events = new(new byte[SIZE_OF_VSTEVENTS + (SIZE_OF_INTPTR * COUNT_OF_EVENTS)]);
_eventList = new(new byte[SIZE_OF_VSTMIDIEVENT * COUNT_OF_EVENTS]);
var vstPluginMain = _audioMaster.DllManager.GetExport <AEffect.VSTPluginMain>(library, "VSTPluginMain");
if (vstPluginMain == default)
{
vstPluginMain = _audioMaster.DllManager.GetExport <AEffect.VSTPluginMain>(library, "main");
}
if (vstPluginMain == default)
{
throw new VstException("VSTPluginMainが取得できない");
}
_audioMasterCallBack = new(new(_audioMaster.AudioMasterCallBackProc));
_aeffectPtr = vstPluginMain(_audioMasterCallBack.FunctionPointer);
if (_aeffectPtr == default)
{
throw new VstException("vstPluginMain で失敗");
}
var aeffect = GetAEffect();
_logger.LogInformation($"magic:{aeffect.magic}");
_logger.LogInformation($"dispatcher:{aeffect.dispatcher}");
_logger.LogInformation($"processDeprecated:{aeffect.processDeprecated}");
_logger.LogInformation($"setParameter:{aeffect.setParameter}");
_logger.LogInformation($"getParameter:{aeffect.getParameter}");
_logger.LogInformation($"numPrograms:{aeffect.numPrograms}");
_logger.LogInformation($"numParams:{aeffect.numParams}");
_logger.LogInformation($"numInputs:{aeffect.numInputs}");
_logger.LogInformation($"numOutputs:{aeffect.numOutputs}");
_logger.LogInformation($"flags:{aeffect.flags}");
//Logger.LogInformation($"resvd1:"+aeffect.resvd1);
//Logger.LogInformation($"resvd2:"+aeffect.resvd2);
_logger.LogInformation($"initialDelay:{aeffect.initialDelay}");
_logger.LogInformation($"realQualitiesDeprecated:{aeffect.realQualitiesDeprecated}");
_logger.LogInformation($"offQualitiesDeprecated:{aeffect.offQualitiesDeprecated}");
_logger.LogInformation($"ioRatioDeprecated:{aeffect.ioRatioDeprecated}");
//Logger.LogInformation($"object:"+aeffect._object);
_logger.LogInformation($"user:{aeffect.user}");
_logger.LogInformation($"uniqueID:{aeffect.uniqueID}");
_logger.LogInformation($"version:{aeffect.version}");
_logger.LogInformation("processReplacing:" + aeffect.processReplacing);
_logger.LogInformation("processDoubleReplacing:" + aeffect.processDoubleReplacing);
if (aeffect.dispatcher != default)
{
_dispatcherProc =
Marshal.GetDelegateForFunctionPointer <AEffect.DispatcherProc>(aeffect.dispatcher);
}
if (aeffect.setParameter != default)
{
_setParameterProc =
Marshal.GetDelegateForFunctionPointer <AEffect.SetParameterProc>(aeffect.setParameter);
}
if (aeffect.getParameter != default)
{
_getParameterProc =
Marshal.GetDelegateForFunctionPointer <AEffect.GetParameterProc>(aeffect.getParameter);
}
if (SIZE_OF_T == 4)
{
if (aeffect.processReplacing != default)
{
_processProc =
Marshal.GetDelegateForFunctionPointer <AEffect.ProcessProc>(aeffect.processReplacing);
}
else
{
throw new VstException("processReplacing が無い");
}
}
else
{
if (aeffect.processDoubleReplacing != default)
{
_processProc =
Marshal.GetDelegateForFunctionPointer <AEffect.ProcessProc>(aeffect.processDoubleReplacing);
}
else
{
throw new VstException("processDoubleReplacing が無い");
}
}
Open();
_beforeTime = _counter.NowTicks;
_audioMaster.EffectMap.Add(_aeffectPtr, this);
}
public Waiter(ElapsedTimeCounter counter, long intervalTicks) : this(counter, intervalTicks, false)
{
}
