← Back to branch summary

~ubuntu-branches/ubuntu/trusty/lmms/trusty

« back to all changes in this revision

Viewing changes to plugins/vst_base/RemoteVstPlugin.cpp

  • Committer: Package Import Robot
  • Author(s): Israel Dahl
  • Date: 2013-02-28 20:58:18 UTC
  • mfrom: (1.1.12)
  • Revision ID: package-import@ubuntu.com-20130228205818-spbc545gwofxkkif
Tags: 0.4.14-0ubuntu1
* New upstream release.
  - Graphically enhanced AudioFileProcessor plugin
  - Fixed bug with magnetic knobs
  - Fixed various crashes
  - Completely revised VST support (improved VST effect support,
  timesync support and many more)
  - Added multitrack export
  - Added Hydrogen song import plugin
  - Fixed wrong chords
  - Improvements to automation framework
* debian/lmms.install debian/lmms-common.install
  - moved /usr/share/applications to lmms.install
* debian/control
  - updated Standards-Version to 3.9.4
* debian/copyright
  - updated to make current
* debian/rules
  - fixed Lintian errors during build

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/vst_base/RemoteVstPlugin.cpp
1
1
/*
2
2
 * RemoteVstPlugin.cpp - LMMS VST Support Layer (RemotePlugin client)
3
3
 *
4
 
 * Copyright (c) 2005-2010 Tobias Doerffel <tobydox/at/users.sourceforge.net>
 
4
 * Copyright (c) 2005-2012 Tobias Doerffel <tobydox/at/users.sourceforge.net>
5
5
 *
6
6
 * This file is part of Linux MultiMedia Studio - http://lmms.sourceforge.net
7
7
 *
163
163
        // determine product-string of plugin
164
164
        const char * pluginProductString();
165
165
 
166
 
        // determine name of plugipn preset
167
 
        const char * presetName();
 
166
        // determine name of current program
 
167
        const char * programName();
 
168
 
 
169
        // send name of current program back to host
 
170
        void sendCurrentProgramName();
168
171
 
169
172
        // do a complete parameter-dump and post it
170
173
        void getParameterDump();
182
185
        void loadChunkFromFile( const std::string & _file, int _len );
183
186
 
184
187
        // restore settings chunk of plugin from file
185
 
        void loadChunkFromPresetFile( const std::string & _file );
186
 
 
187
 
        // restore settings chunk of plugin from file
188
 
        void rotateProgram( int _len );
189
 
 
190
 
        // Load names VST of presets/programs
191
 
        void loadPrograms( int _len );
 
188
        void loadPresetFile( const std::string & _file );
 
189
 
 
190
        // sets given program index
 
191
        void setProgram( int index );
 
192
 
 
193
        // rotate current program by given offset
 
194
        void rotateProgram( int offset );
 
195
 
 
196
        // Load names of presets/programs
 
197
        void getProgramNames();
192
198
 
193
199
        // Save presets/programs
194
200
        void savePreset( const std::string & _file );
255
261
                lock();
256
262
                if( m_plugin )
257
263
                {
258
 
                        ret = m_plugin->dispatcher( m_plugin, cmd, param1,
259
 
                                                        param2, p, f );
 
264
                        ret = m_plugin->dispatcher( m_plugin, cmd, param1, param2, p, f );
260
265
                }
261
266
                unlock();
262
267
                return ret;
263
268
        }
264
269
 
 
270
        // thread-safe dispatching of plugin
 
271
        int pluginDispatchNoLocking( int cmd, int param1 = 0, int param2 = 0, void * p = NULL, float f = 0 )
 
272
        {
 
273
                if( m_plugin )
 
274
                {
 
275
                        return m_plugin->dispatcher( m_plugin, cmd, param1, param2, p, f );
 
276
                }
 
277
                return 0;
 
278
        }
 
279
 
 
280
 
265
281
        std::string m_shortName;
266
282
 
267
283
        HINSTANCE m_libInst;
285
301
 
286
302
        bpm_t m_bpm;
287
303
        double m_currentSamplePos;
 
304
        int m_currentProgram;
288
305
 
289
306
} ;
290
307
 
306
323
        m_outputs( NULL ),
307
324
        m_midiEvents(),
308
325
        m_bpm( 0 ),
309
 
        m_currentSamplePos( 0 )
 
326
        m_currentSamplePos( 0 ),
 
327
        m_currentProgram( -1 )
310
328
{
311
329
        pthread_mutex_init( &m_pluginLock, NULL );
312
330
 
314
332
 
315
333
        // process until we have loaded the plugin
316
334
        while( 1 )
317
 
        {
 
335
        {
318
336
                message m = receiveMessage();
319
337
                processMessage( m );
320
338
                if( m.id == IdVstLoadPlugin || m.id == IdQuit )
401
419
                        sendMessage( IdLoadSettingsFromFile );
402
420
                        break;
403
421
 
404
 
                case IdLoadChunkFromPresetFile:
405
 
                        loadChunkFromPresetFile( _m.getString( 0 ) );
406
 
                        sendMessage( IdLoadChunkFromPresetFile );
407
 
                        break;
408
 
 
409
 
                case IdRotateProgram:
 
422
                case IdLoadPresetFile:
 
423
                        loadPresetFile( _m.getString( 0 ) );
 
424
                        sendMessage( IdLoadPresetFile );
 
425
                        break;
 
426
 
 
427
                case IdVstSetProgram:
 
428
                        setProgram( _m.getInt( 0 ) );
 
429
                        sendMessage( IdVstSetProgram );
 
430
                        break;
 
431
 
 
432
                case IdVstCurrentProgram:
 
433
                        sendMessage( message( IdVstCurrentProgram ).addInt( m_currentProgram ) );
 
434
                        break;
 
435
 
 
436
                case IdVstRotateProgram:
410
437
                        rotateProgram( _m.getInt( 0 ) );
411
 
                        sendMessage( IdRotateProgram );
412
 
                        break;
413
 
 
414
 
                case IdLoadPrograms:
415
 
                        loadPrograms( _m.getInt( 0 ) );
416
 
                        sendMessage( IdLoadPrograms );
417
 
                        break;
418
 
 
419
 
                case IdSavePreset:
 
438
                        sendMessage( IdVstRotateProgram );
 
439
                        break;
 
440
 
 
441
                case IdVstProgramNames:
 
442
                        getProgramNames();
 
443
                        break;
 
444
 
 
445
                case IdSavePresetFile:
420
446
                        savePreset( _m.getString( 0 ) );
421
 
                        sendMessage( IdSavePreset );
 
447
                        sendMessage( IdSavePresetFile );
422
448
                        break;
423
449
 
424
 
                case IdSetParameter:
 
450
                case IdVstSetParameter:
 
451
                        lock();
425
452
                        m_plugin->setParameter( m_plugin, _m.getInt( 0 ), _m.getFloat( 1 ) );
426
 
                        sendMessage( IdSetParameter );
427
 
                        break;
428
 
 
429
 
 
 
453
                        unlock();
 
454
                        sendMessage( IdVstSetParameter );
 
455
                        break;
 
456
 
 
457
 
 
458
                case IdVstIdleUpdate:
 
459
                {
 
460
                        int newCurrentProgram = pluginDispatch( effGetProgram );
 
461
                        if( newCurrentProgram != m_currentProgram )
 
462
                        {
 
463
                                m_currentProgram = newCurrentProgram;
 
464
                                sendCurrentProgramName();
 
465
                        }
 
466
 
 
467
                        break;
 
468
                }
430
469
 
431
470
                default:
432
471
                        return RemotePluginClient::processMessage( _m );
609
648
 
610
649
        if( m_plugin->magic != kEffectMagic )
611
650
        {
612
 
                char buf[256];
613
 
                sprintf( buf, "%s is not a VST plugin\n",
614
 
                                                        _plugin_file.c_str() );
615
 
                debugMessage( buf );
 
651
                debugMessage( "File is not a VST plugin\n" );
616
652
                return false;
617
653
        }
618
654
 
675
711
                memset( m_outputs[i], 0, bufferSize() * sizeof( float ) );
676
712
        }
677
713
 
 
714
        lock();
 
715
 
678
716
#ifdef OLD_VST_SDK
679
717
        if( m_plugin->flags & effFlagsCanReplacing )
680
718
        {
690
728
        }
691
729
#endif
692
730
 
 
731
        unlock();
 
732
 
693
733
        m_currentSamplePos += bufferSize();
694
 
 
695
734
}
696
735
 
697
736
 
768
807
 
769
808
 
770
809
 
771
 
const char * RemoteVstPlugin::presetName()
 
810
const char * RemoteVstPlugin::programName()
772
811
{
773
 
        static char buf[32];
774
 
        buf[0] = 0;
775
 
 
776
 
        m_plugin->dispatcher(m_plugin, effGetProgramName, 0, 0, buf, 0);
777
 
 
778
 
        buf[31] = 0;
 
812
        static char buf[24];
 
813
 
 
814
        memset( buf, 0, sizeof( buf ) );
 
815
 
 
816
        pluginDispatch( effGetProgramName, 0, 0, buf );
 
817
 
 
818
        buf[23] = 0;
 
819
 
779
820
        return buf;
780
821
}
781
822
 
782
823
 
783
824
 
 
825
void RemoteVstPlugin::sendCurrentProgramName()
 
826
{
 
827
        char presName[64];
 
828
        sprintf( presName, "%d/%d: %s", pluginDispatch( effGetProgram ) + 1, m_plugin->numPrograms, programName() );
 
829
 
 
830
        sendMessage( message( IdVstCurrentProgramName ).addString( presName ) );
 
831
}
 
832
 
 
833
 
 
834
 
784
835
void RemoteVstPlugin::getParameterDump()
785
836
{
786
 
        char curPresName[30];
787
 
        //VstParameterProperties vst_props;
788
 
        message m( IdVstParameterDump );
789
 
        m.addInt( m_plugin->numParams );
790
 
        for( int i = 0; i < m_plugin->numParams; ++i )
791
 
        {
792
 
                //pluginDispatch( effGetParameterProperties, i, 0, &vst_props );
793
 
                m_plugin->dispatcher(m_plugin, effGetParamName, i, 0, curPresName, 0);
794
 
                m.addInt( i );
795
 
                m.addString( /*vst_props.shortLabel*/curPresName );
