ext/mikmod/gstmikmod.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23 #include "gstmikmod.h"
  24
  25 #include <gst/audio/audio.h>
  26 #include <stdlib.h>
  27
  28 /* elementfactory information */
  29 GstElementDetails mikmod_details = {
  30   "MikMod",
  31   "Codec/Decoder/Audio",
  32   "Module decoder based on libmikmod",
  33   "Jeremy SIMON <jsimon13@yahoo.fr>",
  34 };
  35
  36
  37 /* Filter signals and args */
  38 enum {
  39   /* FILL ME */
  40   LAST_SIGNAL
  41 };
  42
  43 enum {
  44   ARG_0,
  45   ARG_SONGNAME,
  46   ARG_MODTYPE,
  47   ARG_MUSICVOLUME,
  48   ARG_PANSEP,
  49   ARG_REVERB,
  50   ARG_SNDFXVOLUME,
  51   ARG_VOLUME,
  52   ARG_INTERP,
  53   ARG_REVERSE,
  54   ARG_SURROUND,
  55   ARG_HQMIXER,
  56   ARG_SOFT_MUSIC,
  57   ARG_SOFT_SNDFX
  58 };
  59
  60
  61 static GstStaticPadTemplate mikmod_src_factory =
  62 GST_STATIC_PAD_TEMPLATE (
  63     "src",
  64     GST_PAD_SRC,
  65     GST_PAD_ALWAYS,
  66     GST_STATIC_CAPS (GST_AUDIO_INT_PAD_TEMPLATE_CAPS)
  67 );
  68
  69 static GstStaticPadTemplate mikmod_sink_factory =
  70 GST_STATIC_PAD_TEMPLATE (
  71     "sink",
  72     GST_PAD_SINK,
  73     GST_PAD_ALWAYS,
  74     GST_STATIC_CAPS ("audio/x-mod")
  75 );
  76
  77 static void             gst_mikmod_base_init            (gpointer g_class);
  78 static void             gst_mikmod_class_init           (GstMikModClass *klass);
  79 static void             gst_mikmod_init                 (GstMikMod *filter);
  80 static void             gst_mikmod_set_property         (GObject *object, guint id, const GValue *value, GParamSpec *pspec );
  81 static void             gst_mikmod_get_property         (GObject *object, guint id, GValue *value, GParamSpec *pspec );
  82 static GstPadLinkReturn gst_mikmod_srclink              (GstPad *pad, const GstCaps *caps);
  83 static void             gst_mikmod_loop                 (GstElement *element);
  84 static gboolean         gst_mikmod_setup                (GstMikMod *mikmod);
  85 static GstElementStateReturn  gst_mikmod_change_state   (GstElement *element);
  86
  87
  88
  89 static GstElementClass *parent_class = NULL;
  90
  91 GType
  92 gst_mikmod_get_type(void) {
  93   static GType mikmod_type = 0;
  94
  95   if (!mikmod_type) {
  96     static const GTypeInfo mikmod_info = {
  97       sizeof(GstMikModClass),
  98       gst_mikmod_base_init,
  99       NULL,
 100       (GClassInitFunc)gst_mikmod_class_init,
 101       NULL,
 102       NULL,
 103       sizeof(GstMikMod),
 104       0,
 105       (GInstanceInitFunc)gst_mikmod_init,
 106     };
 107     mikmod_type = g_type_register_static(GST_TYPE_ELEMENT, "GstMikmod", &mikmod_info, 0);
 108   }
 109   return mikmod_type;
 110 }
 111
 112 static void
 113 gst_mikmod_base_init (gpointer g_class)
 114 {
 115   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 116
 117   gst_element_class_add_pad_template (element_class,
 118       gst_static_pad_template_get (&mikmod_src_factory));
 119   gst_element_class_add_pad_template (element_class,
 120       gst_static_pad_template_get (&mikmod_sink_factory));
 121   gst_element_class_set_details (element_class, &mikmod_details);
 122 }
 123
 124 static void
 125 gst_mikmod_class_init (GstMikModClass *klass)
 126 {
 127   GObjectClass *gobject_class;
 128   GstElementClass *gstelement_class;
 129
 130   gobject_class = (GObjectClass*)klass;
 131   gstelement_class = (GstElementClass*)klass;
 132
 133   parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
 134
 135   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SONGNAME,
 136     g_param_spec_string("songname","songname","songname",
 137                         NULL, G_PARAM_READABLE));
 138   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_MODTYPE,
 139     g_param_spec_string("modtype", "modtype", "modtype",
 140                         NULL, G_PARAM_READABLE ));
 141   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_MUSICVOLUME,
 142     g_param_spec_int("musicvolume", "musivolume", "musicvolume",
 143                         0, 128, 128, G_PARAM_READWRITE ));
 144   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_PANSEP,
 145     g_param_spec_int("pansep", "pansep", "pansep",
 146                         0, 128, 128, G_PARAM_READWRITE ));
 147   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_REVERB,
 148     g_param_spec_int("reverb", "reverb", "reverb",
 149                         0, 15, 0, G_PARAM_READWRITE ));
 150   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SNDFXVOLUME,
 151     g_param_spec_int("sndfxvolume", "sndfxvolume", "sndfxvolume",
 152                         0, 128, 128, G_PARAM_READWRITE ));
 153   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_VOLUME,
 154     g_param_spec_int("volume", "volume", "volume",
 155                         0, 128, 96, G_PARAM_READWRITE ));
 156
 157   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_INTERP,
 158     g_param_spec_boolean("interp", "interp", "interp",
 159                        FALSE, G_PARAM_READWRITE ));
 160   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_REVERSE,
 161     g_param_spec_boolean("reverse", "reverse", "reverse",
 162                        FALSE, G_PARAM_READWRITE ));
 163   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SURROUND,
 164     g_param_spec_boolean("surround", "surround", "surround",
 165                        TRUE, G_PARAM_READWRITE ));
 166   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_HQMIXER,
 167     g_param_spec_boolean("hqmixer", "hqmixer", "hqmixer",
 168                        FALSE, G_PARAM_READWRITE ));
 169   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SOFT_MUSIC,
 170     g_param_spec_boolean("soft_music", "soft_music", "soft_music",
 171                        TRUE, G_PARAM_READWRITE ));
 172   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SOFT_SNDFX,
 173     g_param_spec_boolean("soft_sndfx", "soft_sndfx", "soft_sndfx",
 174                        TRUE, G_PARAM_READWRITE ));
 175
 176
 177   gobject_class->set_property = gst_mikmod_set_property;
 178   gobject_class->get_property = gst_mikmod_get_property;
 179
 180   gstelement_class->change_state = gst_mikmod_change_state;
 181 }
 182
 183
 184 static void
 185 gst_mikmod_init (GstMikMod *filter)
 186 {
 187   filter->sinkpad = gst_pad_new_from_template(
 188       gst_static_pad_template_get (&mikmod_sink_factory),"sink");
 189   filter->srcpad = gst_pad_new_from_template(
 190     gst_static_pad_template_get (&mikmod_src_factory),"src");
 191   gst_pad_use_explicit_caps (filter->srcpad);
 192
 193   gst_element_add_pad(GST_ELEMENT(filter),filter->sinkpad);
 194   gst_element_add_pad(GST_ELEMENT(filter),filter->srcpad);
 195   gst_pad_set_link_function (filter->srcpad, gst_mikmod_srclink);
 196
 197   gst_element_set_loop_function (GST_ELEMENT (filter), gst_mikmod_loop);
 198
 199   filter->Buffer = NULL;
 200
 201   filter->stereo      = TRUE;
 202   filter->surround    = TRUE;
 203   filter->_16bit      = TRUE;
 204   filter->soft_music  = TRUE;
 205   filter->soft_sndfx  = TRUE;
 206   filter->mixfreq     = 44100;
 207   filter->reverb      = 0;
 208   filter->pansep      = 128;
 209   filter->musicvolume = 128;
 210   filter->volume      = 96;
 211   filter->sndfxvolume = 128;
 212   filter->songname    = NULL;
 213   filter->modtype     = NULL;
 214 }
 215
 216
 217 static GstPadLinkReturn
 218 gst_mikmod_negotiate (GstMikMod *mikmod)
 219 {
 220   gint width, sign;
 221
 222   if ( mikmod->_16bit ) {
 223     width = 16;
 224     sign = TRUE;
 225   } else {
 226     width = 8;
 227     sign = FALSE;
 228   }
 229
 230   return gst_pad_set_explicit_caps (mikmod->srcpad,
 231       gst_caps_new_simple ( "audio/x-raw-int",
 232         "endianness",  G_TYPE_INT, G_BYTE_ORDER,
 233         "signed",      G_TYPE_BOOLEAN, sign,
 234         "width",       G_TYPE_INT, width,
 235         "depth",       G_TYPE_INT, width,
 236         "rate",        G_TYPE_INT, mikmod->mixfreq,
 237         "channels",    G_TYPE_INT, mikmod->stereo ? 2 : 1,
 238         NULL));
 239 }
 240
 241
 242 static GstPadLinkReturn
 243 gst_mikmod_srclink (GstPad *pad, const GstCaps *caps)
 244 {
 245   GstMikMod *filter;
 246   GstStructure *structure;
 247   gint depth;
 248   gint channels;
 249
 250   filter = GST_MIKMOD (gst_pad_get_parent (pad));
 251
 252   structure = gst_caps_get_structure (caps, 0);
 253
 254   gst_structure_get_int (structure, "depth", &depth);
 255   filter->_16bit = (depth == 16);
 256   gst_structure_get_int (structure, "channels", &channels);
 257   filter->stereo = (channels == 2);
 258   gst_structure_get_int (structure, "rate", &filter->mixfreq);
 259
 260   return gst_mikmod_negotiate(filter);
 261 }
 262
 263
 264 static void
 265 gst_mikmod_loop (GstElement *element)
 266 {
 267   GstMikMod *mikmod;
 268   GstBuffer *buffer_in;
 269
 270   g_return_if_fail (element != NULL);
 271   g_return_if_fail (GST_IS_MIKMOD (element));
 272
 273   mikmod = GST_MIKMOD (element);
 274   srcpad = mikmod->srcpad;
 275   mikmod->Buffer = NULL;
 276
 277   while ((buffer_in = GST_BUFFER (gst_pad_pull( mikmod->sinkpad )))) {
 278     if ( GST_IS_EVENT (buffer_in) ) {
 279       GstEvent *event = GST_EVENT (buffer_in);
 280
 281       if (GST_EVENT_TYPE (event) == GST_EVENT_EOS)
 282          break;
 283     }
 284     else
 285     {
 286       if ( mikmod->Buffer ) {
 287         mikmod->Buffer = gst_buffer_merge( mikmod->Buffer, buffer_in );
 288         gst_buffer_unref( buffer_in );
 289       }
 290       else
 291         mikmod->Buffer = buffer_in;
 292     }
 293   }
 294
 295   if (!GST_PAD_CAPS (mikmod->srcpad)) {
 296     if (gst_mikmod_negotiate (mikmod) <= 0) {
 297       GST_ELEMENT_ERROR (mikmod, CORE, NEGOTIATION, (NULL), (NULL));
 298       return;
 299     }
 300   }
 301   gst_mikmod_setup( mikmod );
 302
 303   MikMod_RegisterDriver(&drv_gst);
 304   MikMod_RegisterAllLoaders();
 305
 306   MikMod_Init("");
 307   reader = GST_READER_new( mikmod );
 308   module = Player_LoadGeneric ( reader, 64, 0 );
 309
 310   gst_buffer_unref (mikmod->Buffer);
 311
 312   if ( ! Player_Active() )
 313     Player_Start(module);
 314
 315   do {
 316     if ( Player_Active() ) {
 317
 318       timestamp = ( module->sngtime / 1024.0 ) * GST_SECOND;
 319       drv_gst.Update();
 320       gst_element_yield (element);
 321     }
 322     else {
 323       gst_element_set_eos (GST_ELEMENT (mikmod));
 324       gst_pad_push (mikmod->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS)));
 325     }
 326
 327   }
 328   while ( 1 );
 329 }
 330
 331
 332 static gboolean
 333 gst_mikmod_setup (GstMikMod *mikmod)
 334 {
 335   md_musicvolume = mikmod->musicvolume;
 336   md_pansep = mikmod->pansep;
 337   md_reverb = mikmod->reverb;
 338   md_sndfxvolume = mikmod->sndfxvolume;
 339   md_volume = mikmod->volume;
 340   md_mixfreq = mikmod->mixfreq;
 341
 342   md_mode = 0;
 343
 344   if ( mikmod->interp )
 345     md_mode = md_mode | DMODE_INTERP;
 346
 347   if ( mikmod->reverse )
 348     md_mode = md_mode | DMODE_REVERSE;
 349
 350   if ( mikmod->surround )
 351     md_mode = md_mode | DMODE_SURROUND;
 352
 353   if ( mikmod->_16bit )
 354     md_mode = md_mode | DMODE_16BITS;
 355
 356   if ( mikmod->hqmixer )
 357     md_mode = md_mode | DMODE_HQMIXER;
 358
 359   if ( mikmod->soft_music )
 360     md_mode = md_mode | DMODE_SOFT_MUSIC;
 361
 362   if ( mikmod->soft_sndfx )
 363     md_mode = md_mode | DMODE_SOFT_SNDFX;
 364
 365   if ( mikmod->stereo )
 366     md_mode = md_mode | DMODE_STEREO;
 367
 368   return TRUE;
 369 }
 370
 371
 372 static GstElementStateReturn
 373 gst_mikmod_change_state (GstElement *element)
 374 {
 375 GstMikMod *mikmod;
 376
 377   g_return_val_if_fail (GST_IS_MIKMOD (element), GST_STATE_FAILURE);
 378
 379   mikmod = GST_MIKMOD (element);
 380
 381   GST_DEBUG ("state pending %d", GST_STATE_PENDING (element));
 382
 383   if (GST_STATE_PENDING (element) == GST_STATE_READY)
 384   {
 385      gst_mikmod_setup(mikmod);
 386
 387          if ( Player_Active() )
 388          {
 389                 Player_TogglePause();
 390                 Player_SetPosition( 0 );
 391          }
 392
 393   }
 394
 395   if (GST_STATE_PENDING (element) == GST_STATE_PLAYING)
 396   {
 397          if ( Player_Active() && Player_Paused() )
 398                 Player_TogglePause();
 399          else
 400            if ( ! Player_Active() )
 401              Player_Start(module);
 402
 403   }
 404
 405   if (GST_STATE_PENDING (element) == GST_STATE_PAUSED)
 406     if ( Player_Active() && ! Player_Paused() )
 407        Player_TogglePause();
 408
 409   if (GST_STATE_PENDING (element) == GST_STATE_NULL)
 410           MikMod_Exit();
 411
 412
 413   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 414     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 415
 416   return GST_STATE_SUCCESS;
 417 }
 418
 419
 420
 421 static void
 422 gst_mikmod_set_property (GObject *object, guint id, const GValue *value, GParamSpec *pspec )
 423 {
 424   GstMikMod *filter;
 425
 426   /* it's not null if we got it, but it might not be ours */
 427   g_return_if_fail(GST_IS_MIKMOD(object));
 428   filter = GST_MIKMOD(object);
 429
 430   switch (id) {
 431     case ARG_SONGNAME:
 432       g_free (filter->songname);
 433       filter->songname = g_strdup (g_value_get_string (value));
 434       break;
 435     case ARG_MODTYPE:
 436       g_free (filter->modtype);
 437       filter->modtype = g_strdup (g_value_get_string (value));
 438       break;
 439     case ARG_MUSICVOLUME:
 440       filter->musicvolume = g_value_get_int (value);
 441       break;
 442     case ARG_PANSEP:
 443       filter->pansep = g_value_get_int (value);
 444       break;
 445     case ARG_REVERB:
 446       filter->reverb = g_value_get_int (value);
 447       break;
 448     case ARG_SNDFXVOLUME:
 449       filter->sndfxvolume = g_value_get_int (value);
 450       break;
 451     case ARG_VOLUME:
 452       filter->volume = g_value_get_int (value);
 453       break;
 454     case ARG_INTERP:
 455       filter->interp = g_value_get_boolean (value);
 456       break;
 457     case ARG_REVERSE:
 458       filter->reverse = g_value_get_boolean (value);
 459       break;
 460     case ARG_SURROUND:
 461       filter->surround = g_value_get_boolean (value);
 462       break;
 463     case ARG_HQMIXER:
 464       filter->hqmixer = g_value_get_boolean (value);
 465       break;
 466     case ARG_SOFT_MUSIC:
 467       filter->soft_music = g_value_get_boolean (value);
 468       break;
 469     case ARG_SOFT_SNDFX:
 470       filter->soft_sndfx = g_value_get_boolean (value);
 471       break;
 472     default:
 473       break;
 474   }
 475 }
 476
 477 static void
 478 gst_mikmod_get_property (GObject *object, guint id, GValue *value, GParamSpec *pspec )
 479 {
 480   GstMikMod *filter;
 481
 482   /* it's not null if we got it, but it might not be ours */
 483   g_return_if_fail(GST_IS_MIKMOD(object));
 484   filter = GST_MIKMOD(object);
 485
 486   switch (id) {
 487     case ARG_MUSICVOLUME:
 488       g_value_set_int (value, filter->musicvolume);
 489       break;
 490     case ARG_PANSEP:
 491       g_value_set_int (value, filter->pansep);
 492       break;
 493     case ARG_REVERB:
 494       g_value_set_int (value, filter->reverb);
 495       break;
 496     case ARG_SNDFXVOLUME:
 497       g_value_set_int (value, filter->sndfxvolume);
 498       break;
 499     case ARG_VOLUME:
 500       g_value_set_int (value, filter->volume);
 501       break;
 502     case ARG_INTERP:
 503       g_value_set_boolean (value, filter->interp);
 504       break;
 505     case ARG_REVERSE:
 506       g_value_set_boolean (value, filter->reverse);
 507       break;
 508     case ARG_SURROUND:
 509       g_value_set_boolean (value, filter->surround);
 510       break;
 511     case ARG_HQMIXER:
 512       g_value_set_boolean (value, filter->hqmixer);
 513       break;
 514     case ARG_SOFT_MUSIC:
 515       g_value_set_boolean (value, filter->soft_music);
 516       break;
 517     case ARG_SOFT_SNDFX:
 518       g_value_set_boolean (value, filter->soft_sndfx);
 519       break;
 520     default:
 521       break;
 522   }
 523 }
 524
 525 static gboolean
 526 plugin_init (GstPlugin *plugin)
 527 {
 528   if (!gst_element_register (plugin, "mikmod", GST_RANK_SECONDARY, GST_TYPE_MIKMOD))
 529     return FALSE;
 530
 531   return TRUE;
 532 }
 533
 534 GST_PLUGIN_DEFINE (
 535   GST_VERSION_MAJOR,
 536   GST_VERSION_MINOR,
 537   "mikmod",
 538   "Mikmod plugin library",
 539   plugin_init,
 540   VERSION,
 541   "GPL",
 542   GST_PACKAGE,
 543   GST_ORIGIN)