test
| Revision | 62d57e3eadfd1eb7e8eb1593eb89baa6e7e786b6 (tree) |
|---|---|
| Time | 2012-04-23 19:26:46 |
| Author | tyiki badwell <miria@user...> |
| Commiter | tyiki badwell |
送信元バッファに使用サイズの指定をできるようにした(インタフェースは後でまとめる)
| @@ -101,17 +101,27 @@ namespace Buffer { | ||
| 101 | 101 | } |
| 102 | 102 | |
| 103 | 103 | generic<typename HEADER_TYPE, typename DATA_TYPE> |
| 104 | - void HeaderPool<HEADER_TYPE, DATA_TYPE>::Header::Reset(array<DATA_TYPE>^ data) | |
| 104 | + void HeaderPool<HEADER_TYPE, DATA_TYPE>::Header::Reset(array<DATA_TYPE>^ data, System::UInt32 useSize) | |
| 105 | 105 | { |
| 106 | - #ifdef _DEBUG | |
| 107 | - System::Console::WriteLine("[{0}][this length:{1}][data length:{2}]",__FUNCTION__, this->_buffer->Length, data->Length); | |
| 108 | - #endif | |
| 106 | + // #ifdef _DEBUG | |
| 107 | + // System::Console::WriteLine("[{0}][this length:{1}][data length:{2}][use length:{3}]",__FUNCTION__, this->_buffer->Length, data->Length, useSize); | |
| 108 | + // #endif | |
| 109 | + | |
| 110 | + if (useSize > data->Length) { | |
| 111 | + throw gcnew HeaderException("データバッファサイズと使用サイズの関係がおかしい [データバッファサイズ:" + data->Length.ToString("D") + "][使用サイズ:" + useSize.ToString("D") + "]"); | |
| 112 | + } | |
| 113 | + | |
| 114 | + //確保していたバッファを超えていたら、後半は打ち切り | |
| 115 | + if (useSize > this->_buffer->Length) { | |
| 116 | + System::Console::WriteLine("[{0}] drop size[{1}]",__FUNCTION__, useSize - this->_buffer->Length); | |
| 117 | + useSize = this->_buffer->Length; | |
| 118 | + } | |
| 109 | 119 | |
| 110 | - System::Array::Copy(data, this->_buffer, data->Length); //確保していたバッファを超えていたら、ココでエラーになることを期待して、長さチェックはしないことにしておく | |
| 120 | + System::Array::Copy(data, this->_buffer, useSize); | |
| 111 | 121 | |
| 112 | 122 | System::Object^ header = |
| 113 | 123 | this->_headerInitializer( |
| 114 | - InteropServices::Marshal::SizeOf(DATA_TYPE::typeid) * data->Length, | |
| 124 | + InteropServices::Marshal::SizeOf(DATA_TYPE::typeid) * useSize, | |
| 115 | 125 | this->_bufferHandle.AddrOfPinnedObject() |
| 116 | 126 | ); |
| 117 | 127 |
| @@ -62,7 +62,7 @@ namespace Buffer { | ||
| 62 | 62 | |
| 63 | 63 | public: |
| 64 | 64 | System::IntPtr GetHeaderIntPtr(); |
| 65 | - void Reset(array<DATA_TYPE>^ data); | |
| 65 | + void Reset(array<DATA_TYPE>^ data, System::UInt32 useSize); | |
| 66 | 66 | |
| 67 | 67 | HEADER_TYPE ToHeader(); |
| 68 | 68 |
| @@ -99,6 +99,15 @@ namespace Buffer { | ||
| 99 | 99 | |
| 100 | 100 | }; |
| 101 | 101 | |
| 102 | + public ref class HeaderException | |
| 103 | + : public System::Exception | |
| 104 | + { | |
| 105 | + public: | |
| 106 | + HeaderException(System::String^ v): System::Exception(v){}; | |
| 107 | + virtual ~HeaderException(void){}; | |
| 108 | + }; | |
| 109 | + | |
| 110 | + | |
| 102 | 111 | } |
| 103 | 112 | } |
| 104 | 113 | } |
| @@ -103,15 +103,18 @@ namespace Midi { | ||
| 103 | 103 | { |
| 104 | 104 | private: |
| 105 | 105 | initonly array<System::Byte>^ _longData; |
| 106 | + initonly System::UInt32 _useSize; | |
| 106 | 107 | |
| 107 | 108 | public: |
| 108 | 109 | LongData( |
| 109 | 110 | System::UInt64 tick, |
| 110 | 111 | System::UInt16 port, |
| 111 | - array<System::Byte>^ longData | |
| 112 | - ): MidiData(tick, port), _longData(longData) {} | |
| 112 | + array<System::Byte>^ longData, | |
| 113 | + System::UInt32 useSize | |
| 114 | + ): MidiData(tick, port), _longData(longData), _useSize(useSize) {} | |
| 113 | 115 | |
| 114 | 116 | property array<System::Byte>^ longData { array<System::Byte>^ get() {return this->_longData;} } |
| 117 | + property System::UInt32 useSize { System::UInt32 get() { return this->_useSize; } } | |
| 115 | 118 | }; |
| 116 | 119 | |
| 117 | 120 | } |
| @@ -272,7 +272,7 @@ namespace Out { | ||
| 272 | 272 | } |
| 273 | 273 | |
| 274 | 274 | void Device::SendLong( |
| 275 | - array<System::Byte>^ data | |
| 275 | + array<System::Byte>^ data, System::UInt32 useSize | |
| 276 | 276 | ) |
| 277 | 277 | { |
| 278 | 278 | #ifdef _DEBUG |
| @@ -298,7 +298,7 @@ namespace Out { | ||
| 298 | 298 | return; |
| 299 | 299 | } |
| 300 | 300 | |
| 301 | - System::IntPtr headerPtr = this->Prepare(data); | |
| 301 | + System::IntPtr headerPtr = this->Prepare(data, useSize); | |
| 302 | 302 | |
| 303 | 303 | auto mmResult = |
| 304 | 304 | Interop::Winmm::Function::midiOutLongMsg( |
| @@ -313,7 +313,7 @@ namespace Out { | ||
| 313 | 313 | } |
| 314 | 314 | } |
| 315 | 315 | |
| 316 | - System::IntPtr Device::Prepare(array<System::Byte>^ data) | |
| 316 | + System::IntPtr Device::Prepare(array<System::Byte>^ data, System::UInt32 useSize) | |
| 317 | 317 | { |
| 318 | 318 | #ifdef _DEBUG |
| 319 | 319 | System::Console::WriteLine("[{0}]",__FUNCTION__); |
| @@ -322,7 +322,7 @@ namespace Out { | ||
| 322 | 322 | Core::Buffer::HeaderPool<Interop::Winmm::MidiHeader, System::Byte>::Header^ header = |
| 323 | 323 | this->_headerPool->Get(); |
| 324 | 324 | |
| 325 | - header->Reset(data); | |
| 325 | + header->Reset(data, useSize); | |
| 326 | 326 | |
| 327 | 327 | auto mmResult = |
| 328 | 328 | Interop::Winmm::Function::midiOutPrepareHeader( |
| @@ -489,7 +489,7 @@ namespace Out { | ||
| 489 | 489 | Core::Midi::LongData^ longData = dynamic_cast<Core::Midi::LongData^>(midiData); |
| 490 | 490 | if (longData != nullptr) |
| 491 | 491 | { |
| 492 | - d->SendLong(longData->longData); | |
| 492 | + d->SendLong(longData->longData, longData->longData->Length); | |
| 493 | 493 | return; |
| 494 | 494 | } |
| 495 | 495 |
| @@ -49,7 +49,7 @@ namespace Out { | ||
| 49 | 49 | !Device(); |
| 50 | 50 | |
| 51 | 51 | private: |
| 52 | - System::IntPtr Prepare(array<System::Byte>^ data); | |
| 52 | + System::IntPtr Prepare(array<System::Byte>^ data, System::UInt32 useSize); | |
| 53 | 53 | void Unprepare(System::IntPtr headerPtr); |
| 54 | 54 | |
| 55 | 55 | Interop::Winmm::MidiHeader InitializeHeader(System::UInt32 bufferLength, System::IntPtr bufferPtr); |
| @@ -65,7 +65,7 @@ namespace Out { | ||
| 65 | 65 | |
| 66 | 66 | public: |
| 67 | 67 | void SendShort(System::UInt32 dwMsg); |
| 68 | - void SendLong(array<System::Byte>^ data); | |
| 68 | + void SendLong(array<System::Byte>^ data, System::UInt32 useSize); | |
| 69 | 69 | |
| 70 | 70 | public: |
| 71 | 71 | event System::EventHandler<System::EventArgs^>^ OnOpen; |
| @@ -37,20 +37,24 @@ namespace Wave { | ||
| 37 | 37 | : public Core::IData |
| 38 | 38 | { |
| 39 | 39 | private: |
| 40 | - System::UInt16 _port; | |
| 41 | - array<T>^ _data; | |
| 40 | + initonly System::UInt16 _port; | |
| 41 | + initonly array<T>^ _data; | |
| 42 | + initonly System::UInt32 _useSize; | |
| 42 | 43 | |
| 43 | 44 | public: |
| 44 | 45 | WaveData( |
| 45 | 46 | System::UInt16 port, |
| 46 | - array<T>^ data | |
| 47 | - ): _port(port), _data(data) {} | |
| 47 | + array<T>^ data, | |
| 48 | + System::UInt32 useSize | |
| 49 | + ): _port(port), _data(data), _useSize(useSize) {} | |
| 48 | 50 | |
| 49 | 51 | public: |
| 50 | 52 | property System::UInt16 port { System::UInt16 get() {return this->_port;} } |
| 51 | 53 | property array<T>^ data { array<T>^ get() {return this->_data;} } |
| 54 | + property System::UInt32 useSize { System::UInt32 get() { return this->_useSize; } } | |
| 52 | 55 | }; |
| 53 | 56 | |
| 57 | + | |
| 54 | 58 | } |
| 55 | 59 | } |
| 56 | 60 | } |
| @@ -299,7 +299,7 @@ namespace Out { | ||
| 299 | 299 | |
| 300 | 300 | //TODO 要同期 |
| 301 | 301 | generic<typename T> |
| 302 | - System::IntPtr Device<T>::Prepare(array<T>^ data) | |
| 302 | + System::IntPtr Device<T>::Prepare(array<T>^ data, System::UInt32 useSize) | |
| 303 | 303 | { |
| 304 | 304 | #ifdef _DEBUG |
| 305 | 305 | System::Console::WriteLine("[{0}]",__FUNCTION__); |
| @@ -308,7 +308,7 @@ namespace Out { | ||
| 308 | 308 | Core::Buffer::HeaderPool<Interop::Winmm::WaveHeader, T>::Header^ header = |
| 309 | 309 | this->_headerPool->Get(); |
| 310 | 310 | |
| 311 | - header->Reset(data); | |
| 311 | + header->Reset(data, useSize); | |
| 312 | 312 | |
| 313 | 313 | auto mmResult = |
| 314 | 314 | Interop::Winmm::Function::waveOutPrepareHeader( |
| @@ -376,7 +376,7 @@ namespace Out { | ||
| 376 | 376 | |
| 377 | 377 | generic<typename T> |
| 378 | 378 | void Device<T>::Send( |
| 379 | - array<T>^ data | |
| 379 | + array<T>^ data, System::UInt32 useSize | |
| 380 | 380 | ) |
| 381 | 381 | { |
| 382 | 382 | #ifdef _DEBUG |
| @@ -396,7 +396,7 @@ namespace Out { | ||
| 396 | 396 | |
| 397 | 397 | //TODO 長かったら分割して送信する |
| 398 | 398 | |
| 399 | - System::IntPtr headerPtr = this->Prepare(data); | |
| 399 | + System::IntPtr headerPtr = this->Prepare(data, useSize); | |
| 400 | 400 | |
| 401 | 401 | auto mmResult = |
| 402 | 402 | Interop::Winmm::Function::waveOutWrite( |
| @@ -528,7 +528,7 @@ namespace Out { | ||
| 528 | 528 | } |
| 529 | 529 | |
| 530 | 530 | Device<T>^ d = this->_outs[p]; |
| 531 | - d->Send(waveData->data); | |
| 531 | + d->Send(waveData->data, waveData->useSize); | |
| 532 | 532 | } |
| 533 | 533 | |
| 534 | 534 | } |
| @@ -66,7 +66,7 @@ namespace Out { | ||
| 66 | 66 | !Device(); |
| 67 | 67 | |
| 68 | 68 | private: |
| 69 | - System::IntPtr Prepare(array<T>^ data); | |
| 69 | + System::IntPtr Prepare(array<T>^ data, System::UInt32 useSize); | |
| 70 | 70 | void Unprepare(System::IntPtr headerPtr); |
| 71 | 71 | |
| 72 | 72 | Interop::Winmm::WaveHeader InitializeHeader(System::UInt32 bufferLength, System::IntPtr bufferPtr); |
| @@ -81,7 +81,7 @@ namespace Out { | ||
| 81 | 81 | void Close(); |
| 82 | 82 | |
| 83 | 83 | public: |
| 84 | - void Send(array<T>^ data); | |
| 84 | + void Send(array<T>^ data, System::UInt32 useSize); | |
| 85 | 85 | |
| 86 | 86 | public: |
| 87 | 87 | event System::EventHandler<System::EventArgs^>^ OnOpen; |
| @@ -159,6 +159,13 @@ namespace Smf { | ||
| 159 | 159 | } |
| 160 | 160 | } |
| 161 | 161 | |
| 162 | + //TODO: packetにIComparerを実装してもSortで反応してくれなかったので、仕方なくコレで。 | |
| 163 | + int IStreamPacketCompare(Core::IStreamPacket^ a, Core::IStreamPacket^ b) | |
| 164 | + { | |
| 165 | + //TODO: RPN・NRPNの塊は維持したままソートしないとダメだった | |
| 166 | + return a->tick.CompareTo(b->tick); | |
| 167 | + } | |
| 168 | + | |
| 162 | 169 | array<Core::IStreamPacket^>^ SmfStream::GetStreamPacket(System::Double deltaTime) |
| 163 | 170 | { |
| 164 | 171 | #ifdef _DEBUG |
| @@ -173,6 +180,8 @@ namespace Smf { | ||
| 173 | 180 | result->AddRange(data); |
| 174 | 181 | } |
| 175 | 182 | |
| 183 | + // result->Sort(gcnew System::Comparison<Core::IStreamPacket^>(IStreamPacketCompare)); | |
| 184 | + | |
| 176 | 185 | return result->ToArray(); |
| 177 | 186 | } |
| 178 | 187 |
| @@ -355,7 +364,8 @@ namespace Smf { | ||
| 355 | 364 | gcnew Core::Midi::LongData( |
| 356 | 365 | this->_tick, |
| 357 | 366 | metaPort->number, |
| 358 | - longData | |
| 367 | + longData, | |
| 368 | + longData->Length | |
| 359 | 369 | ); |
| 360 | 370 | break; |
| 361 | 371 | } |
| @@ -141,7 +141,8 @@ namespace MomijiTestSequencerWave { | ||
| 141 | 141 | private: |
| 142 | 142 | void OnDone(System::Object^ sender, System::EventArgs^ args) |
| 143 | 143 | { |
| 144 | - o->Send(s->Read(this->_samplesPerBuffer)); | |
| 144 | + auto data = s->Read(this->_samplesPerBuffer); | |
| 145 | + o->Send(data, data->Length); | |
| 145 | 146 | } |
| 146 | 147 | |
| 147 | 148 | public: |
| @@ -170,9 +171,11 @@ namespace MomijiTestSequencerWave { | ||
| 170 | 171 | |
| 171 | 172 | o->OnDone += gcnew System::EventHandler<System::EventArgs^>(this, &TestWave::OnDone); |
| 172 | 173 | |
| 174 | + //このやり方は、周ってる間にOnDoneが発生して順番が崩れるかも? | |
| 173 | 175 | for (auto i = 0; i < count; i++) |
| 174 | 176 | { |
| 175 | - o->Send(s->Read(this->_samplesPerBuffer)); | |
| 177 | + auto data = s->Read(this->_samplesPerBuffer); | |
| 178 | + o->Send(data, data->Length); | |
| 176 | 179 | } |
| 177 | 180 | |
| 178 | 181 | } |
| @@ -13,8 +13,76 @@ private: | ||
| 13 | 13 | Momiji::Core::IStream^ _stream; |
| 14 | 14 | Momiji::Core::IOut^ _out; |
| 15 | 15 | |
| 16 | - Momiji::Core::Vst::Host::Master^ _host; | |
| 16 | + //Momiji::Core::Vst::Host::Master^ _host; | |
| 17 | 17 | |
| 18 | + Collections::Generic::List<Momiji::Core::Vst::Host::Master^>^ _hosts; | |
| 19 | + | |
| 20 | + int _interval; | |
| 21 | + int _sampleMax; | |
| 22 | + int _ch; | |
| 23 | + array<System::Single>^ _data; | |
| 24 | + Momiji::Core::Vst::Buffer::VstBuffer<System::Single>^ _inBuffer; | |
| 25 | + Momiji::Core::Vst::Buffer::VstBuffer<System::Single>^ _outBuffer; | |
| 26 | + | |
| 27 | + | |
| 28 | +public: | |
| 29 | + Controller() | |
| 30 | + { | |
| 31 | + #ifdef _DEBUG | |
| 32 | + System::Console::WriteLine("[{0}]",__FUNCTION__); | |
| 33 | + #endif | |
| 34 | + | |
| 35 | + this->_interval = 10; | |
| 36 | + this->_sampleMax = 48000.0 * this->_interval * 2 / 1000.0; | |
| 37 | + | |
| 38 | + this->_ch = 1; | |
| 39 | + this->_data = gcnew array<System::Single>(this->_sampleMax * 2); | |
| 40 | + this->_inBuffer = gcnew Momiji::Core::Vst::Buffer::VstBuffer<System::Single>(2,this->_sampleMax); | |
| 41 | + this->_outBuffer = gcnew Momiji::Core::Vst::Buffer::VstBuffer<System::Single>(2,this->_sampleMax); | |
| 42 | + | |
| 43 | + this->_hosts = gcnew Collections::Generic::List<Momiji::Core::Vst::Host::Master^>; | |
| 44 | + } | |
| 45 | + | |
| 46 | + ~Controller() | |
| 47 | + { | |
| 48 | + #ifdef _DEBUG | |
| 49 | + System::Console::WriteLine("[{0}]",__FUNCTION__); | |
| 50 | + #endif | |
| 51 | + this->!Controller(); | |
| 52 | + } | |
| 53 | + | |
| 54 | + void Start() | |
| 55 | + { | |
| 56 | + #ifdef _DEBUG | |
| 57 | + System::Console::WriteLine("[{0}]",__FUNCTION__); | |
| 58 | + #endif | |
| 59 | + if (this->_timer != nullptr) | |
| 60 | + { | |
| 61 | + this->_timer->Start(this->_interval); | |
| 62 | + } | |
| 63 | + } | |
| 64 | + | |
| 65 | + void Stop() | |
| 66 | + { | |
| 67 | + #ifdef _DEBUG | |
| 68 | + System::Console::WriteLine("[{0}]",__FUNCTION__); | |
| 69 | + #endif | |
| 70 | + if (this->_timer != nullptr) | |
| 71 | + { | |
| 72 | + this->_timer->Stop(); | |
| 73 | + } | |
| 74 | + } | |
| 75 | + | |
| 76 | +protected: | |
| 77 | + !Controller() | |
| 78 | + { | |
| 79 | + #ifdef _DEBUG | |
| 80 | + System::Console::WriteLine("[{0}]",__FUNCTION__); | |
| 81 | + #endif | |
| 82 | + this->Stop(); | |
| 83 | + } | |
| 84 | + | |
| 85 | +private: | |
| 18 | 86 | void OnInterval(System::Double deltaTime) |
| 19 | 87 | { |
| 20 | 88 | #ifdef _DEBUG |
| @@ -22,7 +90,7 @@ private: | ||
| 22 | 90 | #endif |
| 23 | 91 | auto stream = this->_stream; |
| 24 | 92 | auto out = this->_out; |
| 25 | - auto host = this->_host; | |
| 93 | + auto hosts = this->_hosts; | |
| 26 | 94 | |
| 27 | 95 | if (stream == nullptr) |
| 28 | 96 | { |
| @@ -38,7 +106,7 @@ private: | ||
| 38 | 106 | #endif |
| 39 | 107 | return; |
| 40 | 108 | } |
| 41 | - if (host == nullptr) | |
| 109 | + if (hosts == nullptr) | |
| 42 | 110 | { |
| 43 | 111 | #ifdef _DEBUG |
| 44 | 112 | System::Console::WriteLine("[{0}]VSTが無いので何もしません",__FUNCTION__); |
| @@ -46,10 +114,19 @@ private: | ||
| 46 | 114 | return; |
| 47 | 115 | } |
| 48 | 116 | |
| 49 | - int sample = 44100.0 * deltaTime / 1000.0; | |
| 50 | -// System::Console::WriteLine("[{0}][{1}][{2}]",__FUNCTION__, sample, deltaTime); | |
| 117 | + int sample = 48000.0 * deltaTime / 1000.0; | |
| 118 | + //System::Console::WriteLine("[{0}][{1}][{2}][{3}]",__FUNCTION__, this->_sampleMax, sample, deltaTime); | |
| 119 | + | |
| 120 | + if (sample > this->_sampleMax) { | |
| 121 | + sample = this->_sampleMax; | |
| 122 | + } | |
| 123 | + | |
| 124 | + auto events = gcnew Collections::Generic::List< Collections::Generic::List<Momiji::Interop::Vst::VstEvent>^ >; | |
| 125 | + for (int i = 0; i < this->_ch; i++) | |
| 126 | + { | |
| 127 | + events->Add(gcnew Collections::Generic::List<Momiji::Interop::Vst::VstEvent>); | |
| 128 | + } | |
| 51 | 129 | |
| 52 | - auto events = gcnew Collections::Generic::List<Momiji::Interop::Vst::VstEvent>; | |
| 53 | 130 | auto packets = stream->GetStreamPacket(deltaTime); |
| 54 | 131 | auto startTick = 0; |
| 55 | 132 | for each(auto packet in packets) |
| @@ -66,83 +143,46 @@ private: | ||
| 66 | 143 | auto e = Momiji::Interop::Vst::VstEvent(); |
| 67 | 144 | e.type = Momiji::Interop::Vst::VstEvent::VstEventTypes::kVstMidiType; |
| 68 | 145 | e.flags = Momiji::Interop::Vst::VstEvent::VstMidiEventFlags::kVstMidiEventIsRealtime; |
| 69 | - e.deltaFrames = 0;//((sample < delta) ? sample : delta) * 10000; | |
| 146 | + e.deltaFrames = ((sample < delta) ? sample : delta) * 10000; //これはちゃんと求めるようにする | |
| 70 | 147 | e.midiData = midi->shortData; |
| 71 | - events->Add(e); | |
| 148 | + events[0/*midi->port*/]->Add(e); | |
| 72 | 149 | } |
| 73 | - host->ProcessEvents(events->ToArray()); | |
| 74 | - delete events; | |
| 75 | - | |
| 76 | - auto inBuffer = gcnew Momiji::Core::Vst::Buffer::VstBuffer<System::Single>(2,sample); | |
| 77 | - auto outBuffer = gcnew Momiji::Core::Vst::Buffer::VstBuffer<System::Single>(2,sample); | |
| 78 | 150 | |
| 79 | - host->Process(inBuffer, outBuffer, outBuffer->Length()); | |
| 80 | - | |
| 81 | - delete inBuffer; | |
| 82 | - | |
| 83 | - auto data = gcnew array<System::Single>(sample * 2); | |
| 84 | 151 | auto pos = 0; |
| 85 | - for (int idx = 0; idx < sample; idx++) | |
| 152 | + for (int i = 0; i < this->_ch; i++) | |
| 86 | 153 | { |
| 87 | - data[pos++] = outBuffer->GetBuffer()[0][idx]; | |
| 88 | - data[pos++] = outBuffer->GetBuffer()[1][idx]; | |
| 89 | - } | |
| 90 | - delete outBuffer; | |
| 154 | + auto host = hosts[i]; | |
| 91 | 155 | |
| 92 | - auto buffer = gcnew Momiji::Core::Wave::WaveData<System::Single>(0, data); | |
| 93 | - delete data; | |
| 156 | + host->ProcessEvents(events[i]->ToArray()); | |
| 157 | + host->Process(this->_inBuffer, this->_outBuffer, sample/*this->_outBuffer->Length()/**/); | |
| 94 | 158 | |
| 95 | - out->Send(buffer); | |
| 96 | - buffer = nullptr; | |
| 97 | - } | |
| 159 | + for (int idx = 0; idx < sample; idx++) | |
| 160 | + { | |
| 161 | + this->_data[pos++] += this->_outBuffer->GetBuffer()[0][idx]; | |
| 162 | + this->_data[pos++] += this->_outBuffer->GetBuffer()[1][idx]; | |
| 163 | + } | |
| 164 | + } | |
| 98 | 165 | |
| 99 | -public: | |
| 100 | - Controller() | |
| 101 | - { | |
| 102 | - #ifdef _DEBUG | |
| 103 | - System::Console::WriteLine("[{0}]",__FUNCTION__); | |
| 104 | - #endif | |
| 105 | - } | |
| 166 | + delete events; | |
| 106 | 167 | |
| 107 | - ~Controller() | |
| 108 | - { | |
| 109 | - #ifdef _DEBUG | |
| 110 | - System::Console::WriteLine("[{0}]",__FUNCTION__); | |
| 111 | - #endif | |
| 112 | - this->!Controller(); | |
| 113 | - } | |
| 168 | + auto buffer = gcnew Momiji::Core::Wave::WaveData<System::Single>(0, this->_data, pos); | |
| 114 | 169 | |
| 115 | - void Start() | |
| 116 | - { | |
| 117 | - #ifdef _DEBUG | |
| 118 | - System::Console::WriteLine("[{0}]",__FUNCTION__); | |
| 119 | - #endif | |
| 120 | - if (this->_timer != nullptr) | |
| 121 | - { | |
| 122 | - this->_timer->Start(10); | |
| 123 | - } | |
| 124 | - } | |
| 170 | + out->Send(buffer); | |
| 125 | 171 | |
| 126 | - void Stop() | |
| 127 | - { | |
| 128 | - #ifdef _DEBUG | |
| 129 | - System::Console::WriteLine("[{0}]",__FUNCTION__); | |
| 130 | - #endif | |
| 131 | - if (this->_timer != nullptr) | |
| 172 | + pos = 0; | |
| 173 | + for (int i = 0; i < this->_ch; i++) | |
| 132 | 174 | { |
| 133 | - this->_timer->Stop(); | |
| 175 | + for (int idx = 0; idx < sample; idx++) | |
| 176 | + { | |
| 177 | + this->_data[pos++] = 0; | |
| 178 | + this->_data[pos++] = 0; | |
| 179 | + } | |
| 134 | 180 | } |
| 135 | - } | |
| 136 | 181 | |
| 137 | -protected: | |
| 138 | - !Controller() | |
| 139 | - { | |
| 140 | - #ifdef _DEBUG | |
| 141 | - System::Console::WriteLine("[{0}]",__FUNCTION__); | |
| 142 | - #endif | |
| 143 | - this->Stop(); | |
| 182 | + buffer = nullptr; | |
| 144 | 183 | } |
| 145 | 184 | |
| 185 | + | |
| 146 | 186 | public: |
| 147 | 187 | void Assign(Momiji::Core::ITimer^ timer) |
| 148 | 188 | { |
| @@ -166,9 +206,9 @@ public: | ||
| 166 | 206 | this->_out = out; |
| 167 | 207 | } |
| 168 | 208 | |
| 169 | - void Assign(Momiji::Core::Vst::Host::Master^ host) | |
| 209 | + void Add(Momiji::Core::Vst::Host::Master^ host) | |
| 170 | 210 | { |
| 171 | - this->_host = host; | |
| 211 | + this->_hosts->Add(host); | |
| 172 | 212 | } |
| 173 | 213 | |
| 174 | 214 | }; |
| @@ -231,30 +271,32 @@ void test0() | ||
| 231 | 271 | o->AddPort( |
| 232 | 272 | 0, |
| 233 | 273 | 2, |
| 234 | - 44110, | |
| 274 | + 48000, | |
| 235 | 275 | System::Runtime::InteropServices::Marshal::SizeOf(System::Single::typeid) * 8, |
| 236 | 276 | ( |
| 237 | 277 | Momiji::Interop::Winmm::WaveFormatExtensiblePart::SPEAKER::FRONT_LEFT |
| 238 | 278 | | Momiji::Interop::Winmm::WaveFormatExtensiblePart::SPEAKER::FRONT_RIGHT |
| 239 | 279 | ), |
| 240 | 280 | Momiji::Interop::Ks::StaticKs::SUBTYPE_IEEE_FLOAT, |
| 241 | - 44110 | |
| 281 | + 48000 | |
| 242 | 282 | ); |
| 243 | 283 | |
| 244 | - h = gcnew Momiji::Core::Vst::Host::Master(vstFileName); | |
| 245 | - h->SetSampleRate(44100); | |
| 246 | - h->SetBlockSize(512); | |
| 247 | - h->Resume(); | |
| 248 | - h->Suspend(); | |
| 249 | - h->StartProcess(); | |
| 250 | - | |
| 251 | 284 | c = gcnew Controller(); |
| 252 | 285 | c->Assign(t); |
| 253 | 286 | c->Assign(s); |
| 254 | 287 | c->Assign(o); |
| 255 | - c->Assign(h); | |
| 256 | 288 | |
| 257 | - h->Resume(); | |
| 289 | + for (int i = 0; i < 1/*16*/; i++) { | |
| 290 | + h = gcnew Momiji::Core::Vst::Host::Master(vstFileName); | |
| 291 | + h->SetSampleRate(48000); | |
| 292 | + h->SetBlockSize(48000); | |
| 293 | + h->Resume(); | |
| 294 | + h->Suspend(); | |
| 295 | + h->StartProcess(); | |
| 296 | + h->Resume(); | |
| 297 | + | |
| 298 | + c->Add(h); | |
| 299 | + } | |
| 258 | 300 | |
| 259 | 301 | c->Start(); |
| 260 | 302 | Console::WriteLine("============ enter でstop"); |