796
 
                m.addFloat( m_plugin->getParameter( m_plugin, i ) );
797
 
        }
798
 
        sendMessage( m );
 
837
        lock();
 
838
 
 
839
        message m( IdVstParameterDump );
 
840
        m.addInt( m_plugin->numParams );
 
841
 
 
842
        for( int i = 0; i < m_plugin->numParams; ++i )
 
843
        {
 
844
                char paramName[32];
 
845
                memset( paramName, 0, sizeof( paramName ) );
 
846
                pluginDispatchNoLocking( effGetParamName, i, 0, paramName );
 
847
                paramName[sizeof(paramName)-1] = 0;
 
848
 
 
849
                m.addInt( i );
 
850
                m.addString( paramName );
 
851
                m.addFloat( m_plugin->getParameter( m_plugin, i ) );
 
852
        }
 
853
 
 
854
        unlock();
 
855
 
 
856
        sendMessage( m );
799
857
}
800
858
 
801
859
 
803
861
 
804
862
void RemoteVstPlugin::setParameterDump( const message & _m )
805
863
{
 
864
        lock();
806
865
        const int n = _m.getInt( 0 );
807
866
        const int params = ( n > m_plugin->numParams ) ?
808
867
                                        m_plugin->numParams : n;
815
874
                item.value = _m.getFloat( ++p );
816
875
                m_plugin->setParameter( m_plugin, item.index, item.value );
817
876
        }
 
