git.sesse.net Git - vlc/blob - src/modules/entry.c

   1 /*****************************************************************************
   2  * entry.c : Callbacks for module entry point
   3  *****************************************************************************
   4  * Copyright (C) 2007 the VideoLAN team
   5  * Copyright © 2007-2008 Rémi Denis-Courmont
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  20  *****************************************************************************/
  21
  22 #ifdef HAVE_CONFIG_H
  23 # include "config.h"
  24 #endif
  25
  26 #include <vlc_common.h>
  27 #include <vlc_plugin.h>
  28 #include <assert.h>
  29 #include <stdarg.h>
  30
  31 #include "modules/modules.h"
  32 #include "config/configuration.h"
  33 #include "libvlc.h"
  34 #ifndef ENABLE_NLS
  35 # define dgettext(d, m) ((char *)(m))
  36 #endif
  37
  38 static void vlc_module_destruct (gc_object_t *obj)
  39 {
  40     module_t *module = vlc_priv (obj, module_t);
  41
  42     vlc_mutex_destroy (&module->lock);
  43     free (module);
  44 }
  45
  46 static const char default_name[] = "unnamed";
  47
  48 module_t *vlc_module_create (vlc_object_t *obj)
  49 {
  50     module_t *module = malloc (sizeof (*module));
  51     if (module == NULL)
  52         return NULL;
  53
  54     module->psz_object_name = strdup( default_name );
  55     module->next = NULL;
  56     module->submodule = NULL;
  57     module->parent = NULL;
  58     module->submodule_count = 0;
  59     vlc_gc_init (module, vlc_module_destruct);
  60     vlc_mutex_init (&module->lock);
  61
  62     module->psz_shortname = NULL;
  63     module->psz_longname = (char*)default_name;
  64     module->psz_help = NULL;
  65     for (unsigned i = 0; i < MODULE_SHORTCUT_MAX; i++)
  66         module->pp_shortcuts[i] = NULL;
  67     module->psz_capability = (char*)"";
  68     module->i_score = 1;
  69     module->i_cpu = 0;
  70     module->b_unloadable = true;
  71     module->b_reentrant = true;
  72     module->b_submodule = false;
  73     module->pf_activate = NULL;
  74     module->pf_deactivate = NULL;
  75     module->p_config = NULL;
  76     module->confsize = 0;
  77     module->i_config_items = 0;
  78     module->i_bool_items = 0;
  79     /*module->handle = garbage */
  80     module->psz_filename = NULL;
  81     module->b_builtin = false;
  82     module->b_loaded = false;
  83
  84     (void)obj;
  85     return module;
  86 }
  87
  88
  89 static void vlc_submodule_destruct (gc_object_t *obj)
  90 {
  91     module_t *module = vlc_priv (obj, module_t);
  92     free (module);
  93 }
  94
  95 module_t *vlc_submodule_create (module_t *module)
  96 {
  97     assert (module != NULL);
  98
  99     module_t *submodule = malloc (sizeof (*submodule));
 100     if (submodule == NULL)
 101         return NULL;
 102
 103     memset (submodule, 0, sizeof (*submodule));
 104     vlc_gc_init (submodule, vlc_submodule_destruct);
 105
 106     submodule->next = module->submodule;
 107     submodule->parent = module;
 108     module->submodule = submodule;
 109     module->submodule_count++;
 110
 111     /* Muahahaha! Heritage! Polymorphism! Ugliness!! */
 112     memcpy (submodule->pp_shortcuts, module->pp_shortcuts,
 113             sizeof (submodule->pp_shortcuts));
 114
 115     submodule->psz_object_name = strdup( module->psz_object_name );
 116     submodule->psz_shortname = module->psz_shortname;
 117     submodule->psz_longname = module->psz_longname;
 118     submodule->psz_capability = module->psz_capability;
 119     submodule->i_score = module->i_score;
 120     submodule->i_cpu = module->i_cpu;
 121     submodule->b_submodule = true;
 122     return submodule;
 123 }
 124
 125
 126 int vlc_module_set (module_t *module, int propid, ...)
 127 {
 128     va_list ap;
 129     int ret = VLC_SUCCESS;
 130
 131     va_start (ap, propid);
 132     switch (propid)
 133     {
 134         case VLC_MODULE_CPU_REQUIREMENT:
 135             assert (!module->b_submodule);
 136             module->i_cpu |= va_arg (ap, int);
 137             break;
 138
 139         case VLC_MODULE_SHORTCUT:
 140         {
 141             unsigned i;
 142             for (i = 0; module->pp_shortcuts[i] != NULL; i++);
 143             if (i >= (MODULE_SHORTCUT_MAX - 1))
 144             {
 145                 ret = VLC_ENOMEM;
 146                 break;
 147             }
 148
 149             module->pp_shortcuts[i] = va_arg (ap, char *);
 150             break;
 151         }
 152
 153         case VLC_MODULE_SHORTNAME_NODOMAIN:
 154         {
 155             const char *name = va_arg (ap, char *);
 156             ret = vlc_module_set (module, VLC_MODULE_SHORTNAME, NULL, name);
 157             break;
 158         }
 159
 160         case VLC_MODULE_DESCRIPTION_NODOMAIN:
 161         {
 162             const char *desc = va_arg (ap, char *);
 163             ret = vlc_module_set (module, VLC_MODULE_DESCRIPTION, NULL, desc);
 164             break;
 165         }
 166
 167         case VLC_MODULE_HELP_NODOMAIN:
 168         {
 169             const char *help = va_arg (ap, char *);
 170             ret = vlc_module_set (module, VLC_MODULE_HELP, NULL, help);
 171             break;
 172         }
 173
 174         case VLC_MODULE_CAPABILITY:
 175             module->psz_capability = va_arg (ap, char *);
 176             break;
 177
 178         case VLC_MODULE_SCORE:
 179             module->i_score = va_arg (ap, int);
 180             break;
 181
 182         case VLC_MODULE_PROGRAM:
 183             fprintf (stderr, "deprecated module property %d", propid);
 184             break;
 185
 186         case VLC_MODULE_CB_OPEN:
 187             module->pf_activate = va_arg (ap, int (*) (vlc_object_t *));
 188             break;
 189
 190         case VLC_MODULE_CB_CLOSE:
 191             module->pf_deactivate = va_arg (ap, void (*) (vlc_object_t *));
 192             break;
 193
 194         case VLC_MODULE_NO_UNLOAD:
 195             module->b_unloadable = false;
 196             break;
 197
 198         case VLC_MODULE_NAME:
 199         {
 200             const char *value = va_arg (ap, const char *);
 201             free( module->psz_object_name );
 202             module->psz_object_name = strdup( value );
 203             module->pp_shortcuts[0] = (char*)value; /* dooh! */
 204             if (module->psz_longname == default_name)
 205                 module->psz_longname = (char*)value; /* dooh! */
 206             break;
 207         }
 208
 209         case VLC_MODULE_SHORTNAME:
 210         {
 211             const char *domain = va_arg (ap, const char *);
 212             if (domain == NULL)
 213                 domain = PACKAGE;
 214             module->psz_shortname = dgettext (domain, va_arg (ap, char *));
 215             break;
 216         }
 217
 218         case VLC_MODULE_DESCRIPTION:
 219         {
 220             const char *domain = va_arg (ap, const char *);
 221             if (domain == NULL)
 222                 domain = PACKAGE;
 223             module->psz_longname = dgettext (domain, va_arg (ap, char *));
 224             break;
 225         }
 226
 227         case VLC_MODULE_HELP:
 228         {
 229             const char *domain = va_arg (ap, const char *);
 230             if (domain == NULL)
 231                 domain = PACKAGE;
 232             module->psz_help = dgettext (domain, va_arg (ap, char *));
 233             break;
 234         }
 235
 236         default:
 237             fprintf (stderr, "LibVLC: unknown module property %d", propid);
 238             fprintf (stderr, "LibVLC: too old to use this module?");
 239             ret = VLC_EGENERIC;
 240             break;
 241     }
 242     va_end (ap);
 243     return ret;
 244 }
 245
 246 module_config_t *vlc_config_create (module_t *module, int type)
 247 {
 248     unsigned confsize = module->confsize;
 249     module_config_t *tab = module->p_config;
 250
 251     if ((confsize & 0xf) == 0)
 252     {
 253         tab = realloc (tab, (confsize + 17) * sizeof (*tab));
 254         if (tab == NULL)
 255             return NULL;
 256
 257         module->p_config = tab;
 258     }
 259
 260     memset (tab + confsize, 0, sizeof (tab[confsize]));
 261     tab[confsize].i_type = type;
 262     tab[confsize].p_lock = &module->lock;
 263
 264     if (type & CONFIG_ITEM)
 265     {
 266         module->i_config_items++;
 267         if (type == CONFIG_ITEM_BOOL)
 268             module->i_bool_items++;
 269     }
 270
 271     module->confsize++;
 272     return tab + confsize;
 273 }
 274
 275 int vlc_config_set (module_config_t *restrict item, int id, ...)
 276 {
 277     int ret = -1;
 278     va_list ap;
 279
 280     assert (item != NULL);
 281     va_start (ap, id);
 282
 283     switch (id)
 284     {
 285         case VLC_CONFIG_NAME:
 286         {
 287             const char *name = va_arg (ap, const char *);
 288             vlc_callback_t cb = va_arg (ap, vlc_callback_t);
 289
 290             assert (name != NULL);
 291             item->psz_name = strdup (name);
 292             item->pf_callback = cb;
 293             ret = 0;
 294             break;
 295         }
 296
 297         case VLC_CONFIG_DESC_NODOMAIN:
 298         {
 299             const char *text = va_arg (ap, const char *);
 300             const char *longtext = va_arg (ap, const char *);
 301             ret = vlc_config_set (item, VLC_CONFIG_DESC, NULL, text, longtext);
 302             break;
 303         }
 304
 305         case VLC_CONFIG_VALUE:
 306         {
 307             if (IsConfigIntegerType (item->i_type))
 308             {
 309                 item->orig.i = item->saved.i =
 310                 item->value.i = va_arg (ap, int);
 311                 ret = 0;
 312             }
 313             else
 314             if (IsConfigFloatType (item->i_type))
 315             {
 316                 item->orig.f = item->saved.f =
 317                 item->value.f = va_arg (ap, double);
 318                 ret = 0;
 319             }
 320             else
 321             if (IsConfigStringType (item->i_type))
 322             {
 323                 const char *value = va_arg (ap, const char *);
 324                 item->value.psz = value ? strdup (value) : NULL;
 325                 item->orig.psz = value ? strdup (value) : NULL;
 326                 item->saved.psz = value ? strdup (value) : NULL;
 327                 ret = 0;
 328             }
 329             break;
 330         }
 331
 332         case VLC_CONFIG_RANGE:
 333         {
 334             if (IsConfigIntegerType (item->i_type))
 335             {
 336                 item->min.i = va_arg (ap, int);
 337                 item->max.i = va_arg (ap, int);
 338                 ret = 0;
 339             }
 340             else
 341             if (IsConfigFloatType (item->i_type))
 342             {
 343                 item->min.f = va_arg (ap, double);
 344                 item->max.f = va_arg (ap, double);
 345                 ret = 0;
 346             }
 347             break;
 348         }
 349
 350         case VLC_CONFIG_ADVANCED:
 351             item->b_advanced = true;
 352             ret = 0;
 353             break;
 354
 355         case VLC_CONFIG_VOLATILE:
 356             item->b_unsaveable = true;
 357             ret = 0;
 358             break;
 359
 360         case VLC_CONFIG_PERSISTENT:
 361             item->b_autosave = true;
 362             ret = 0;
 363             break;
 364
 365         case VLC_CONFIG_RESTART:
 366             item->b_restart = true;
 367             ret = 0;
 368             break;
 369
 370         case VLC_CONFIG_PRIVATE:
 371             item->b_internal = true;
 372             ret = 0;
 373             break;
 374
 375         case VLC_CONFIG_REMOVED:
 376             item->b_removed = true;
 377             ret = 0;
 378             break;
 379
 380         case VLC_CONFIG_CAPABILITY:
 381         {
 382             const char *cap = va_arg (ap, const char *);
 383             item->psz_type = cap ? strdup (cap) : NULL;
 384             ret = 0;
 385             break;
 386         }
 387
 388         case VLC_CONFIG_SHORTCUT:
 389             item->i_short = va_arg (ap, int);
 390             ret = 0;
 391             break;
 392
 393         case VLC_CONFIG_LIST_NODOMAIN:
 394         {
 395             size_t len = va_arg (ap, size_t);
 396             if (IsConfigIntegerType (item->i_type))
 397             {
 398                 const int *src = va_arg (ap, const int *);
 399                 const char *const *text = va_arg (ap, const char *const *);
 400                 ret = vlc_config_set (item, VLC_CONFIG_LIST, NULL, len, src,
 401                                       text);
 402             }
 403             else
 404             if (IsConfigStringType (item->i_type))
 405             {
 406                 const char *const *src = va_arg (ap, const char *const *);
 407                 const char *const *text = va_arg (ap, const char *const *);
 408                 ret = vlc_config_set (item, VLC_CONFIG_LIST, NULL, len, src,
 409                                       text);
 410             }
 411             break;
 412         }
 413
 414         case VLC_CONFIG_ADD_ACTION_NODOMAIN:
 415         {
 416             vlc_callback_t cb = va_arg (ap, vlc_callback_t);
 417             const char *name = va_arg (ap, const char *);
 418             ret = vlc_config_set (item, VLC_CONFIG_ADD_ACTION, NULL, cb, name);
 419             break;
 420         }
 421
 422         case VLC_CONFIG_OLDNAME:
 423         {
 424             const char *oldname = va_arg (ap, const char *);
 425             item->psz_oldname = oldname ? strdup (oldname) : NULL;
 426             ret = 0;
 427             break;
 428         }
 429
 430         case VLC_CONFIG_SAFE:
 431             item->b_safe = true;
 432             ret = 0;
 433             break;
 434
 435         case VLC_CONFIG_DESC:
 436         {
 437             const char *domain = va_arg (ap, const char *);
 438             const char *text = va_arg (ap, const char *);
 439             const char *longtext = va_arg (ap, const char *);
 440
 441             if (domain == NULL)
 442                 domain = PACKAGE;
 443             item->psz_text = text ? strdup (dgettext (domain, text)) : NULL;
 444             item->psz_longtext =
 445                 longtext ? strdup (dgettext (domain, longtext)) : NULL;
 446             ret = 0;
 447             break;
 448         }
 449
 450         case VLC_CONFIG_LIST:
 451         {
 452             const char *domain = va_arg (ap, const char *);
 453             size_t len = va_arg (ap, size_t);
 454             char **dtext = malloc (sizeof (char *) * (len + 1));
 455
 456             if (dtext == NULL)
 457                 break;
 458
 459             /* Copy values */
 460             if (IsConfigIntegerType (item->i_type))
 461             {
 462                 const int *src = va_arg (ap, const int *);
 463                 int *dst = malloc (sizeof (int) * (len + 1));
 464
 465                 if (dst != NULL)
 466                 {
 467                     memcpy (dst, src, sizeof (int) * len);
 468                     dst[len] = 0;
 469                 }
 470                 item->pi_list = dst;
 471             }
 472             else
 473 #if 0
 474             if (IsConfigFloatType (item->i_type))
 475             {
 476                 const float *src = va_arg (ap, const float *);
 477                 float *dst = malloc (sizeof (float) * (len + 1));
 478
 479                 if (dst != NULL)
 480                 {
 481                     memcpy (dst, src, sizeof (float) * len);
 482                     dst[len] = 0.;
 483                 }
 484                 item->pf_list = dst;
 485             }
 486             else
 487 #endif
 488             if (IsConfigStringType (item->i_type))
 489             {
 490                 const char *const *src = va_arg (ap, const char *const *);
 491                 char **dst = malloc (sizeof (char *) * (len + 1));
 492
 493                 if (dst != NULL)
 494                 {
 495                     for (size_t i = 0; i < len; i++)
 496                         dst[i] = src[i] ? strdup (src[i]) : NULL;
 497                     dst[len] = NULL;
 498                 }
 499                 item->ppsz_list = dst;
 500             }
 501             else
 502                 break;
 503
 504             /* Copy textual descriptions */
 505             if (domain == NULL)
 506                 domain = PACKAGE;
 507
 508             const char *const *text = va_arg (ap, const char *const *);
 509             if (text != NULL)
 510             {
 511                 for (size_t i = 0; i < len; i++)
 512                     dtext[i] =
 513                         text[i] ? strdup (dgettext (domain, text[i])) : NULL;
 514
 515                 dtext[len] = NULL;
 516                 item->ppsz_list_text = dtext;
 517             }
 518             else
 519             {
 520                 free (dtext);
 521                 item->ppsz_list_text = NULL;
 522             }
 523
 524             item->i_list = len;
 525             item->pf_update_list = va_arg (ap, vlc_callback_t);
 526             ret = 0;
 527             break;
 528         }
 529
 530         case VLC_CONFIG_ADD_ACTION:
 531         {
 532             const char *domain = va_arg (ap, const char *);
 533             vlc_callback_t cb = va_arg (ap, vlc_callback_t), *tabcb;
 534             const char *name = va_arg (ap, const char *);
 535             char **tabtext;
 536
 537             tabcb = realloc (item->ppf_action,
 538                              (item->i_action + 2) * sizeof (cb));
 539             if (tabcb == NULL)
 540                 break;
 541             item->ppf_action = tabcb;
 542             tabcb[item->i_action] = cb;
 543             tabcb[item->i_action + 1] = NULL;
 544
 545             tabtext = realloc (item->ppsz_action_text,
 546                                (item->i_action + 2) * sizeof (name));
 547             if (tabtext == NULL)
 548                 break;
 549             item->ppsz_action_text = tabtext;
 550
 551             if (domain == NULL)
 552                 domain = PACKAGE;
 553             if (name)
 554                 tabtext[item->i_action] = strdup (dgettext (domain, name));
 555             else
 556                 tabtext[item->i_action] = NULL;
 557             tabtext[item->i_action + 1] = NULL;
 558
 559             item->i_action++;
 560             ret = 0;
 561             break;
 562         }
 563     }
 564
 565     va_end (ap);
 566     return ret;
 567 }