fix VST user cache typo: info/blacklist
[ardour.git] / libs / ardour / vst_info_file.cc
1 /*
2     Copyright (C) 2012-2014 Paul Davis
3
4     This program is free software; you can redistribute it and/or modify
5     it under the terms of the GNU General Public License as published by
6     the Free Software Foundation; either version 2 of the License, or
7     (at your option) any later version.
8
9     This program is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12     GNU General Public License for more details.
13
14     You should have received a copy of the GNU General Public License
15     along with this program; if not, write to the Free Software
16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17
18 */
19
20 /** @file libs/ardour/vst_info_file.cc
21  *  @brief Code to manage info files containing cached information about a plugin.
22  *  e.g. its name, creator etc.
23  */
24
25 #include <iostream>
26 #include <cassert>
27
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <unistd.h>
31 #include <errno.h>
32
33 #include <stdlib.h>
34 #include <stddef.h>
35 #include <stdio.h>
36 #include <string.h>
37
38 #include <glib.h>
39 #include <glib/gstdio.h>
40 #include <glibmm.h>
41
42 #include "pbd/error.h"
43
44 #ifndef VST_SCANNER_APP
45 #include "ardour/plugin_manager.h" // scanner_bin_path
46 #include "ardour/rc_configuration.h"
47 #include "ardour/system_exec.h"
48 #endif
49
50 #include "ardour/filesystem_paths.h"
51 #include "ardour/linux_vst_support.h"
52 #include "ardour/plugin_types.h"
53 #include "ardour/vst_info_file.h"
54
55 #define MAX_STRING_LEN 256
56 #define PLUGIN_SCAN_TIMEOUT (Config->get_vst_scan_timeout()) // in deciseconds
57
58
59 /* CACHE FILE PATHS */
60 #define EXT_BLACKLIST ".fsb"
61 #define EXT_ERRORFILE ".err"
62 #define EXT_INFOFILE  ".fsi"
63
64 #ifdef PLATFORM_WINDOWS
65 #define PFX_DOTFILE   ""
66 #else
67 #define PFX_DOTFILE   "."
68 #endif
69
70
71 using namespace std;
72 #ifndef VST_SCANNER_APP
73 namespace ARDOUR {
74 #endif
75
76 /* prototypes */
77 #ifdef WINDOWS_VST_SUPPORT
78 #include <fst.h>
79 static bool
80 vstfx_instantiate_and_get_info_fst (const char* dllpath, vector<VSTInfo*> *infos, int uniqueID);
81 #endif
82
83 #ifdef LXVST_SUPPORT
84 static bool vstfx_instantiate_and_get_info_lx (const char* dllpath, vector<VSTInfo*> *infos, int uniqueID);
85 #endif
86
87 /* ID for shell plugins */
88 static int vstfx_current_loading_id = 0;
89
90
91
92 /* *** CACHE FILE PATHS *** */
93
94 static string
95 vstfx_cache_file (const char* dllpath, int personal, const char *ext)
96 {
97         string dir;
98         if (personal) {
99                 dir = get_personal_vst_info_cache_dir();
100         } else {
101                 dir = Glib::path_get_dirname (std::string(dllpath));
102         }
103
104         stringstream s;
105         s << PFX_DOTFILE << Glib::path_get_basename (dllpath) << ext;
106         return Glib::build_filename (dir, s.str ());
107 }
108
109 static string
110 vstfx_blacklist_path (const char* dllpath, int personal)
111 {
112         string dir;
113         if (personal) {
114                 dir = get_personal_vst_blacklist_dir();
115         } else {
116                 dir = Glib::path_get_dirname (std::string(dllpath));
117         }
118
119         stringstream s;
120         s << PFX_DOTFILE << Glib::path_get_basename (dllpath) << EXT_BLACKLIST;
121         return Glib::build_filename (dir, s.str ());
122 }
123
124 static string
125 vstfx_infofile_path (const char* dllpath, int personal)
126 {
127         return vstfx_cache_file(dllpath, personal, EXT_INFOFILE);
128 }
129
130 #ifndef VST_SCANNER_APP
131 static string
132 vstfx_errorfile_path (const char* dllpath, int personal)
133 {
134         return vstfx_cache_file(dllpath, personal, EXT_ERRORFILE);
135 }
136 #endif
137
138
139 /* *** MEMORY MANAGEMENT *** */
140
141 /** cleanup single allocated VSTInfo */
142 static void
143 vstfx_free_info (VSTInfo *info)
144 {
145         for (int i = 0; i < info->numParams; i++) {
146                 free (info->ParamNames[i]);
147                 free (info->ParamLabels[i]);
148         }
149
150         free (info->name);
151         free (info->creator);
152         free (info->Category);
153         free (info->ParamNames);
154         free (info->ParamLabels);
155         free (info);
156 }
157
158 /** reset vector */
159 static void
160 vstfx_clear_info_list (vector<VSTInfo *> *infos)
161 {
162         for (vector<VSTInfo *>::iterator i = infos->begin(); i != infos->end(); ++i) {
163                 vstfx_free_info(*i);
164         }
165         infos->clear();
166 }
167
168
169
170 /* *** CACHE FILE I/O *** */
171
172 /** Helper function to read a line from the cache file
173  * @return newly allocated string of NULL
174  */
175 static char *
176 read_string (FILE *fp)
177 {
178         char buf[MAX_STRING_LEN];
179
180         if (!fgets (buf, MAX_STRING_LEN, fp)) {
181                 return 0;
182         }
183
184         if (strlen(buf) < MAX_STRING_LEN) {
185                 if (strlen (buf)) {
186                         buf[strlen(buf)-1] = 0;
187                 }
188                 return strdup (buf);
189         } else {
190                 return 0;
191         }
192 }
193
194 /** Read an integer value from a line in fp into n,
195  *  @return true on failure, false on success.
196  */
197 static bool
198 read_int (FILE* fp, int* n)
199 {
200         char buf[MAX_STRING_LEN];
201
202         char* p = fgets (buf, MAX_STRING_LEN, fp);
203         if (p == 0) {
204                 return true;
205         }
206
207         return (sscanf (p, "%d", n) != 1);
208 }
209
210 /** parse a plugin-block from the cache info file */
211 static bool
212 vstfx_load_info_block(FILE* fp, VSTInfo *info)
213 {
214         if ((info->name = read_string(fp)) == 0) return false;
215         if ((info->creator = read_string(fp)) == 0) return false;
216         if (read_int (fp, &info->UniqueID)) return false;
217         if ((info->Category = read_string(fp)) == 0) return false;
218         if (read_int (fp, &info->numInputs)) return false;
219         if (read_int (fp, &info->numOutputs)) return false;
220         if (read_int (fp, &info->numParams)) return false;
221         if (read_int (fp, &info->wantMidi)) return false;
222         if (read_int (fp, &info->hasEditor)) return false;
223         if (read_int (fp, &info->canProcessReplacing)) return false;
224
225         /* backwards compatibility with old .fsi files */
226         if (info->wantMidi == -1) {
227                 info->wantMidi = 1;
228         }
229
230         if ((info->ParamNames = (char **) malloc(sizeof(char*)*info->numParams)) == 0) {
231                 return false;
232         }
233
234         for (int i = 0; i < info->numParams; ++i) {
235                 if ((info->ParamNames[i] = read_string(fp)) == 0) return false;
236         }
237
238         if ((info->ParamLabels = (char **) malloc(sizeof(char*)*info->numParams)) == 0) {
239                 return false;
240         }
241
242         for (int i = 0; i < info->numParams; ++i) {
243                 if ((info->ParamLabels[i] = read_string(fp)) == 0) {
244                         return false;
245                 }
246         }
247         return true;
248 }
249
250 /** parse all blocks in a cache info file */
251 static bool
252 vstfx_load_info_file (FILE* fp, vector<VSTInfo*> *infos)
253 {
254         VSTInfo *info;
255         if ((info = (VSTInfo*) calloc (1, sizeof (VSTInfo))) == 0) {
256                 return false;
257         }
258         if (vstfx_load_info_block(fp, info)) {
259                 if (strncmp (info->Category, "Shell", 5)) {
260                         infos->push_back(info);
261                 } else {
262                         int plugin_cnt = 0;
263                         vstfx_free_info(info);
264                         if (!read_int (fp, &plugin_cnt)) {
265                                 for (int i = 0; i < plugin_cnt; i++) {
266                                         if ((info = (VSTInfo*) calloc (1, sizeof (VSTInfo))) == 0) {
267                                                 vstfx_clear_info_list(infos);
268                                                 return false;
269                                         }
270                                         if (vstfx_load_info_block(fp, info)) {
271                                                 infos->push_back(info);
272                                         } else {
273                                                 vstfx_free_info(info);
274                                                 vstfx_clear_info_list(infos);
275                                                 return false;
276                                         }
277                                 }
278                         } else {
279                                 return false; /* Bad file */
280                         }
281                 }
282                 return true;
283         }
284         vstfx_free_info(info);
285         vstfx_clear_info_list(infos);
286         return false;
287 }
288
289 static void
290 vstfx_write_info_block (FILE* fp, VSTInfo *info)
291 {
292         assert (info);
293         assert (fp);
294
295         fprintf (fp, "%s\n", info->name);
296         fprintf (fp, "%s\n", info->creator);
297         fprintf (fp, "%d\n", info->UniqueID);
298         fprintf (fp, "%s\n", info->Category);
299         fprintf (fp, "%d\n", info->numInputs);
300         fprintf (fp, "%d\n", info->numOutputs);
301         fprintf (fp, "%d\n", info->numParams);
302         fprintf (fp, "%d\n", info->wantMidi);
303         fprintf (fp, "%d\n", info->hasEditor);
304         fprintf (fp, "%d\n", info->canProcessReplacing);
305
306         for (int i = 0; i < info->numParams; i++) {
307                 fprintf (fp, "%s\n", info->ParamNames[i]);
308         }
309
310         for (int i = 0; i < info->numParams; i++) {
311                 fprintf (fp, "%s\n", info->ParamLabels[i]);
312         }
313 }
314
315 static void
316 vstfx_write_info_file (FILE* fp, vector<VSTInfo *> *infos)
317 {
318         assert(infos);
319         assert(fp);
320
321         if (infos->size() > 1) {
322                 vector<VSTInfo *>::iterator x = infos->begin();
323                 /* write out the shell info first along with count of the number of
324                  * plugins contained in this shell
325                  */
326                 vstfx_write_info_block(fp, *x);
327                 fprintf( fp, "%d\n", (int)infos->size() - 1 );
328                 ++x;
329                 /* Now write out the info for each plugin */
330                 for (; x != infos->end(); ++x) {
331                         vstfx_write_info_block(fp, *x);
332                 }
333         } else if (infos->size() == 1) {
334                 vstfx_write_info_block(fp, infos->front());
335         } else {
336                 PBD::error << "Zero plugins in VST." << endmsg; // XXX here? rather make this impossible before if it ain't already.
337         }
338 }
339
340
341 /* *** CACHE AND BLACKLIST MANAGEMENT *** */
342
343 /* return true if plugin is blacklisted or has an invalid file extension */
344 static bool
345 vstfx_blacklist_stat (const char *dllpath, int personal)
346 {
347         if (strstr (dllpath, ".so" ) == 0 && strstr(dllpath, ".dll") == 0) {
348                 return true;
349         }
350         string const path = vstfx_blacklist_path (dllpath, personal);
351
352         if (Glib::file_test (path, Glib::FileTest (Glib::FILE_TEST_EXISTS | Glib::FILE_TEST_IS_REGULAR))) {
353                 struct stat dllstat;
354                 struct stat fsbstat;
355
356                 if (stat (dllpath, &dllstat) == 0 && stat (path.c_str(), &fsbstat) == 0) {
357                         if (dllstat.st_mtime > fsbstat.st_mtime) {
358                                 /* plugin is newer than blacklist file */
359                                 return true;
360                         }
361                 }
362                 /* stat failed or plugin is older than blacklist file */
363                 return true;
364         }
365         /* blacklist file does not exist */
366         return false;
367 }
368
369 /* return true if plugin is blacklisted, checks both personal
370  * and global folder */
371 static bool
372 vstfx_check_blacklist (const char *dllpath)
373 {
374         if (vstfx_blacklist_stat(dllpath, 0)) return true;
375         if (vstfx_blacklist_stat(dllpath, 1)) return true;
376         return false;
377 }
378
379 /* create blacklist file, preferably in same folder as the
380  * plugin, fall back to personal folder in $HOME
381  */
382 static FILE *
383 vstfx_blacklist_file (const char *dllpath)
384 {
385         FILE *f;
386         if ((f = fopen (vstfx_blacklist_path (dllpath, 0).c_str(), "wb"))) {
387                 return f;
388         }
389         return fopen (vstfx_blacklist_path (dllpath, 1).c_str(), "wb");
390 }
391
392 /** mark plugin as blacklisted */
393 static bool
394 vstfx_blacklist (const char *dllpath)
395 {
396         FILE *f = vstfx_blacklist_file(dllpath);
397         if (f) {
398                 fclose(f);
399                 return true;
400         }
401         return false;
402 }
403
404 /** mark plugin as not blacklisted */
405 static void
406 vstfx_un_blacklist (const char *dllpath)
407 {
408         ::g_unlink(vstfx_blacklist_path (dllpath, 0).c_str());
409         ::g_unlink(vstfx_blacklist_path (dllpath, 1).c_str());
410 }
411
412 /** remove info file from cache */
413 static void
414 vstfx_remove_infofile (const char *dllpath)
415 {
416         ::g_unlink(vstfx_infofile_path (dllpath, 0).c_str());
417         ::g_unlink(vstfx_infofile_path (dllpath, 1).c_str());
418 }
419
420 /** helper function, check if cache is newer than plugin
421  * @return path to cache file */
422 static char *
423 vstfx_infofile_stat (const char *dllpath, struct stat* statbuf, int personal)
424 {
425         if (strstr (dllpath, ".so" ) == 0 && strstr(dllpath, ".dll") == 0) {
426                 return 0;
427         }
428
429         string const path = vstfx_infofile_path (dllpath, personal);
430
431         if (Glib::file_test (path, Glib::FileTest (Glib::FILE_TEST_EXISTS | Glib::FILE_TEST_IS_REGULAR))) {
432
433                 struct stat dllstat;
434
435                 if (stat (dllpath, &dllstat) == 0) {
436                         if (stat (path.c_str(), statbuf) == 0) {
437                                 if (dllstat.st_mtime <= statbuf->st_mtime) {
438                                         /* plugin is older than info file */
439                                         return strdup (path.c_str ());
440                                 }
441                         }
442                 }
443         }
444
445         return 0;
446 }
447
448 /** cache file for given plugin
449  * @return FILE of the .fsi cache if found and up-to-date*/
450 static FILE *
451 vstfx_infofile_for_read (const char* dllpath)
452 {
453         struct stat own_statbuf;
454         struct stat sys_statbuf;
455         FILE *rv = NULL;
456
457         char* own_info = vstfx_infofile_stat (dllpath, &own_statbuf, 1);
458         char* sys_info = vstfx_infofile_stat (dllpath, &sys_statbuf, 0);
459
460         if (own_info) {
461                 if (sys_info) {
462                         if (own_statbuf.st_mtime <= sys_statbuf.st_mtime) {
463                                 /* system info file is newer, use it */
464                                 rv = g_fopen (sys_info, "rb");
465                         }
466                 } else {
467                         rv = g_fopen (own_info, "rb");
468                 }
469         } else if (sys_info) {
470                 rv = g_fopen (sys_info, "rb");
471         }
472         free(own_info);
473         free(sys_info);
474
475         return rv;
476 }
477
478 /** helper function for \ref vstfx_infofile_for_write
479  * abstract global and personal cache folders
480  */
481 static FILE *
482 vstfx_infofile_create (const char* dllpath, int personal)
483 {
484         if (strstr (dllpath, ".so" ) == 0 && strstr(dllpath, ".dll") == 0) {
485                 return 0;
486         }
487
488         string const path = vstfx_infofile_path (dllpath, personal);
489         return fopen (path.c_str(), "wb");
490 }
491
492 /** newly created cache file for given plugin
493  * @return FILE for the .fsi cache, NULL if neither personal,
494  * nor global cache folder is writable */
495 static FILE *
496 vstfx_infofile_for_write (const char* dllpath)
497 {
498         FILE* f;
499
500         if ((f = vstfx_infofile_create (dllpath, 0)) == 0) {
501                 f = vstfx_infofile_create (dllpath, 1);
502         }
503
504         return f;
505 }
506
507 /** check if cache-file exists, is up-to-date and parse cache file
508  * @param infos [return] loaded plugin info
509  * @return true if .fsi cache was read successfully, false otherwise
510  */
511 static bool
512 vstfx_get_info_from_file(const char* dllpath, vector<VSTInfo*> *infos)
513 {
514         FILE* infofile;
515         bool rv = false;
516         if ((infofile = vstfx_infofile_for_read (dllpath)) != 0) {
517                 rv = vstfx_load_info_file(infofile, infos);
518                 fclose (infofile);
519                 if (!rv) {
520                         PBD::warning << "Cannot get VST information form " << dllpath << ": info file load failed." << endmsg;
521                 }
522         }
523         return rv;
524 }
525
526
527
528 /* *** VST system-under-test methods *** */
529
530 static
531 bool vstfx_midi_input (VSTState* vstfx)
532 {
533         AEffect* plugin = vstfx->plugin;
534
535         int const vst_version = plugin->dispatcher (plugin, effGetVstVersion, 0, 0, 0, 0.0f);
536
537         if (vst_version >= 2) {
538                 /* should we send it VST events (i.e. MIDI) */
539
540                 if ((plugin->flags & effFlagsIsSynth) || (plugin->dispatcher (plugin, effCanDo, 0, 0,(void*) "receiveVstEvents", 0.0f) > 0)) {
541                         return true;
542                 }
543         }
544
545         return false;
546 }
547
548 static
549 bool vstfx_midi_output (VSTState* vstfx)
550 {
551         AEffect* plugin = vstfx->plugin;
552
553         int const vst_version = plugin->dispatcher (plugin, effGetVstVersion, 0, 0, 0, 0.0f);
554
555         if (vst_version >= 2) {
556                 /* should we send it VST events (i.e. MIDI) */
557
558                 if (   (plugin->dispatcher (plugin, effCanDo, 0, 0,(void*) "sendVstEvents", 0.0f) > 0)
559                                 || (plugin->dispatcher (plugin, effCanDo, 0, 0,(void*) "sendVstMidiEvent", 0.0f) > 0)
560                          ) {
561                         return true;
562                 }
563         }
564
565         return false;
566 }
567
568 /** simple 'dummy' audiomaster callback to instantiate the plugin
569  * and query information
570  */
571 static intptr_t
572 simple_master_callback (AEffect *, int32_t opcode, int32_t, intptr_t, void *ptr, float)
573 {
574         const char* vstfx_can_do_strings[] = {
575                 "supplyIdle",
576                 "sendVstTimeInfo",
577                 "sendVstEvents",
578                 "sendVstMidiEvent",
579                 "receiveVstEvents",
580                 "receiveVstMidiEvent",
581                 "supportShell",
582                 "shellCategory",
583                 "shellCategorycurID"
584         };
585         const int vstfx_can_do_string_count = 9;
586
587         if (opcode == audioMasterVersion) {
588                 return 2400;
589         }
590         else if (opcode == audioMasterCanDo) {
591                 for (int i = 0; i < vstfx_can_do_string_count; i++) {
592                         if (! strcmp(vstfx_can_do_strings[i], (const char*)ptr)) {
593                                 return 1;
594                         }
595                 }
596                 return 0;
597         }
598         else if (opcode == audioMasterCurrentId) {
599                 return vstfx_current_loading_id;
600         }
601         else {
602                 return 0;
603         }
604 }
605
606
607 /** main plugin query and test function */
608 static VSTInfo*
609 vstfx_parse_vst_state (VSTState* vstfx)
610 {
611         assert (vstfx);
612
613         VSTInfo* info = (VSTInfo*) malloc (sizeof (VSTInfo));
614         if (!info) {
615                 return 0;
616         }
617
618         /*We need to init the creator because some plugins
619           fail to implement getVendorString, and so won't stuff the
620           string with any name*/
621
622         char creator[65] = "Unknown";
623         char name[65] = "";
624
625         AEffect* plugin = vstfx->plugin;
626
627
628         plugin->dispatcher (plugin, effGetEffectName, 0, 0, name, 0);
629
630         if (strlen(name) == 0) {
631                 plugin->dispatcher (plugin, effGetProductString, 0, 0, name, 0);
632         }
633
634         if (strlen(name) == 0) {
635                 info->name = strdup (vstfx->handle->name);
636         } else {
637                 info->name = strdup (name);
638         }
639
640         /*If the plugin doesn't bother to implement GetVendorString we will
641           have pre-stuffed the string with 'Unknown' */
642
643         plugin->dispatcher (plugin, effGetVendorString, 0, 0, creator, 0);
644
645         /*Some plugins DO implement GetVendorString, but DON'T put a name in it
646           so if its just a zero length string we replace it with 'Unknown' */
647
648         if (strlen(creator) == 0) {
649                 info->creator = strdup ("Unknown");
650         } else {
651                 info->creator = strdup (creator);
652         }
653
654
655         switch (plugin->dispatcher (plugin, effGetPlugCategory, 0, 0, 0, 0))
656         {
657                 case kPlugCategEffect:         info->Category = strdup ("Effect"); break;
658                 case kPlugCategSynth:          info->Category = strdup ("Synth"); break;
659                 case kPlugCategAnalysis:       info->Category = strdup ("Anaylsis"); break;
660                 case kPlugCategMastering:      info->Category = strdup ("Mastering"); break;
661                 case kPlugCategSpacializer:    info->Category = strdup ("Spacializer"); break;
662                 case kPlugCategRoomFx:         info->Category = strdup ("RoomFx"); break;
663                 case kPlugSurroundFx:          info->Category = strdup ("SurroundFx"); break;
664                 case kPlugCategRestoration:    info->Category = strdup ("Restoration"); break;
665                 case kPlugCategOfflineProcess: info->Category = strdup ("Offline"); break;
666                 case kPlugCategShell:          info->Category = strdup ("Shell"); break;
667                 case kPlugCategGenerator:      info->Category = strdup ("Generator"); break;
668                 default:                       info->Category = strdup ("Unknown"); break;
669         }
670
671         info->UniqueID = plugin->uniqueID;
672
673         info->numInputs = plugin->numInputs;
674         info->numOutputs = plugin->numOutputs;
675         info->numParams = plugin->numParams;
676         info->wantMidi = (vstfx_midi_input(vstfx) ? 1 : 0) | (vstfx_midi_output(vstfx) ? 2 : 0);
677         info->hasEditor = plugin->flags & effFlagsHasEditor ? true : false;
678         info->canProcessReplacing = plugin->flags & effFlagsCanReplacing ? true : false;
679         info->ParamNames = (char **) malloc(sizeof(char*)*info->numParams);
680         info->ParamLabels = (char **) malloc(sizeof(char*)*info->numParams);
681
682         for (int i = 0; i < info->numParams; ++i) {
683                 char name[64];
684                 char label[64];
685
686                 /* Not all plugins give parameters labels as well as names */
687
688                 strcpy (name, "No Name");
689                 strcpy (label, "No Label");
690
691                 plugin->dispatcher (plugin, effGetParamName, i, 0, name, 0);
692                 info->ParamNames[i] = strdup(name);
693
694                 //NOTE: 'effGetParamLabel' is no longer defined in vestige headers
695                 //plugin->dispatcher (plugin, effGetParamLabel, i, 0, label, 0);
696                 info->ParamLabels[i] = strdup(label);
697         }
698         return info;
699 }
700
701 /** wrapper around \ref vstfx_parse_vst_state,
702  * iterate over plugins in shell, translate VST-info into ardour VSTState
703  */
704 static void
705 vstfx_info_from_plugin (const char *dllpath, VSTState* vstfx, vector<VSTInfo *> *infos, enum ARDOUR::PluginType type)
706 {
707         assert(vstfx);
708         VSTInfo *info;
709
710         if (!(info = vstfx_parse_vst_state(vstfx))) {
711                 return;
712         }
713
714         infos->push_back(info);
715 #if 1 // shell-plugin support
716         /* If this plugin is a Shell and we are not already inside a shell plugin
717          * read the info for all of the plugins contained in this shell.
718          */
719         if (!strncmp (info->Category, "Shell", 5)
720                         && vstfx->handle->plugincnt == 1) {
721                 int id;
722                 vector< pair<int, string> > ids;
723                 AEffect *plugin = vstfx->plugin;
724                 string path = vstfx->handle->path;
725
726                 do {
727                         char name[65] = "Unknown";
728                         id = plugin->dispatcher (plugin, effShellGetNextPlugin, 0, 0, name, 0);
729                         ids.push_back(std::make_pair(id, name));
730                 } while ( id != 0 );
731
732                 switch(type) {
733 #ifdef WINDOWS_VST_SUPPORT
734                         case ARDOUR::Windows_VST: fst_close(vstfx); break;
735 #endif
736 #ifdef LXVST_SUPPORT
737                         case ARDOUR::LXVST: vstfx_close (vstfx); break;
738 #endif
739                         default: assert(0); break;
740                 }
741
742                 for (vector< pair<int, string> >::iterator x = ids.begin(); x != ids.end(); ++x) {
743                         id = (*x).first;
744                         if (id == 0) continue;
745                         /* recurse vstfx_get_info() */
746
747                         bool ok;
748                         switch (type) {
749 #ifdef WINDOWS_VST_SUPPORT
750                                 case ARDOUR::Windows_VST:  ok = vstfx_instantiate_and_get_info_fst(dllpath, infos, id); break;
751 #endif
752 #ifdef LXVST_SUPPORT
753                                 case ARDOUR::LXVST:  ok = vstfx_instantiate_and_get_info_lx(dllpath, infos, id); break;
754 #endif
755                                 default: ok = false;
756                         }
757                         if (ok) {
758                                 // One shell (some?, all?) does not report the actual plugin name
759                                 // even after the shelled plugin has been instantiated.
760                                 // Replace the name of the shell with the real name.
761                                 info = infos->back();
762                                 free (info->name);
763
764                                 if ((*x).second.length() == 0) {
765                                         info->name = strdup("Unknown");
766                                 }
767                                 else {
768                                         info->name = strdup ((*x).second.c_str());
769                                 }
770                         }
771                 }
772         } else {
773                 switch(type) {
774 #ifdef WINDOWS_VST_SUPPORT
775                         case ARDOUR::Windows_VST: fst_close(vstfx); break;
776 #endif
777 #ifdef LXVST_SUPPORT
778                         case ARDOUR::LXVST: vstfx_close (vstfx); break;
779 #endif
780                         default: assert(0); break;
781                 }
782         }
783 #endif
784 }
785
786
787
788 /* *** TOP-LEVEL PLUGIN INSTANTIATION FUNCTIONS *** */
789
790 #ifdef LXVST_SUPPORT
791 static bool
792 vstfx_instantiate_and_get_info_lx (
793                 const char* dllpath, vector<VSTInfo*> *infos, int uniqueID)
794 {
795         VSTHandle* h;
796         VSTState* vstfx;
797         if (!(h = vstfx_load(dllpath))) {
798                 PBD::warning << "Cannot get LinuxVST information from " << dllpath << ": load failed." << endmsg;
799                 return false;
800         }
801
802         vstfx_current_loading_id = uniqueID;
803
804         if (!(vstfx = vstfx_instantiate(h, simple_master_callback, 0))) {
805                 vstfx_unload(h);
806                 PBD::warning << "Cannot get LinuxVST information from " << dllpath << ": instantiation failed." << endmsg;
807                 return false;
808         }
809
810         vstfx_current_loading_id = 0;
811
812         vstfx_info_from_plugin(dllpath, vstfx, infos, ARDOUR::LXVST);
813
814         vstfx_unload (h);
815         return true;
816 }
817 #endif
818
819 #ifdef WINDOWS_VST_SUPPORT
820 static bool
821 vstfx_instantiate_and_get_info_fst (
822                 const char* dllpath, vector<VSTInfo*> *infos, int uniqueID)
823 {
824         VSTHandle* h;
825         VSTState* vstfx;
826         if(!(h = fst_load(dllpath))) {
827                 PBD::warning << "Cannot get Windows VST information from " << dllpath << ": load failed." << endmsg;
828                 return false;
829         }
830
831         vstfx_current_loading_id = uniqueID;
832
833         if(!(vstfx = fst_instantiate(h, simple_master_callback, 0))) {
834                 fst_unload(&h);
835                 vstfx_current_loading_id = 0;
836                 PBD::warning << "Cannot get Windows VST information from " << dllpath << ": instantiation failed." << endmsg;
837                 return false;
838         }
839         vstfx_current_loading_id = 0;
840
841         vstfx_info_from_plugin(dllpath, vstfx, infos, ARDOUR::Windows_VST);
842
843         return true;
844 }
845 #endif
846
847
848
849 /* *** ERROR LOGGING *** */
850 #ifndef VST_SCANNER_APP
851
852 static FILE * _errorlog_fd = 0;
853 static char * _errorlog_dll = 0;
854
855 static void parse_scanner_output (std::string msg, size_t /*len*/)
856 {
857         if (!_errorlog_fd && !_errorlog_dll) {
858                 PBD::error << "VST scanner: " << msg;
859                 return;
860         }
861
862         if (!_errorlog_fd) {
863                 if (!(_errorlog_fd = fopen(vstfx_errorfile_path(_errorlog_dll, 0).c_str(), "w"))) {
864                         if (!(_errorlog_fd = fopen(vstfx_errorfile_path(_errorlog_dll, 1).c_str(), "w"))) {
865                                 PBD::error << "Cannot create plugin error-log for plugin " << _errorlog_dll;
866                                 free(_errorlog_dll);
867                                 _errorlog_dll = NULL;
868                         }
869                 }
870         }
871
872         if (_errorlog_fd) {
873                 fprintf (_errorlog_fd, "%s\n", msg.c_str());
874         } else {
875                 PBD::error << "VST scanner: " << msg;
876         }
877 }
878
879 static void
880 set_error_log (const char* dllpath) {
881         assert(!_errorlog_fd);
882         assert(!_errorlog_dll);
883         _errorlog_dll = strdup(dllpath);
884 }
885
886 static void
887 close_error_log () {
888         if (_errorlog_fd) {
889                 fclose(_errorlog_fd);
890                 _errorlog_fd = 0;
891         }
892         free(_errorlog_dll);
893         _errorlog_dll = 0;
894 }
895
896 #endif
897
898
899 /* *** THE MAIN FUNCTION THAT USES ALL OF THE ABOVE :) *** */
900
901 static vector<VSTInfo *> *
902 vstfx_get_info (const char* dllpath, enum ARDOUR::PluginType type, enum VSTScanMode mode)
903 {
904         FILE* infofile;
905         vector<VSTInfo*> *infos = new vector<VSTInfo*>;
906
907         if (vstfx_check_blacklist(dllpath)) {
908                 return infos;
909         }
910
911         if (vstfx_get_info_from_file(dllpath, infos)) {
912                 return infos;
913         }
914
915 #ifndef VST_SCANNER_APP
916         std::string scanner_bin_path = ARDOUR::PluginManager::scanner_bin_path;
917
918         if (mode == VST_SCAN_CACHE_ONLY) {
919                 /* never scan explicitly, use cache only */
920                 return infos;
921         }
922         else if (mode == VST_SCAN_USE_APP && scanner_bin_path != "") {
923                 /* use external scanner app */
924
925                 char **argp= (char**) calloc(3,sizeof(char*));
926                 argp[0] = strdup(scanner_bin_path.c_str());
927                 argp[1] = strdup(dllpath);
928                 argp[2] = 0;
929
930                 set_error_log(dllpath);
931                 ARDOUR::SystemExec scanner (scanner_bin_path, argp);
932                 PBD::ScopedConnectionList cons;
933                 scanner.ReadStdout.connect_same_thread (cons, boost::bind (&parse_scanner_output, _1 ,_2));
934                 if (scanner.start (2 /* send stderr&stdout via signal */)) {
935                         PBD::error << "Cannot launch VST scanner app '" << scanner_bin_path << "': "<< strerror(errno) << endmsg;
936                         close_error_log();
937                         return infos;
938                 } else {
939                         int timeout = PLUGIN_SCAN_TIMEOUT;
940                         bool no_timeout = (timeout <= 0);
941                         ARDOUR::PluginScanTimeout(timeout);
942                         while (scanner.is_running() && (no_timeout || timeout > 0)) {
943                                 if (!no_timeout && !ARDOUR::PluginManager::instance().no_timeout()) {
944                                         if (timeout%5 == 0) {
945                                                 ARDOUR::PluginScanTimeout(timeout);
946                                         }
947                                         --timeout;
948                                 }
949                                 ARDOUR::GUIIdle();
950                                 Glib::usleep (100000);
951
952                                 if (ARDOUR::PluginManager::instance().cancelled()) {
953                                         // remove info file (might be incomplete)
954                                         vstfx_remove_infofile(dllpath);
955                                         // remove temporary blacklist file (scan incomplete)
956                                         vstfx_un_blacklist(dllpath);
957                                         scanner.terminate();
958                                         close_error_log();
959                                         return infos;
960                                 }
961                         }
962                         scanner.terminate();
963                 }
964                 close_error_log();
965                 /* re-read index (generated by external scanner) */
966                 vstfx_clear_info_list(infos);
967                 if (!vstfx_check_blacklist(dllpath)) {
968                         vstfx_get_info_from_file(dllpath, infos);
969                 }
970                 return infos;
971         }
972         /* else .. instantiate and check in in ardour process itself */
973 #else
974         (void) mode; // unused parameter
975 #endif
976
977         bool ok;
978         /* blacklist in case instantiation fails */
979         vstfx_blacklist(dllpath);
980
981         switch (type) {
982 #ifdef WINDOWS_VST_SUPPORT
983                 case ARDOUR::Windows_VST:  ok = vstfx_instantiate_and_get_info_fst(dllpath, infos, 0); break;
984 #endif
985 #ifdef LXVST_SUPPORT
986                 case ARDOUR::LXVST:  ok = vstfx_instantiate_and_get_info_lx(dllpath, infos, 0); break;
987 #endif
988                 default: ok = false;
989         }
990
991         if (!ok) {
992                 return infos;
993         }
994
995         /* remove from blacklist */
996         vstfx_un_blacklist(dllpath);
997
998         /* crate cache/whitelist */
999         infofile = vstfx_infofile_for_write (dllpath);
1000         if (!infofile) {
1001                 PBD::warning << "Cannot cache VST information for " << dllpath << ": cannot create new FST info file." << endmsg;
1002                 return infos;
1003         } else {
1004                 vstfx_write_info_file (infofile, infos);
1005                 fclose (infofile);
1006         }
1007         return infos;
1008 }
1009
1010
1011
1012 /* *** public API *** */
1013
1014 void
1015 vstfx_free_info_list (vector<VSTInfo *> *infos)
1016 {
1017         for (vector<VSTInfo *>::iterator i = infos->begin(); i != infos->end(); ++i) {
1018                 vstfx_free_info(*i);
1019         }
1020         delete infos;
1021 }
1022
1023 string
1024 get_personal_vst_blacklist_dir() {
1025         string dir = Glib::build_filename (ARDOUR::user_cache_directory(), "fst_blacklist");
1026         /* if the directory doesn't exist, try to create it */
1027         if (!Glib::file_test (dir, Glib::FILE_TEST_IS_DIR)) {
1028                 if (g_mkdir (dir.c_str (), 0700)) {
1029                         PBD::error << "Cannot create VST blacklist folder '" << dir << "'" << endmsg;
1030                         //exit(1);
1031                 }
1032         }
1033         return dir;
1034 }
1035
1036 string
1037 get_personal_vst_info_cache_dir() {
1038         string dir = Glib::build_filename (ARDOUR::user_cache_directory(), "fst_info");
1039         /* if the directory doesn't exist, try to create it */
1040         if (!Glib::file_test (dir, Glib::FILE_TEST_IS_DIR)) {
1041                 if (g_mkdir (dir.c_str (), 0700)) {
1042                         PBD::error << "Cannot create VST info folder '" << dir << "'" << endmsg;
1043                         //exit(1);
1044                 }
1045         }
1046         return dir;
1047 }
1048
1049 #ifdef LXVST_SUPPORT
1050 vector<VSTInfo *> *
1051 vstfx_get_info_lx (char* dllpath, enum VSTScanMode mode)
1052 {
1053         return vstfx_get_info(dllpath, ARDOUR::LXVST, mode);
1054 }
1055 #endif
1056
1057 #ifdef WINDOWS_VST_SUPPORT
1058 vector<VSTInfo *> *
1059 vstfx_get_info_fst (char* dllpath, enum VSTScanMode mode)
1060 {
1061         return vstfx_get_info(dllpath, ARDOUR::Windows_VST, mode);
1062 }
1063 #endif
1064
1065 #ifndef VST_SCANNER_APP
1066 } // namespace
1067 #endif