877
        unlock();
818
878
}
819
879
 
820
880
 
869
929
 
870
930
 
871
931
 
872
 
void RemoteVstPlugin::rotateProgram( int _len )
873
 
{
874
 
        int currProgram;
875
 
        if (isInitialized() == false) return;
876
 
        if (_len <= 1) {
877
 
                currProgram = m_plugin->dispatcher(m_plugin, effGetProgram, 0, 0, 0, 0) + _len;
878
 
                if (currProgram >= m_plugin->numPrograms) currProgram = m_plugin->numPrograms - 1;
879
 
                if (currProgram < 0) currProgram = 0;
880
 
                m_plugin->dispatcher(m_plugin, effSetProgram, 0, currProgram++, 0, 0);
881
 
        } else {
882
 
                m_plugin->dispatcher(m_plugin, effSetProgram, 0, _len - 2, 0, 0);
883
 
                currProgram = _len - 1;
884
 
        }
885
 
 
886
 
        char presName[30];
887
 
        sprintf( presName, " %d/%d: %s", currProgram, m_plugin->numPrograms, presetName() );
888
 
 
889
 
        sendMessage( message( IdVstPluginPresetString ).addString( presName ) );
890
 
}
891
 
 
892
 
 
893
 
 
894
 
 
895
 
void RemoteVstPlugin::loadPrograms( int _len )
 
932
void RemoteVstPlugin::setProgram( int program )
 
