Credit Andrew - improve in-tree documentation
[goodguy/cinelerra.git] / cinelerra / pluginfclient.C
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <stdint.h>
4 #include <unistd.h>
5 #include <string.h>
6 #include <ctype.h>
7
8 #include "bcwindowbase.h"
9 #include "bctitle.h"
10 #include "cstrdup.h"
11 #include "language.h"
12 #include "mwindow.h"
13 #include "pluginfclient.h"
14 #include "pluginserver.h"
15 #include "samples.h"
16 #include "vframe.h"
17 #include "filexml.h"
18
19 #ifdef FFMPEG3
20 #define av_filter_iterate(p) ((*(const AVFilter**)(p))=avfilter_next(*(const AVFilter **)(p)))
21 #endif
22
23 static void ff_err(int ret, const char *fmt, ...)
24 {
25         char msg[BCTEXTLEN];
26         va_list ap;
27         va_start(ap, fmt);
28         vsnprintf(msg, sizeof(msg), fmt, ap);
29         va_end(ap);
30         char errmsg[BCSTRLEN];
31         av_strerror(ret, errmsg, sizeof(errmsg));
32         fprintf(stderr,_("%s  err: %s\n"),msg, errmsg);
33 }
34
35 PluginFClientConfig::PluginFClientConfig()
36 {
37         ffilt = 0;
38 }
39
40 PluginFClientConfig::~PluginFClientConfig()
41 {
42         delete ffilt;
43         remove_all_objects();
44 }
45
46 int PluginFClientConfig::equivalent(PluginFClientConfig &that)
47 {
48         PluginFClientConfig &conf = *this;
49         for( int i=0; i<that.size(); ++i ) {
50                 PluginFClient_Opt *topt = conf[i], *vopt = that[i];
51                 char tval[BCTEXTLEN], *tp = topt->get(tval, sizeof(tval));
52                 char vval[BCTEXTLEN], *vp = vopt->get(vval, sizeof(vval));
53                 int ret = tp && vp ? strcmp(tp, vp) : tp || vp ? 1 : 0;
54                 if( ret ) return 0;
55         }
56         return 1;
57 }
58
59 void PluginFClientConfig::copy_from(PluginFClientConfig &that)
60 {
61         PluginFClientConfig &conf = *this;
62         for( int i=0; i<that.size(); ++i ) {
63                 PluginFClient_Opt *vp = that[i];
64                 const char *nm = vp->opt->name;
65                 int k = size();
66                 while( --k >= 0 && strcmp(nm, conf[k]->opt->name) );
67                 if( k < 0 ) continue;
68                 PluginFClient_Opt *fopt = conf[k];
69                 char str[BCTEXTLEN], *sp = vp->get(str, sizeof(str));
70                 if( sp ) fopt->set(sp);
71         }
72 }
73
74 void PluginFClientConfig::interpolate(PluginFClientConfig &prev, PluginFClientConfig &next,
75         int64_t prev_frame, int64_t next_frame, int64_t current_frame)
76 {
77         copy_from(prev);
78 }
79
80 void PluginFClientConfig::initialize(const char *name)
81 {
82         delete ffilt;
83         ffilt = PluginFFilter::new_ffilter(name);
84         const AVOption *opt = 0;
85         void *obj = ffilt->filter_config();
86
87         const AVClass *filt_class = ffilt->filter_class();
88         if( filt_class && filt_class->option ) {
89                 PluginFClientConfig &conf = *this;
90                 while( (opt=av_opt_next(obj, opt)) != 0 ) {
91                         if( opt->type == AV_OPT_TYPE_CONST ) continue;
92                         int dupl = 0;
93                         for( int i=0; !dupl && i<size(); ++i ) {
94                                 PluginFClient_Opt *fp = conf[i];
95                                 const AVOption *op = fp->opt;
96                                 if( op->offset != opt->offset ) continue;
97                                 if( op->type != opt->type ) continue;
98                                 dupl = 1;
99                                 if( strlen(op->name) < strlen(opt->name) )
100                                         fp->opt = opt;
101                         }
102                         if( dupl ) continue;
103                         PluginFClient_Opt *fopt = new PluginFClient_Opt(this, opt);
104                         append(fopt);
105                 }
106         }
107         if( (ffilt->filter->flags & AVFILTER_FLAG_SLICE_THREADS) != 0 ) {
108                 opt = av_opt_find(ffilt->fctx, "threads", NULL, 0, 0);
109                 if( opt ) {
110                         PluginFClient_Opt *fopt = new PluginFClient_Opt(this, opt);
111                         append(fopt);
112                 }
113         }
114 }
115
116 int PluginFClientConfig::update()
117 {
118         int ret = 0;
119         PluginFClientConfig &conf = *this;
120
121         for( int i=0; i<size(); ++i ) {
122                 PluginFClient_Opt *fopt = conf[i];
123                 char val[BCTEXTLEN], *vp = fopt->get(val, sizeof(val));
124                 if( !vp || !strcmp(val, fopt->item_value->get_text()) ) continue;
125                 fopt->item_value->update();
126                 ++ret;
127         }
128         return ret;
129 }
130
131 void PluginFClientConfig::dump(FILE *fp)
132 {
133         const AVOption *opt = 0;
134         const AVClass *obj = filter_class();
135         PluginFClientConfig &conf = *this;
136
137         while( (opt=av_opt_next(&obj, opt)) != 0 ) {
138                 if( opt->type == AV_OPT_TYPE_CONST ) continue;
139                 int k = size();
140                 while( --k >= 0 && strcmp(opt->name, conf[k]->opt->name) );
141                 if( k < 0 ) continue;
142                 PluginFClient_Opt *fopt = conf[k];
143                 char val[BCTEXTLEN], *vp = fopt->get(val,sizeof(val));
144                 fprintf(fp, "  %s:=%s", opt->name, vp);
145                 if( opt->unit ) {
146                         char unt[BCTEXTLEN], *up = unt;
147                         fopt->units(up);
148                         fprintf(fp, "%s", unt);
149                 }
150                 fprintf(fp, "\n");
151         }
152 }
153
154 PluginFClientReset::
155 PluginFClientReset(PluginFClientWindow *fwin, int x, int y)
156  : BC_GenericButton(x, y, _("Reset"))
157 {
158         this->fwin = fwin;
159 }
160
161 PluginFClientReset::
162 ~PluginFClientReset()
163 {
164 }
165
166 int PluginFClientReset::handle_event()
167 {
168         fwin->ffmpeg->config.initialize(fwin->ffmpeg->name);
169         if( fwin->ffmpeg->config.update() > 0 )
170                 fwin->draw();
171         fwin->ffmpeg->plugin->send_configure_change();
172         return 1;
173 }
174
175 PluginFClientText::
176 PluginFClientText(PluginFClientWindow *fwin, int x, int y, int w)
177  : BC_TextBox(x, y, w, 1, (char *)"")
178 {
179         this->fwin = fwin;
180 }
181
182 PluginFClientText::
183 ~PluginFClientText()
184 {
185 }
186
187 int PluginFClientText::handle_event()
188 {
189         return 0;
190 }
191
192 PluginFClientUnits::
193 PluginFClientUnits(PluginFClientWindow *fwin, int x, int y, int w)
194  : BC_PopupMenu(x, y, w, "")
195 {
196         this->fwin = fwin;
197 }
198
199 PluginFClientUnits::
200 ~PluginFClientUnits()
201 {
202 }
203
204 int PluginFClientUnits::handle_event()
205 {
206         const char *text = get_text();
207         if( text && fwin->selected ) {
208                 if( text ) fwin->selected->set(text);
209                 fwin->selected->item_value->update();
210                 fwin->draw();
211                 fwin->ffmpeg->plugin->send_configure_change();
212         }
213         return 1;
214 }
215
216 PluginFClientApply::
217 PluginFClientApply(PluginFClientWindow *fwin, int x, int y)
218  : BC_GenericButton(x, y, _("Apply"))
219 {
220         this->fwin = fwin;
221 }
222
223 PluginFClientApply::
224 ~PluginFClientApply()
225 {
226 }
227
228 int PluginFClientApply::handle_event()
229 {
230         return fwin->update();
231 }
232
233 PluginFClientPot::PluginFClientPot(PluginFClientWindow *fwin, int x, int y)
234  : BC_FPot(x, y, 0.f, 0.f, 0.f)
235 {
236         this->fwin = fwin;
237 }
238
239 int PluginFClient_Opt::get_range(float &fmn, float &fmx)
240 {
241         switch( opt->type ) {
242         case AV_OPT_TYPE_INT:
243         case AV_OPT_TYPE_INT64:
244         case AV_OPT_TYPE_DOUBLE:
245         case AV_OPT_TYPE_FLOAT: break;
246         default: return 1;
247         }
248         const AVClass *filt_class = filter_class();
249         if( !filt_class || !filt_class->option ) return 1;
250         AVOptionRanges *r = 0;
251         void *obj = &filt_class;
252         if( av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ) < 0 ) return 1;
253         int ret = 1;
254         if( r->nb_ranges == 1 ) {
255                 fmn = r->range[0]->value_min;
256                 fmx = r->range[0]->value_max;
257                 ret = 0;
258         }
259         av_opt_freep_ranges(&r);
260         return ret;
261 }
262
263 float PluginFClient_Opt::get_float()
264 {
265         char val[BCTEXTLEN];  val[0] = 0;
266         get(val, sizeof(val));
267         return atof(val);
268 }
269
270 void PluginFClient_Opt::set_float(float v)
271 {
272         char val[BCTEXTLEN];  val[0] = 0;
273         sprintf(val, "%f", v);
274         set(val);
275 }
276
277 int PluginFClientPot::handle_event()
278 {
279         if( fwin->selected ) {
280                 fwin->selected->set_float(get_value());
281                 fwin->update_selected();
282                 return fwin->update();
283         }
284         return 1;
285 }
286
287 PluginFClientSlider::PluginFClientSlider(PluginFClientWindow *fwin, int x, int y)
288  : BC_FSlider(x, y, 0, fwin->get_w()-x-20, fwin->get_w()-x-20, 0.f, 0.f, 0.f)
289 {
290         this->fwin = fwin;
291 }
292
293 int PluginFClientSlider::handle_event()
294 {
295         if( fwin->selected ) {
296                 fwin->selected->set_float(get_value());
297                 fwin->update_selected();
298                 return fwin->update();
299         }
300         return 1;
301 }
302
303
304 PluginFClient_OptPanel::
305 PluginFClient_OptPanel(PluginFClientWindow *fwin, int x, int y, int w, int h)
306  : BC_ListBox(x, y, w, h, LISTBOX_TEXT), opts(items[0]), vals(items[1])
307 {
308         this->fwin = fwin;
309         update();  // init col/wid/columns
310 }
311
312 PluginFClient_OptPanel::
313 ~PluginFClient_OptPanel()
314 {
315 }
316
317 void PluginFClient_OptPanel::create_objects()
318 {
319         PluginFClientConfig &fconfig = fwin->ffmpeg->config;
320         for( int i=0; i<fconfig.size(); ++i ) {
321                 PluginFClient_Opt *opt = fconfig[i];
322                 opts.append(opt->item_name);
323                 vals.append(opt->item_value);
324         }
325 }
326
327 int PluginFClient_OptPanel::cursor_leave_event()
328 {
329         hide_tooltip();
330         return 0;
331 }
332
333 void PluginFClientWindow::update(PluginFClient_Opt *opt)
334 {
335         if( selected != opt ) {
336                 if( selected ) selected->item_name->set_selected(0);
337                 selected = opt;
338                 if( selected ) selected->item_name->set_selected(1);
339         }
340         clear_box(0,0, 0,panel->get_y());
341         char str[BCTEXTLEN], *sp;
342         *(sp=str) = 0;
343         if( opt ) opt->types(sp);
344         type->update(str);
345         *(sp=str) = 0;
346         if( opt ) opt->ranges(sp);
347         range->update(str);
348         while( units->total_items() ) units->del_item(0);
349         ArrayList<const AVOption *> opts;
350         int n = !opt ? 0 : opt->units(opts);
351         for( int i=0; i<n; ++i )
352                 units->add_item(new BC_MenuItem(opts[i]->name, 0));
353         char unit[BCSTRLEN];  strcpy(unit, "()");
354         if( units->total_items() && opt && opt->opt->unit )
355                 strcpy(unit, opt->opt->unit);
356         units->set_text(unit);
357         char val[BCTEXTLEN];  val[0] = 0;
358         if( opt ) opt->get(val, sizeof(val));
359         text->update(val);
360
361         float v = 0, fmn = 0, fmx = 0;
362         if( opt && !opt->get_range(fmn, fmx) ) v = atof(val);
363         float p = (fmx-fmn) / slider->get_w();
364         slider->set_precision(p);
365         slider->update(slider->get_w(), v, fmn, fmx);
366         pot->set_precision(p);
367         pot->update(v, fmn, fmx);
368         panel->update();
369 }
370
371 int PluginFClientWindow::update()
372 {
373         const char *txt = text->get_text();
374         if( txt && selected ) {
375                 selected->set(txt);
376                 selected->item_value->update();
377                 draw();
378                 ffmpeg->plugin->send_configure_change();
379         }
380         return 1;
381 }
382
383 void PluginFClientWindow::update_selected()
384 {
385         update(selected);
386 }
387
388 int PluginFClient_OptPanel::selection_changed()
389 {
390         PluginFClient_Opt *opt = 0;
391         BC_ListBoxItem *item = get_selection(0, 0);
392         if( item ) {
393                 PluginFClient_OptName *opt_name = (PluginFClient_OptName *)item;
394                 opt = opt_name->opt;
395         }
396         fwin->update(opt);
397         fwin->panel->set_tooltip(!opt ? 0 : opt->tip());
398         fwin->panel->show_tooltip();
399         return 1;
400 }
401
402 void *PluginFClient_Opt::filter_config()
403 {
404         return conf->filter_config();
405 }
406 const AVClass *PluginFClient_Opt::filter_class()
407 {
408         return conf->filter_class();
409 }
410
411 int PluginFClient_Opt::types(char *rp)
412 {
413         const char *cp;
414         switch (opt->type) {
415         case AV_OPT_TYPE_FLAGS: cp = "<flags>";  break;
416         case AV_OPT_TYPE_INT: cp = "<int>"; break;
417         case AV_OPT_TYPE_INT64: cp = "<int64>"; break;
418         case AV_OPT_TYPE_DOUBLE: cp = "<double>"; break;
419         case AV_OPT_TYPE_FLOAT: cp = "<float>"; break;
420         case AV_OPT_TYPE_STRING: cp = "<string>"; break;
421         case AV_OPT_TYPE_RATIONAL: cp = "<rational>"; break;
422         case AV_OPT_TYPE_BINARY: cp = "<binary>"; break;
423         case AV_OPT_TYPE_IMAGE_SIZE: cp = "<image_size>"; break;
424         case AV_OPT_TYPE_VIDEO_RATE: cp = "<video_rate>"; break;
425         case AV_OPT_TYPE_PIXEL_FMT: cp = "<pix_fmt>"; break;
426         case AV_OPT_TYPE_SAMPLE_FMT: cp = "<sample_fmt>"; break;
427         case AV_OPT_TYPE_DURATION: cp = "<duration>"; break;
428         case AV_OPT_TYPE_COLOR: cp = "<color>"; break;
429         case AV_OPT_TYPE_CHANNEL_LAYOUT: cp = "<channel_layout>";  break;
430         default: cp = "<undef>";  break;
431         }
432         return sprintf(rp, "%s", cp);
433 }
434 int PluginFClient_Opt::scalar(double d, char *rp)
435 {
436         const char *cp = 0;
437              if( d == INT_MAX ) cp = "INT_MAX";
438         else if( d == INT_MIN ) cp = "INT_MIN";
439         else if( d == UINT32_MAX ) cp = "UINT32_MAX";
440         else if( d == (double)INT64_MAX ) cp = "I64_MAX";
441         else if( d == INT64_MIN ) cp = "I64_MIN";
442         else if( d == FLT_MAX ) cp = "FLT_MAX";
443         else if( d == FLT_MIN ) cp = "FLT_MIN";
444         else if( d == -FLT_MAX ) cp = "-FLT_MAX";
445         else if( d == -FLT_MIN ) cp = "-FLT_MIN";
446         else if( d == DBL_MAX ) cp = "DBL_MAX";
447         else if( d == DBL_MIN ) cp = "DBL_MIN";
448         else if( d == -DBL_MAX ) cp = "-DBL_MAX";
449         else if( d == -DBL_MIN ) cp = "-DBL_MIN";
450         else if( d == 0 ) cp = signbit(d) ? "-0" : "0";
451         else if( isnan(d) ) cp = signbit(d) ? "-NAN" : "NAN";
452         else if( isinf(d) ) cp = signbit(d) ? "-INF" : "INF";
453         else return sprintf(rp, "%g", d);
454         return sprintf(rp, "%s", cp);
455 }
456
457 int PluginFClient_Opt::ranges(char *rp)
458 {
459         const AVClass *filt_class = filter_class();
460         if( !filt_class || !filt_class->option ) return 0;
461         switch (opt->type) {
462         case AV_OPT_TYPE_INT:
463         case AV_OPT_TYPE_INT64:
464         case AV_OPT_TYPE_DOUBLE:
465         case AV_OPT_TYPE_FLOAT: break;
466         default: return 0;;
467         }
468         AVOptionRanges *r = 0;
469         void *obj = &filt_class;
470         char *cp = rp;
471         if( av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ) < 0 ) return 0;
472         for( int i=0; i<r->nb_ranges; ++i ) {
473                 cp += sprintf(cp, " (");  cp += scalar(r->range[i]->value_min, cp);
474                 cp += sprintf(cp, "..");  cp += scalar(r->range[i]->value_max, cp);
475                 cp += sprintf(cp, ")");
476         }
477         av_opt_freep_ranges(&r);
478         return cp - rp;
479 }
480
481 int PluginFClient_Opt::units(ArrayList<const AVOption *> &opts)
482 {
483         if( !this->opt->unit ) return 0;
484         const AVClass *filt_class = filter_class();
485         if( !filt_class || !filt_class->option ) return 0;
486         void *obj = &filt_class;
487         const AVOption *opt = NULL;
488         while( (opt=av_opt_next(obj, opt)) != 0 ) {
489                 if( !opt->unit ) continue;
490                 if( opt->type != AV_OPT_TYPE_CONST ) continue;
491                 if( strcmp(this->opt->unit, opt->unit) ) continue;
492                 int i = opts.size();
493                 while( --i >= 0 ) {
494                         if( opts[i]->default_val.i64 != opt->default_val.i64 ) continue;
495                         if( strlen(opts[i]->name) < strlen(opt->name) ) opts[i] = opt;
496                         break;
497                 }
498                 if( i < 0 )
499                         opts.append(opt);
500         }
501         return opts.size();
502 }
503
504 int PluginFClient_Opt::units(char *rp)
505 {
506         ArrayList<const AVOption *> opts;
507         int n = units(opts);
508         if( !n ) return 0;
509         char *cp = rp;
510         cp += sprintf(cp, " [%s:", this->opt->unit);
511         for( int i=0; i<n; ++i )
512                 cp += sprintf(cp, " %s", opts[i]->name);
513         cp += sprintf(cp, "]:");
514         return cp - rp;
515 }
516
517 const char *PluginFClient_Opt::tip()
518 {
519         return opt->help;
520 }
521
522 int PluginFClient_OptPanel::update()
523 {
524         const char *cols[] = { "option", "value", };
525         const int col1_w = 150;
526         int wids[] = { col1_w, get_w()-col1_w };
527         BC_ListBox::update(&items[0], &cols[0], &wids[0], sizeof(items)/sizeof(items[0]),
528                 get_xposition(), get_yposition(), get_highlighted_item());
529         return 0;
530 }
531
532
533 PluginFClientWindow::PluginFClientWindow(PluginFClient *ffmpeg)
534  : PluginClientWindow(ffmpeg->plugin, 600, 300, 600, 300, 1)
535 {
536         this->ffmpeg = ffmpeg;
537         this->selected = 0;
538 }
539
540 PluginFClientWindow::~PluginFClientWindow()
541 {
542 }
543
544 void PluginFClientWindow::create_objects()
545 {
546         char string[BCTEXTLEN];
547         BC_Title *title;
548         int x = 10, y = 10;
549         const char *descr = ffmpeg->config.ffilt->description();
550         if( !descr ) descr = ffmpeg->config.ffilt->filter_name();
551         add_subwindow(title = new BC_Title(x, y, descr));
552         y += title->get_h() + 10;
553         int x0 = x;
554         sprintf(string, _("Type: "));
555         add_subwindow(title = new BC_Title(x0, y, string));
556         x0 += title->get_w() + 8;
557         add_subwindow(type = new BC_Title(x0, y, (char *)""));
558         x0 = x + 150;
559         sprintf(string, _("Range: "));
560         add_subwindow(title = new BC_Title(x0, y, string));
561         x0 += title->get_w() + 8;
562         add_subwindow(range = new BC_Title(x0, y, (char *)""));
563         int x1 = get_w() - BC_GenericButton::calculate_w(this, _("Reset")) - 8;
564         add_subwindow(reset = new PluginFClientReset(this, x1, y));
565         y += title->get_h() + 10;
566         x0 = x;
567         add_subwindow(units = new PluginFClientUnits(this, x0, y, 120));
568         x0 += units->get_w() + 8;
569         x1 = get_w() - BC_GenericButton::calculate_w(this, _("Apply")) - 8;
570         add_subwindow(apply = new PluginFClientApply(this, x1, y));
571         add_subwindow(text = new PluginFClientText(this, x0, y, x1-x0 - 8));
572         y += title->get_h() + 10;
573         add_subwindow(pot = new PluginFClientPot(this, x, y));
574         x1 = x + pot->get_w() + 10;
575         add_subwindow(slider = new PluginFClientSlider(this, x1, y+10));
576         y += pot->get_h() + 10;
577
578         panel_x = x;  panel_y = y;
579         panel_w = get_w()-10 - panel_x;
580         panel_h = get_h()-10 - panel_y;
581         panel = new PluginFClient_OptPanel(this, panel_x, panel_y, panel_w, panel_h);
582         add_subwindow(panel);
583         panel->create_objects();
584         ffmpeg->config.update();
585         draw();
586         show_window(1);
587 }
588
589 void PluginFClientWindow::draw()
590 {
591         update(selected);
592 }
593
594 int PluginFClientWindow::resize_event(int w, int h)
595 {
596         int x = get_w() - BC_GenericButton::calculate_w(this, _("Reset")) - 8;
597         int y = reset->get_y();
598         reset->reposition_window(x, y);
599         int x1 = get_w() - BC_GenericButton::calculate_w(this, _("Apply")) - 8;
600         int y1 = units->get_y();
601         apply->reposition_window(x1, y1);
602         int x0 = units->get_x() + units->get_w() + 8;
603         int y0 = units->get_y();
604         text->reposition_window(x0,y0, x1-x0-8);
605         x1 = pot->get_x() + pot->get_w() + 10;
606         int w1 = w - slider->get_x() - 20;
607         slider->set_pointer_motion_range(w1);
608         slider->reposition_window(x1, slider->get_y(), w1, slider->get_h());
609         panel_w = get_w()-10 - panel_x;
610         panel_h = get_h()-10 - panel_y;
611         panel->reposition_window(panel_x,panel_y, panel_w, panel_h);
612         return 1;
613 }
614
615
616 PluginFClient::PluginFClient(PluginClient *plugin, const char *name)
617 {
618         this->plugin = plugin;
619         this->name = name;
620         ffilt = 0;
621         fsrc = fsink = 0;
622         plugin_position = -1;
623         filter_position = -1;
624         activated = 0;
625         sprintf(title, "F_%s", name);
626         config.initialize(name);
627         curr_config.initialize(name);
628 }
629
630 PluginFClient::~PluginFClient()
631 {
632         delete ffilt;
633 }
634
635 bool PluginFClient::is_audio(const AVFilter *fp)
636 {
637         if( !fp->outputs ) return 0;
638         if( avfilter_pad_count(fp->outputs) > 1 ) return 0;
639         if( !avfilter_pad_get_name(fp->outputs, 0) ) return 0;
640         if( avfilter_pad_get_type(fp->outputs, 0) != AVMEDIA_TYPE_AUDIO ) return 0;
641         if( !fp->inputs ) return 1;
642         if( avfilter_pad_count(fp->inputs) > 1 ) return 0;
643         if( !avfilter_pad_get_name(fp->inputs, 0) ) return 0;
644         if( avfilter_pad_get_type(fp->inputs, 0) != AVMEDIA_TYPE_AUDIO ) return 0;
645         return 1;
646 }
647 bool PluginFClient::is_video(const AVFilter *fp)
648 {
649         if( !fp->outputs ) return 0;
650         if( avfilter_pad_count(fp->outputs) > 1 ) return 0;
651         if( !avfilter_pad_get_name(fp->outputs, 0) ) return 0;
652         if( avfilter_pad_get_type(fp->outputs, 0) != AVMEDIA_TYPE_VIDEO ) return 0;
653         if( !fp->inputs ) return 1;
654         if( avfilter_pad_count(fp->inputs) > 1 ) return 0;
655         if( !avfilter_pad_get_name(fp->inputs, 0) ) return 0;
656         if( avfilter_pad_get_type(fp->inputs, 0) != AVMEDIA_TYPE_VIDEO ) return 0;
657         return 1;
658 }
659
660 NEW_WINDOW_MACRO(PluginFClient, PluginFClientWindow)
661
662 int PluginFClient::load_configuration()
663 {
664         int64_t src_position =  get_source_position();
665         KeyFrame *prev_keyframe = get_prev_keyframe(src_position);
666         config.copy_from(curr_config);
667         read_data(prev_keyframe);
668         int ret = !config.equivalent(curr_config) ? 1 : 0;
669         return ret;
670 }
671
672
673 void PluginFClient::render_gui(void *data, int size)
674 {
675         PluginFClientConfig *conf = (PluginFClientConfig *)data;
676         config.copy_from(*conf);
677         KeyFrame *keyframe = plugin->server->get_keyframe();
678         save_data(keyframe);
679         update_gui();
680 }
681
682 void PluginFClient::update_gui()
683 {
684         PluginClientThread *thread = plugin->get_thread();
685         if( !thread ) return;
686         PluginFClientWindow *window = (PluginFClientWindow*)thread->get_window();
687         window->lock_window("PluginFClient::update_gui");
688         load_configuration();
689         if( config.update() > 0 )
690                 window->draw();
691         window->unlock_window();
692 }
693
694 const char *PluginFClient::plugin_title()
695 {
696         return title;
697 }
698
699 char *PluginFClient::to_upper(char *cp, const char *sp)
700 {
701         char *bp = cp;
702         while( *sp != 0 ) *bp++ = toupper(*sp++);
703         *bp = 0;
704         return cp;
705 }
706
707 void PluginFClient::save_data(KeyFrame *keyframe)
708 {
709         FileXML output;
710         char string[BCTEXTLEN];
711
712 // cause data to be stored directly in text
713         output.set_shared_output(keyframe->xbuf);
714         output.tag.set_title(to_upper(string, plugin_title()));
715         const AVClass *filt_class = config.filter_class();
716         if( filt_class && filt_class->option ) {
717                 void *obj = config.filter_config();
718                 const AVOption *opt = NULL;
719                 while( (opt=av_opt_next(obj, opt)) != 0 ) {
720                         uint8_t *buf = 0;
721                         if( av_opt_get(obj, opt->name, 0, &buf) < 0 ) continue;
722                         output.tag.set_property(opt->name, (const char *)buf);
723                         av_freep(&buf);
724                 }
725         }
726         if( (config.ffilt->filter->flags & AVFILTER_FLAG_SLICE_THREADS) != 0 ) {
727                 uint8_t *buf = 0;
728                 if( av_opt_get(config.ffilt->fctx, "threads", 0, &buf) >= 0 && buf ) {
729                         output.tag.set_property("threads", (const char *)buf);
730                         av_freep(&buf);
731                 }
732         }
733
734         output.append_tag();
735         output.terminate_string();
736 }
737
738 void PluginFClient::read_data(KeyFrame *keyframe)
739 {
740         FileXML input;
741         char string[BCTEXTLEN];
742         input.set_shared_input(keyframe->xbuf);
743
744         while( !input.read_tag() ) {
745                 to_upper(string, plugin_title());
746                 if( !input.tag.title_is(string) ) continue;
747                 const AVClass *filt_class = config.filter_class();
748                 if( filt_class && filt_class->option ) {
749                         void *obj = config.filter_config();
750                         const AVOption *opt = NULL;
751                         while( (opt=av_opt_next(obj, opt)) != 0 ) {
752                                 const char *v = input.tag.get_property(opt->name);
753                                 if( v ) av_opt_set(obj, opt->name, v, 0);
754                         }
755                         if( (config.ffilt->filter->flags & AVFILTER_FLAG_SLICE_THREADS) != 0 ) {
756                                 const char *v = input.tag.get_property("threads");
757                                 if( v ) av_opt_set(config.ffilt->fctx, "threads", v, 0);
758                         }
759                 }
760         }
761 }
762
763 int PluginFClient::activate()
764 {
765         if( fsrc )
766                 avfilter_link(fsrc, 0, ffilt->fctx, 0);
767         avfilter_link(ffilt->fctx, 0, fsink, 0);
768         int ret = avfilter_graph_config(ffilt->graph, NULL);
769         if( ret >= 0 ) {
770                 curr_config.copy_from(config);
771                 activated = 1;
772         }
773         return ret;
774 }
775
776 void PluginFClient::reactivate()
777 {
778         delete ffilt;  ffilt = 0;
779         activated = 0;
780 }
781
782 PluginFAClient::PluginFAClient(PluginServer *server, const char *name)
783  : PluginAClient(server), PluginFClient(this, name)
784 {
785 }
786
787 PluginFAClient::~PluginFAClient()
788 {
789 }
790
791 int PluginFAClient::activate()
792 {
793         if( activated ) return activated;
794         ffilt = PluginFFilter::new_ffilter(name, &config);
795         if( !ffilt ) {
796                 config.copy_from(curr_config);
797                 send_configure_change();
798                 send_render_gui(&config, sizeof(config));
799                 ffilt = PluginFFilter::new_ffilter(name, &config);
800         }
801         AVSampleFormat sample_fmt = AV_SAMPLE_FMT_FLTP;
802         int channels = PluginClient::total_in_buffers;
803         uint64_t layout = (((uint64_t)1)<<channels) - 1;
804         AVFilterGraph *graph = !ffilt ? 0 : ffilt->graph;
805         int ret = !graph ? -1 : 0;
806         if( ret >= 0 && ffilt->filter->inputs ) {
807                 char args[BCTEXTLEN];
808                 snprintf(args, sizeof(args),
809                         "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%jx",
810                         1, sample_rate, sample_rate, av_get_sample_fmt_name(sample_fmt), layout);
811                 ret = avfilter_graph_create_filter(&fsrc, avfilter_get_by_name("abuffer"),
812                         "in", args, NULL, graph);
813         }
814         if( ret >= 0 )
815                 ret = avfilter_graph_create_filter(&fsink, avfilter_get_by_name("abuffersink"),
816                         "out", NULL, NULL, graph);
817         if( ret >= 0 )
818                 ret = av_opt_set_bin(fsink, "sample_fmts",
819                         (uint8_t*)&sample_fmt, sizeof(sample_fmt), AV_OPT_SEARCH_CHILDREN);
820         if( ret >= 0 )
821                 ret = av_opt_set_bin(fsink, "channel_layouts",
822                         (uint8_t*)&layout, sizeof(layout), AV_OPT_SEARCH_CHILDREN);
823         if( ret >= 0 )
824                 ret = av_opt_set_bin(fsink, "sample_rates",
825                         (uint8_t*)&sample_rate, sizeof(sample_rate), AV_OPT_SEARCH_CHILDREN);
826         if( ret >= 0 )
827                 ret = PluginFClient::activate();
828         if( ret < 0 && activated >= 0 ) {
829                 ff_err(ret, "PluginFAClient::activate: %s failed\n", plugin_title());
830                 activated = -1;
831         }
832         return activated;
833 }
834
835
836 static AVRational best_frame_rate(double frame_rate)
837 {
838         static const int m1 = 1001*12, m2 = 1000*12;
839         static const int freqs[] = {
840                 40*m1, 48*m1, 50*m1, 60*m1, 80*m1,120*m1, 240*m1,
841                 24*m2, 30*m2, 60*m2, 12*m2, 15*m2, 48*m2, 0,
842         };
843         double max_err = 1.;
844         int freq, best_freq = 0;
845         for( int i=0; (freq = i<30*12 ? (i+1)*1001 : freqs[i-30*12]); ++i ) {
846                 double framerate = (double)freq / m1;
847                 double err = fabs(frame_rate/framerate - 1.);
848                 if( err >= max_err ) continue;
849                 max_err = err;
850                 best_freq = freq;
851         }
852         return max_err < 0.0001 ?
853                 (AVRational) { best_freq, m1 } :
854                 (AVRational) { 0, 0 };
855 }
856
857 int PluginFVClient::activate(int width, int height, int color_model)
858 {
859         if( activated ) return activated;
860         ffilt = PluginFFilter::new_ffilter(name, &config);
861         if( !ffilt ) {
862                 config.copy_from(curr_config);
863                 send_configure_change();
864                 send_render_gui(&config, sizeof(config));
865                 ffilt = PluginFFilter::new_ffilter(name, &config);
866         }
867         AVPixelFormat pix_fmt = color_model_to_pix_fmt(color_model);
868         AVFilterGraph *graph = !ffilt ? 0 : ffilt->graph;
869         int ret = !graph ? -1 : 0;
870         if( ret >= 0 && ffilt->filter->inputs ) {
871                 curr_config.copy_from(config);
872                 if( pix_fmt == AV_PIX_FMT_NB ) {
873                         int bpp = BC_CModels::calculate_pixelsize(color_model) * 8;
874                         int bits_per_comp = bpp / BC_CModels::components(color_model);
875                         int alpha =  BC_CModels::has_alpha(color_model);
876                         pix_fmt = bits_per_comp > 8 ?
877                                 !alpha ? AV_PIX_FMT_RGB48LE : AV_PIX_FMT_RGBA64LE :
878                                 !alpha ? AV_PIX_FMT_RGB24 : AV_PIX_FMT_RGBA ;
879                 }
880                 int aspect_w = 1, aspect_h = 1; // XXX
881                 AVRational best_rate = best_frame_rate(frame_rate);
882                 char args[BCTEXTLEN];
883                 snprintf(args, sizeof(args),
884                         "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
885                         width, height, pix_fmt, best_rate.num, best_rate.den, aspect_w, aspect_h);
886                 ret = avfilter_graph_create_filter(&fsrc, avfilter_get_by_name("buffer"),
887                         "in", args, NULL, graph);
888         }
889         if( ret >= 0 )
890                 ret = avfilter_graph_create_filter(&fsink, avfilter_get_by_name("buffersink"),
891                         "out", NULL, NULL, graph);
892         if( ret >= 0 )
893                 ret = av_opt_set_bin(fsink, "pix_fmts",
894                         (uint8_t*)&pix_fmt, sizeof(pix_fmt), AV_OPT_SEARCH_CHILDREN);
895         if( ret >= 0 )
896                 ret = PluginFClient::activate();
897         if( ret < 0 && activated >= 0 ) {
898                 ff_err(ret, "PluginFVClient::activate() %s\n", plugin_title());
899                 activated = -1;
900         }
901         return activated;
902 }
903
904 int PluginFAClient::get_inchannels()
905 {
906         AVFilterContext *fctx = ffilt->fctx;
907         AVFilterLink **links = !fctx->nb_inputs ? 0 : fctx->inputs;
908         return !links ? 0 : links[0]->channels;
909 }
910
911 int PluginFAClient::get_outchannels()
912 {
913         AVFilterContext *fctx = ffilt->fctx;
914         AVFilterLink **links = !fctx->nb_outputs ? 0 : fctx->outputs;
915         return !links ? 0 : links[0]->channels;
916 }
917
918 int PluginFAClient::process_buffer(int64_t size, Samples **buffer, int64_t start_position, int sample_rate)
919 {
920         int total_in = PluginClient::total_in_buffers;
921         int total_out = PluginClient::total_out_buffers;
922         int in_channels = 0, out_channels = 0;
923
924         if( load_configuration() )
925                 reactivate();
926
927         if( plugin_position != start_position )
928                 filter_position = plugin_position = start_position;
929
930         AVFrame *frame = 0;
931         int ret = activate();
932         if( ret >= 0 && !(frame = av_frame_alloc()) ) {
933                 fprintf(stderr, "PluginFAClient::process_buffer: av_frame_alloc failed\n");
934                 ret = AVERROR(ENOMEM);
935         }
936         if( ret >= 0 ) {
937                 in_channels = get_inchannels();
938                 out_channels = get_outchannels();
939                 frame->nb_samples = size;
940                 frame->format = AV_SAMPLE_FMT_FLTP;
941                 frame->channel_layout = (1<<in_channels)-1;
942                 frame->sample_rate = sample_rate;
943                 frame->pts = local_to_edl(filter_position);
944         }
945
946         int retry = 10;
947         while( ret >= 0 && --retry >= 0 ) {
948                 ret = av_buffersink_get_frame(fsink, frame);
949                 if( ret >= 0 || ret != AVERROR(EAGAIN) ) break;
950                 if( !fsrc ) { ret = AVERROR(EIO);  break; }
951                 for( int i=0; i<total_in; ++i )
952                         read_samples(buffer[i], i, sample_rate, filter_position, size);
953                 filter_position += size;
954                 ret = av_frame_get_buffer(frame, 0);
955                 if( ret < 0 ) break;
956                 float **in_buffers = (float **)&frame->extended_data[0];
957                 for(int i = 0; i < in_channels; i++) {
958                         float *in_buffer = in_buffers[i];
959                         int k = i < total_in ? i : 0;
960                         double *in_ptr = buffer[k]->get_data();
961                         for(int j = 0; j < size; j++) in_buffer[j] = in_ptr[j];
962                 }
963                 ret = av_buffersrc_add_frame_flags(fsrc, frame, 0);
964         }
965         if( ret >= 0 && retry < 0 )
966                 ret = AVERROR(EAGAIN);
967
968         if( ret >= 0 ) {
969                 int nbfrs = total_out;
970                 if( out_channels < nbfrs ) nbfrs = out_channels;
971                 float **out_buffers = (float **)&frame->extended_data[0];
972                 int i = 0;
973                 while( i < nbfrs ) {
974                         float *out_buffer = out_buffers[i];
975                         double *out_ptr = buffer[i++]->get_data();
976                         for(int j = 0; j < size; j++) out_ptr[j] = out_buffer[j];
977                 }
978                 while( i < total_out ) {
979                         double *out_ptr = buffer[i++]->get_data();
980                         bzero(out_ptr, sizeof(double) * size);
981                 }
982         }
983         if( ret < 0 ) {
984                 int64_t position = PluginFClient::get_source_position();
985                 double t0 = (double)position/sample_rate, dt = 1./sample_rate;
986                 for( int i=0; i<total_out; ++i ) {
987                         double t = t0, *out = buffer[i]->get_data();
988                         for( int k=size; --k>=0; t+=dt ) {
989                                 double w = int(2*t) & 1 ? 2*M_PI*440 : 2*M_PI*697;
990                                 *out++ = sin(t * w);
991                         }
992                 }
993                 ff_err(ret, "PluginFAClient::process_buffer() %s\n", plugin_title());
994         }
995
996         av_frame_free(&frame);
997         plugin_position += size;
998         return size;
999 }
1000
1001
1002 PluginFVClient::PluginFVClient(PluginServer *server, const char *name)
1003  : PluginVClient(server), PluginFClient(this, name)
1004 {
1005 }
1006
1007 PluginFVClient::~PluginFVClient()
1008 {
1009 }
1010
1011 int PluginFVClient::process_buffer(VFrame **frames, int64_t position, double frame_rate)
1012 {
1013         VFrame *vframe = *frames;
1014         int width = vframe->get_w();
1015         int height = vframe->get_h();
1016
1017         if( load_configuration() )
1018                 reactivate();
1019
1020         if( plugin_position != position )
1021                 filter_position = plugin_position = position;
1022
1023         int colormodel = vframe->get_color_model();
1024         int ret = activate(width, height, colormodel);
1025         AVPixelFormat pix_fmt = fsrc ?
1026                 (AVPixelFormat) fsrc->outputs[0]->format :
1027                 color_model_to_pix_fmt(colormodel);
1028         if( pix_fmt <= AV_PIX_FMT_NONE || pix_fmt >= AV_PIX_FMT_NB )
1029                 pix_fmt = AV_PIX_FMT_RGBA;
1030
1031         AVFrame *frame = 0;
1032         if( ret >= 0 && !(frame = av_frame_alloc()) ) {
1033                 fprintf(stderr, "PluginFVClient::process_buffer: av_frame_alloc failed\n");
1034                 ret = AVERROR(ENOMEM);
1035         }
1036
1037         int retry = 10;
1038         while( ret >= 0 && --retry >= 0 ) {
1039                 ret = av_buffersink_get_frame(fsink, frame);
1040                 if( ret >= 0 || ret != AVERROR(EAGAIN) ) break;
1041                 if( !fsrc ) { ret = AVERROR(EIO);  break; }
1042                 read_frame(vframe, 0, filter_position++, frame_rate, 0);
1043                 frame->format = pix_fmt;
1044                 frame->width  = width;
1045                 frame->height = height;
1046                 frame->pts = local_to_edl(position);
1047                 ret = av_frame_get_buffer(frame, 32);
1048                 if( ret < 0 ) break;
1049                 ret = transfer_pixfmt(vframe, frame);
1050                 if( ret < 0 ) break;
1051                 ret = av_buffersrc_add_frame_flags(fsrc, frame, 0);
1052         }
1053         if( ret >= 0 && retry < 0 )
1054                 ret = AVERROR(EAGAIN);
1055
1056         if( ret >= 0 ) {
1057                 pix_fmt = (AVPixelFormat) frame->format;
1058                 ret = transfer_cmodel(vframe, frame);
1059         }
1060         if( ret < 0 ) {
1061                 ff_err(ret, "PluginFVClient::process_buffer() %s\n", plugin_title());
1062                 if( position & 1 ) vframe->clear_frame();
1063         }
1064
1065         ++plugin_position;
1066         av_frame_free(&frame);
1067         return ret >= 0 ? 0 : 1;
1068 }
1069
1070
1071 PluginFClient_OptName:: PluginFClient_OptName(PluginFClient_Opt *opt)
1072 {
1073         this->opt = opt;
1074         set_text(opt->opt->name);
1075 }
1076
1077 PluginFClient_OptValue::PluginFClient_OptValue(PluginFClient_Opt *opt)
1078 {
1079         this->opt = opt;
1080         update();
1081 }
1082
1083 void PluginFClient_OptValue::update()
1084 {
1085         char val[BCTEXTLEN];  val[0] = 0;
1086         opt->get(val, sizeof(val));
1087         set_text(val);
1088 }
1089
1090
1091 PluginFClient_Opt::PluginFClient_Opt(PluginFClientConfig *conf, const AVOption *opt)
1092 {
1093         this->conf = conf;
1094         this->opt = opt;
1095         item_name = new PluginFClient_OptName(this);
1096         item_value = new PluginFClient_OptValue(this);
1097 }
1098
1099 PluginFClient_Opt::~PluginFClient_Opt()
1100 {
1101         delete item_name;
1102         delete item_value;
1103 }
1104
1105 const char *PluginFClientConfig::get(const char *name)
1106 {
1107         uint8_t *bp = 0;
1108         if( av_opt_get(filter_config(), name, 0, &bp) >= 0 ||
1109             av_opt_get(ffilt->fctx, name, 0, &bp) >= 0 )
1110                 return (const char *)bp;
1111         return 0;
1112 }
1113 char *PluginFClient_Opt::get(char *vp, int sz)
1114 {
1115         const char *val = conf->get(opt->name);
1116         if( val ) {
1117                 strncpy(vp, val, sz);
1118                 vp[sz-1] = 0;
1119         }
1120         else
1121                 vp = 0;
1122         av_freep(&val);
1123         return vp;
1124 }
1125
1126 void PluginFClientConfig::set(const char *name, const char *val)
1127 {
1128         if( av_opt_set(filter_config(), name, val, 0) < 0 )
1129                 av_opt_set(ffilt->fctx, name, val, 0);
1130 }
1131 void PluginFClient_Opt::set(const char *val)
1132 {
1133         conf->set(opt->name, val);
1134 }
1135
1136 void PluginFFilter::uninit()
1137 {
1138 }
1139
1140 static int get_defaults(const char *name, char *args)
1141 {
1142         *args = 0;
1143         char defaults_path[BCTEXTLEN];
1144         FFMPEG::set_option_path(defaults_path, "plugin.opts");
1145         FILE *fp = fopen(defaults_path,"r");
1146         if( !fp ) return 0;
1147         char ff_plugin[BCSTRLEN], ff_args[BCTEXTLEN], *ap = 0;
1148         while( fgets(ff_args, sizeof(ff_args), fp) ) {
1149                 char *cp = ff_args;
1150                 if( *cp == ';' ) continue;
1151                 if( *cp == '#' ) ++cp;
1152                 char *bp = ff_plugin, *ep = bp + sizeof(ff_plugin)-1;
1153                 while( bp < ep && *cp && *cp != '\n' && *cp != ' ' ) *bp++ = *cp++;
1154                 *bp = 0;
1155                 if( !strcmp(ff_plugin, name) ) { ap = cp;  break; }
1156         }
1157         fclose(fp);
1158         if( !ap ) return 0;
1159         if( ff_args[0] == '#' ) return -1;
1160         while( *ap == ' ' ) ++ap;
1161         while( *ap && *ap != '\n' ) *args++ = *ap++;
1162         *args = 0;
1163         return 1;
1164 }
1165
1166 bool PluginFFilter::is_audio()
1167 {
1168         return PluginFClient::is_audio(filter);
1169 }
1170
1171 bool PluginFFilter::is_video()
1172 {
1173         return PluginFClient::is_video(filter);
1174 }
1175
1176 int PluginFFilter::init(const char *name, PluginFClientConfig *conf)
1177 {
1178         char args[BCTEXTLEN];
1179         int ret = get_defaults(name, args);
1180         if( ret < 0 ) return 0;
1181         PluginFLogLevel errs(AV_LOG_ERROR);
1182         this->filter = avfilter_get_by_name(name);
1183         if( !this->filter ) return AVERROR(ENOENT);
1184         int flag_mask = AVFILTER_FLAG_DYNAMIC_INPUTS | AVFILTER_FLAG_DYNAMIC_OUTPUTS;
1185         if( filter->flags & flag_mask ) return AVERROR(EPERM);
1186         if( !this->is_audio() && !this->is_video() ) return AVERROR(EIO);
1187         this->graph = avfilter_graph_alloc();
1188         if( !this->graph ) return AVERROR(ENOMEM);
1189         static int inst = 0;
1190         char inst_name[BCSTRLEN];
1191         sprintf(inst_name,"%s_%d", name, ++inst);
1192         if( conf && (filter->flags & AVFILTER_FLAG_SLICE_THREADS) != 0 ) {
1193                 graph->thread_type = AVFILTER_THREAD_SLICE;
1194                 graph->nb_threads  = atoi(conf->get("threads"));
1195         }
1196         else {
1197                 graph->thread_type = 0;
1198                 graph->nb_threads  = 0;
1199         }
1200         fctx = avfilter_graph_alloc_filter(graph, filter, inst_name);
1201         if( !fctx ) return AVERROR(ENOMEM);
1202         fctx->thread_type = graph->thread_type; // bug in avfilter
1203         if( conf ) {
1204                 AVDictionary *opts = 0;
1205                 for( int i=0; i<conf->size(); ++i ) {
1206                         PluginFClient_Opt *op = conf->get(i);
1207                         const char *name = op->opt->name;
1208                         char val[BCTEXTLEN], *vp = op->get(val, sizeof(val));
1209                         if( !vp ) continue;
1210                         uint8_t *bp = 0;
1211 // unspecified opts cause a special behavior in some filters (lut3d)
1212 // so... if opt value is the default, skip it or no special behavior
1213                         if( av_opt_get(filter_config(), name, 0, &bp) >= 0 ) {
1214                                 int result = strcmp((const char *)bp, vp);
1215                                 av_freep(&bp);
1216                                 if( !result ) continue;
1217                         }
1218                         av_dict_set(&opts, name, vp, 0);
1219                 }
1220                 ret = avfilter_init_dict(fctx, &opts);
1221                 av_dict_free(&opts);
1222         }
1223         else
1224                 ret = avfilter_init_str(fctx, args);
1225         return ret < 0 ? ret : 1;
1226 }
1227
1228
1229 PluginFFilter::PluginFFilter()
1230 {
1231         filter = 0;
1232         graph = 0;
1233         fctx = 0;
1234 }
1235
1236 PluginFFilter::~PluginFFilter()
1237 {
1238         PluginFLogLevel errs(AV_LOG_ERROR);
1239         avfilter_graph_free(&graph);
1240         filter = 0;  fctx = 0;
1241 }
1242
1243 PluginFFilter *PluginFFilter::new_ffilter(const char *name, PluginFClientConfig *conf)
1244 {
1245         PluginFFilter *ffilt = new PluginFFilter;
1246         int ret = ffilt->init(name, conf);
1247         if( ret < 0 ) ff_err(ret, "PluginFFilter::new_ffilter(%s)\n", name);
1248         if( ret <= 0 ) { delete ffilt;  ffilt = 0; }
1249         return ffilt;
1250 }
1251
1252 PluginClient *PluginServer::new_ffmpeg_plugin()
1253 {
1254         const AVFilter *filter = avfilter_get_by_name(ff_name);
1255         if( !filter ) return 0;
1256         PluginFClient *ffmpeg =
1257                 PluginFClient::is_audio(filter) ?
1258                         (PluginFClient *)new PluginFAClient(this, ff_name) :
1259                 PluginFClient::is_video(filter) ?
1260                         (PluginFClient *)new PluginFVClient(this, ff_name) :
1261                 0;
1262         if( !ffmpeg ) return 0;
1263         return ffmpeg->plugin;
1264 }
1265
1266
1267 PluginServer* MWindow::new_ffmpeg_server(MWindow *mwindow, const char *name)
1268 {
1269         PluginFFilter *ffilt = PluginFFilter::new_ffilter(name);
1270         if( !ffilt ) return 0;
1271         delete ffilt;
1272         return new PluginServer(mwindow, name, PLUGIN_TYPE_FFMPEG);
1273 }
1274
1275 void MWindow::init_ffmpeg_index(MWindow *mwindow, Preferences *preferences, FILE *fp)
1276 {
1277         PluginFLogLevel errs(AV_LOG_ERROR);
1278         const AVFilter *filter = 0;  void *idx = 0;
1279         while( (filter=av_filter_iterate(&idx)) != 0 ) {
1280 //printf("%s\n",filter->name);
1281                 PluginServer *server = new_ffmpeg_server(mwindow, filter->name);
1282                 if( server ) {
1283                         int result = server->open_plugin(1, preferences, 0, 0);
1284                         if( !result ) {
1285                                 server->write_table(fp, filter->name, PLUGIN_FFMPEG_ID, 0);
1286                                 server->close_plugin();
1287                         }
1288                         delete server;
1289                         if( result ) fprintf(fp, "#%s\n", filter->name);
1290                 }
1291         }
1292 }
1293
1294 void MWindow::init_ffmpeg()
1295 {
1296 }
1297