933
{
 
934
        if( isInitialized() == false )
 
935
        {
 
936
                return;
 
937
        }
 
938
 
 
939
        if( program < 0 )
 
940
        {
 
941
                program = 0;
 
942
        }
 
943
        else if( program >= m_plugin->numPrograms )
 
944
        {
 
945
                program = m_plugin->numPrograms - 1;
 
946
        }
 
947
        pluginDispatch( effSetProgram, 0, program );
 
948
 
 
949
        sendCurrentProgramName();
 
950
}
 
951
 
 
952
 
 
953
 
 
954
 
 
955
void RemoteVstPlugin::rotateProgram( int offset )
 
956
{
 
957
        if( isInitialized() == false )
 
958
        {
 
959
                return;
 
960
        }
 
961
 
 
962
        int newProgram = pluginDispatch( effGetProgram ) + offset;
 
963
 
 
964
        if( newProgram < 0 )
 
965
        {
 
966
                newProgram = 0;
 
967
        }
 
968
        else if( newProgram >= m_plugin->numPrograms )
 
969
        {
 
970
                newProgram = m_plugin->numPrograms - 1;
 
971
        }
 
972
        pluginDispatch( effSetProgram, 0, newProgram );
 
973
 
 
974
        sendCurrentProgramName();
 
975
}
 
976
 
 
977
 
 
978
 
 
979
 
 
980
void RemoteVstPlugin::getProgramNames()
896
981
{
897
982
        char presName[1024+256*30];
898
983
        char curProgName[30];
899
984
        if (isInitialized() == false) return;
900
 
        bool progNameIndexed = (m_plugin->dispatcher(m_plugin, 29, 0, -1, curProgName, 0) == 1);
 
985
        bool progNameIndexed = ( pluginDispatch( 29, 0, -1, curProgName ) == 1 );
901
986
 
902
987
        if (m_plugin->numPrograms > 1) {
903
988
                if (progNameIndexed) {
904
 
                        for (int i = 0; i< (m_plugin->numPrograms >= 256?256:m_plugin->numPrograms); i++) {
905
 
                                m_plugin->dispatcher(m_plugin, 29, i, -1, curProgName, 0);
 
989
                        for (int i = 0; i< (m_plugin->numPrograms >= 256?256:m_plugin->numPrograms); i++)
 
990
                        {
 
991
                                pluginDispatch( 29, i, -1, curProgName );
906
992
                                if (i == 0)     sprintf( presName, "%s", curProgName );
907
993
                                else            sprintf( presName + strlen(presName), "|%s", curProgName );
908
994
                        }
909
 
                } else {
910
 
                        int currProgram = m_plugin->dispatcher(m_plugin, effGetProgram, 0, 0, 0, 0);
911
 
                        for (int i = 0; i< (m_plugin->numPrograms >= 256?256:m_plugin->numPrograms); i++) {
912
 
                                m_plugin->dispatcher(m_plugin, effSetProgram, 0, i, 0, 0);
913
 
                                if (i == 0)     sprintf( presName, "%s", presetName() );
914
 
                                else            sprintf( presName + strlen(presName), "|%s", presetName() );
 
995
                }
 
996
                else
 
997
                {
 
998
                        int currProgram = pluginDispatch( effGetProgram );
 
999
                        for (int i = 0; i< (m_plugin->numPrograms >= 256?256:m_plugin->numPrograms); i++)
 
1000
                        {
 
1001
                                pluginDispatch( effSetProgram, 0, i );
 
1002
                                if (i == 0)     sprintf( presName, "%s", programName() );
 
1003
                                else            sprintf( presName + strlen(presName), "|%s", programName() );
915
1004
                        }
916
 
                        m_plugin->dispatcher(m_plugin, effSetProgram, 0, currProgram, 0, 0);
 
1005
                        pluginDispatch( effSetProgram, 0, currProgram );
917
1006
                }
918
 
        } else sprintf( presName, "%s", presetName() );
919
 
 
920
 
        sendMessage( message( IdVstPluginPresetsString ).addString( presName ) );
 
1007
        } else sprintf( presName, "%s", programName() );
 
1008
 
 
1009
        presName[sizeof(presName)-1] = 0;
 
1010
 
 
1011
        sendMessage( message( IdVstProgramNames ).addString( presName ) );
921
1012
}
922
1013
 
923
1014
 
950
1041
        bool isPreset = _file.substr( _file.find_last_of( "." ) + 1 )  == "fxp";
951
1042
        int presNameLen = _file.find_last_of( "/" ) + _file.find_last_of( "\\" ) + 2;
952
1043
 
953
 
        if (isPreset) {
954
 
                for (int i = 0; i < _file.length() - 4 - presNameLen; i++) 
 
1044
        if (isPreset)
 
1045
        {
 
1046
                for (size_t i = 0; i < _file.length() - 4 - presNameLen; i++)
955
1047
                        progName[i] = i < 23 ? _file[presNameLen + i] : 0;
956
 
                m_plugin->dispatcher(m_plugin, 4, 0, 0, progName, 0);
957
 
        } //    m_plugin->dispatcher( m_plugin, effGetProgramName, 0, 0, progName, 0.0f );
 
1048
                pluginDispatch( 4, 0, 0, progName );
 
1049
        }
958
1050
        if ( chunky )
959
 
                chunk_size = m_plugin->dispatcher( m_plugin, 23, isPreset, 0, &data, false );
 
1051
                chunk_size = pluginDispatch( 23, isPreset, 0, &data );
960
1052
        else {
961
1053
                if (isPreset) {
962
1054
                        chunk_size = m_plugin->numParams * sizeof( float );
963
1055
                        data = new char[ chunk_size ];
964
1056
                        unsigned int* toUIntArray = reinterpret_cast<unsigned int*>( data );
 
1057
                        lock();
965
1058
                        for ( int i = 0; i < m_plugin->numParams; i++ )
966
1059
                        {
967
1060
                                float value = m_plugin->getParameter( m_plugin, i );
968
1061
                                unsigned int * pValue = ( unsigned int * ) &value;
969
1062
                                toUIntArray[ i ] = endian_swap( *pValue );
970
1063
                        }
 
1064
                        unlock();
971
1065
                } else chunk_size = (((m_plugin->numParams * sizeof( float )) + 56)*m_plugin->numPrograms);
972
1066
        }
973
1067
 
999
1093
                fwrite ( data, 1, chunk_size, stream );
1000
1094
        else {
1001
1095
                int numPrograms = m_plugin->numPrograms;
1002
 
                int currProgram = m_plugin->dispatcher(m_plugin, effGetProgram, 0, 0, 0, 0);
 
1096
                int currProgram = pluginDispatch( effGetProgram );
1003
1097
                chunk_size = (m_plugin->numParams * sizeof( float ));
1004
1098
                pBank->byteSize = chunk_size + 48;
1005
1099
                pBank->byteSize = endian_swap( pBank->byteSize );
1010
1104
                unsigned int* pValue,* toUIntArray = reinterpret_cast<unsigned int*>( data );
1011
1105
                float value;
1012
1106
                for (int j = 0; j < numPrograms; j++) {
1013
 
                        m_plugin->dispatcher(m_plugin, effSetProgram, 0, j, 0, 0);
1014
 
                        m_plugin->dispatcher(m_plugin, effGetProgramName, 0, 0, pBank->prgName, 0);
 
1107
                        pluginDispatch( effSetProgram, 0, j );
 
1108
                        pluginDispatch( effGetProgramName, 0, 0, pBank->prgName );
1015
1109
                        fwrite ( pBank, 1, 56, stream );
 
1110
                        lock();
1016
1111
                        for ( int i = 0; i < m_plugin->numParams; i++ )
1017
1112
                        {
1018
1113
                                value = m_plugin->getParameter( m_plugin, i );
1019
1114
                                pValue = ( unsigned int * ) &value;
1020
1115
                                toUIntArray[ i ] = endian_swap( *pValue );
1021
1116
                        }
 
1117
                        unlock();
1022
1118
                        fwrite ( data, 1, chunk_size, stream );
1023
1119
                }
1024
 
                m_plugin->dispatcher(m_plugin, effSetProgram, 0, currProgram, 0, 0);
 
1120
                pluginDispatch( effSetProgram, 0, currProgram );
1025
1121
        }
1026
1122
        fclose( stream );
1027
1123
 
1034
1130
 
1035
1131
 
1036
1132
 
1037
 
void RemoteVstPlugin::loadChunkFromPresetFile( const std::string & _file )
 
1133
void RemoteVstPlugin::loadPresetFile( const std::string & _file )
1038
1134
{
1039
1135
        void * chunk = NULL;
1040
1136
        unsigned int * pLen = new unsigned int[ 1 ];
1048
1144
        float * pFloat;
1049
1145
 
1050
1146
        if (m_plugin->uniqueID != pBank->fxID) {
1051
 
                sendMessage( message( IdVstPluginPresetString ).
 
1147
                sendMessage( message( IdVstCurrentProgramName ).
1052
1148
                                        addString( "Error: Plugin UniqID not match" ) );
1053
1149
                fclose( stream );
1054
1150
                delete[] (unsigned int*)pLen;
1070
1166
 
1071
1167
        if(_file.substr(_file.find_last_of(".") + 1) == "fxp") {
1072
1168
                pBank->prgName[23] = 0;
1073
 
                m_plugin->dispatcher(m_plugin, 4, 0, 0, pBank->prgName, 0);
 
1169
                pluginDispatch( 4, 0, 0, pBank->prgName );
1074
1170
                if(pBank->fxMagic != 0x6B437846)
1075
 
                        m_plugin->dispatcher(m_plugin, 24, 1, len, chunk, 0);
1076
 
                else {
 
1171
                        pluginDispatch( 24, 1, len, chunk );
 
1172
                else
 
1173
                {
 
1174
                        lock();
1077
1175
                        unsigned int* toUIntArray = reinterpret_cast<unsigned int*>( chunk );
1078
 
                        for (int i = 0; i < pBank->numPrograms; i++ ) {
 
1176
                        for (int i = 0; i < pBank->numPrograms; i++ )
 
1177
                        {
1079
1178
                                toUInt = endian_swap( toUIntArray[ i ] );
1080
1179
                                pFloat = ( float* ) &toUInt;
1081
1180
                                m_plugin->setParameter( m_plugin, i, *pFloat );
1082
1181
                        }
 
1182
                        unlock();
1083
1183
                }
1084
1184
        } else {
1085
1185
                if(pBank->fxMagic != 0x6B427846) {
1086
 
                        m_plugin->dispatcher(m_plugin, 24, 0, len, chunk, 0);
 
1186
                        pluginDispatch( 24, 0, len, chunk );
1087
1187
                } else {
1088
1188
                        int numPrograms = pBank->numPrograms;
1089
1189
                        unsigned int * toUIntArray;
1090
 
                        int currProgram = m_plugin->dispatcher(m_plugin, effGetProgram, 0, 0, 0, 0);
 
1190
                        int currProgram = pluginDispatch( effGetProgram );
1091
1191
                        chunk = new char[ len = sizeof(float)*m_plugin->numParams ];
1092
1192
                        toUIntArray = reinterpret_cast<unsigned int *>( chunk );
 
1193
                        lock();
1093
1194
                        for (int i =0; i < numPrograms; i++) {
1094
1195
                                fread (pBank, 1, 56, stream);
1095
1196
                                fread (chunk, len, 1, stream);
1096
 
                                m_plugin->dispatcher(m_plugin, effSetProgram, 0, i, 0, 0);
 
1197
                                pluginDispatch( effSetProgram, 0, i );
1097
1198
                                pBank->prgName[23] = 0;
1098
 
                                m_plugin->dispatcher(m_plugin, 4, 0, 0, pBank->prgName, 0);
 
1199
                                pluginDispatch( 4, 0, 0, pBank->prgName );
1099
1200
                                for (int j = 0; j < m_plugin->numParams; j++ ) {
1100
1201
                                        toUInt = endian_swap( toUIntArray[ j ] );
1101
1202
                                        pFloat = ( float* ) &toUInt;
1102
1203
                                        m_plugin->setParameter( m_plugin, j, *pFloat );
1103
1204
                                }
1104
1205
                        }
1105
 
                        m_plugin->dispatcher(m_plugin, effSetProgram, 0, currProgram, 0, 0);
 
1206
                        unlock();
 
1207
                        pluginDispatch( effSetProgram, 0, currProgram );
1106
1208
                        fclose( stream );
1107
1209
                }
1108
1210
        }
1109
 
        char presName[30];
1110
 
        int currProgram = m_plugin->dispatcher(m_plugin, effGetProgram, 0, 0, 0, 0) + 1;
1111
 
        sprintf( presName, " %d/%d: %s", currProgram, m_plugin->numPrograms, presetName() );
1112
1211
 
1113
 
        sendMessage( message( IdVstPluginPresetString ).addString( presName ) );
 
1212
        sendCurrentProgramName();
1114
1213
 
1115
1214
        delete[] (unsigned int*)pLen;
1116
1215
        delete[] (sBank*)pBank;