ext/aalib/gstaasink.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 #include <config.h>
  21
  22 #include <string.h>
  23 #include <sys/time.h>
  24
  25 #include "gstaasink.h"
  26
  27 static GstElementDetails gst_aasink_details = {
  28   "Video sink",
  29   "Sink/Video",
  30   "An ASCII art videosink",
  31   VERSION,
  32   "Wim Taymans <wim.taymans@chello.be>",
  33   "(C) 2001",
  34 };
  35
  36 /* aasink signals and args */
  37 enum {
  38   SIGNAL_FRAME_DISPLAYED,
  39   SIGNAL_HAVE_SIZE,
  40   LAST_SIGNAL
  41 };
  42
  43
  44 enum {
  45   ARG_0,
  46   ARG_WIDTH,
  47   ARG_HEIGHT,
  48   ARG_DRIVER,
  49   ARG_DITHER,
  50   ARG_BRIGHTNESS,
  51   ARG_CONTRAST,
  52   ARG_GAMMA,
  53   ARG_INVERSION,
  54   ARG_RANDOMVAL,
  55   ARG_FRAMES_DISPLAYED,
  56   ARG_FRAME_TIME,
  57 };
  58
  59 GST_PADTEMPLATE_FACTORY (sink_template,
  60   "sink",
  61   GST_PAD_SINK,
  62   GST_PAD_ALWAYS,
  63   GST_CAPS_NEW (
  64     "aasink_caps",
  65     "video/raw",
  66       "format",         GST_PROPS_FOURCC (GST_STR_FOURCC ("I420"))
  67   )
  68 )
  69
  70 static void     gst_aasink_class_init   (GstAASinkClass *klass);
  71 static void     gst_aasink_init         (GstAASink *aasink);
  72
  73 static void     gst_aasink_chain        (GstPad *pad, GstBuffer *buf);
  74
  75 static void     gst_aasink_set_property (GObject *object, guint prop_id,
  76                                          const GValue *value, GParamSpec *pspec);
  77 static void     gst_aasink_get_property (GObject *object, guint prop_id,
  78                                          GValue *value, GParamSpec *pspec);
  79
  80 static GstElementStateReturn gst_aasink_change_state (GstElement *element);
  81
  82 static GstElementClass *parent_class = NULL;
  83 static guint gst_aasink_signals[LAST_SIGNAL] = { 0 };
  84
  85 GType
  86 gst_aasink_get_type (void)
  87 {
  88   static GType aasink_type = 0;
  89
  90   if (!aasink_type) {
  91     static const GTypeInfo aasink_info = {
  92       sizeof(GstAASinkClass),
  93       NULL,
  94       NULL,
  95       (GClassInitFunc) gst_aasink_class_init,
  96       NULL,
  97       NULL,
  98       sizeof(GstAASink),
  99       0,
 100       (GInstanceInitFunc)gst_aasink_init,
 101     };
 102     aasink_type = g_type_register_static(GST_TYPE_ELEMENT, "GstAASink", &aasink_info, 0);
 103   }
 104   return aasink_type;
 105 }
 106
 107 #define GST_TYPE_AADRIVERS (gst_aasink_drivers_get_type())
 108 static GType
 109 gst_aasink_drivers_get_type (void)
 110 {
 111   static GType driver_type = 0;
 112   if (!driver_type) {
 113     GEnumValue *drivers;
 114     const struct aa_driver *driver;
 115     gint i = 0;
 116
 117     driver = aa_drivers[i++];
 118     while (driver) {
 119       driver = aa_drivers[i++];
 120     }
 121
 122     drivers = g_new0(GEnumValue, i);
 123
 124     i = 0;
 125     driver = aa_drivers[i];
 126     while (driver) {
 127       drivers[i].value = i;
 128       drivers[i].value_name = g_strdup (driver->shortname);
 129       drivers[i].value_nick = g_strdup (driver->name);
 130       i++;
 131       driver = aa_drivers[i];
 132     }
 133     drivers[i].value = 0;
 134     drivers[i].value_name = NULL;
 135     drivers[i].value_nick = NULL;
 136
 137     driver_type = g_enum_register_static ("GstAASinkDrivers", drivers);
 138   }
 139   return driver_type;
 140 }
 141
 142 #define GST_TYPE_AADITHER (gst_aasink_dither_get_type())
 143 static GType
 144 gst_aasink_dither_get_type (void)
 145 {
 146   static GType dither_type = 0;
 147   if (!dither_type) {
 148     GEnumValue *ditherers;
 149     gint i = 0;
 150
 151     while (aa_dithernames[i]) {
 152       i++;
 153     }
 154
 155     ditherers = g_new0(GEnumValue, i);
 156
 157     i = 0;
 158     while (aa_dithernames[i]) {
 159       ditherers[i].value = i;
 160       ditherers[i].value_name = g_strdup (aa_dithernames[i]);
 161       ditherers[i].value_nick = g_strdup (aa_dithernames[i]);
 162       i++;
 163     }
 164     ditherers[i].value = 0;
 165     ditherers[i].value_name = NULL;
 166     ditherers[i].value_nick = NULL;
 167
 168     dither_type = g_enum_register_static ("GstAASinkDitherers", ditherers);
 169   }
 170   return dither_type;
 171 }
 172
 173 static void
 174 gst_aasink_class_init (GstAASinkClass *klass)
 175 {
 176   GObjectClass *gobject_class;
 177   GstElementClass *gstelement_class;
 178
 179   gobject_class = (GObjectClass*)klass;
 180   gstelement_class = (GstElementClass*)klass;
 181
 182   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 183
 184   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_WIDTH,
 185     g_param_spec_int("width","width","width",
 186                      G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
 187   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_HEIGHT,
 188     g_param_spec_int("height","height","height",
 189                      G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
 190   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DRIVER,
 191     g_param_spec_enum("driver","driver","driver",
 192                       GST_TYPE_AADRIVERS,0,G_PARAM_READWRITE)); /* CHECKME! */
 193   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DITHER,
 194     g_param_spec_enum("dither","dither","dither",
 195                       GST_TYPE_AADITHER,0,G_PARAM_READWRITE)); /* CHECKME! */
 196   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BRIGHTNESS,
 197     g_param_spec_int("brightness","brightness","brightness",
 198                      G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
 199   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_CONTRAST,
 200     g_param_spec_int("contrast","contrast","contrast",
 201                      G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
 202   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_GAMMA,
 203     g_param_spec_float("gamma","gamma","gamma",
 204                        0.0,5.0,1.0,G_PARAM_READWRITE)); /* CHECKME */
 205   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_INVERSION,
 206     g_param_spec_boolean("inversion","inversion","inversion",
 207                          TRUE,G_PARAM_READWRITE)); /* CHECKME */
 208   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_RANDOMVAL,
 209     g_param_spec_int("randomval","randomval","randomval",
 210                      G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
 211   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FRAMES_DISPLAYED,
 212     g_param_spec_int("frames_displayed","frames_displayed","frames_displayed",
 213                      G_MININT,G_MAXINT,0,G_PARAM_READABLE)); /* CHECKME */
 214   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FRAME_TIME,
 215     g_param_spec_int("frame_time","frame_time","frame_time",
 216                      G_MININT,G_MAXINT,0,G_PARAM_READABLE)); /* CHECKME */
 217
 218   gobject_class->set_property = gst_aasink_set_property;
 219   gobject_class->get_property = gst_aasink_get_property;
 220
 221   gst_aasink_signals[SIGNAL_FRAME_DISPLAYED] =
 222     g_signal_new ("frame_displayed", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
 223                    G_STRUCT_OFFSET (GstAASinkClass, frame_displayed), NULL, NULL,
 224                    g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 225   gst_aasink_signals[SIGNAL_HAVE_SIZE] =
 226     g_signal_new ("have_size", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
 227                    G_STRUCT_OFFSET (GstAASinkClass, have_size), NULL, NULL,
 228                    gst_marshal_VOID__INT_INT, G_TYPE_NONE, 2,
 229                    G_TYPE_UINT, G_TYPE_UINT);
 230
 231   gstelement_class->change_state = gst_aasink_change_state;
 232 }
 233
 234 static GstPadConnectReturn
 235 gst_aasink_sinkconnect (GstPad *pad, GstCaps *caps)
 236 {
 237   GstAASink *aasink;
 238   gulong print_format;
 239
 240   aasink = GST_AASINK (gst_pad_get_parent (pad));
 241
 242   if (!GST_CAPS_IS_FIXED (caps))
 243     return GST_PAD_CONNECT_DELAYED;
 244
 245   aasink->width =  gst_caps_get_int (caps, "width");
 246   aasink->height =  gst_caps_get_int (caps, "height");
 247
 248   print_format = GULONG_FROM_LE (aasink->format);
 249
 250   GST_DEBUG (0, "aasink: setting %08lx (%4.4s)", aasink->format, (gchar*)&print_format);
 251
 252   g_signal_emit( G_OBJECT (aasink), gst_aasink_signals[SIGNAL_HAVE_SIZE], 0,
 253                  aasink->width, aasink->height);
 254
 255   return GST_PAD_CONNECT_OK;
 256 }
 257
 258 static void
 259 gst_aasink_set_clock (GstElement *element, GstClock *clock)
 260 {
 261   GstAASink *aasink = GST_AASINK (element);
 262
 263   aasink->clock = clock;
 264 }
 265
 266 static void
 267 gst_aasink_init (GstAASink *aasink)
 268 {
 269   aasink->sinkpad = gst_pad_new_from_template (
 270                   GST_PADTEMPLATE_GET (sink_template), "sink");
 271   gst_element_add_pad (GST_ELEMENT (aasink), aasink->sinkpad);
 272   gst_pad_set_chain_function (aasink->sinkpad, gst_aasink_chain);
 273   gst_pad_set_connect_function (aasink->sinkpad, gst_aasink_sinkconnect);
 274
 275   memcpy(&aasink->ascii_surf, &aa_defparams, sizeof (struct aa_hardware_params));
 276   aasink->ascii_parms.bright = 0;
 277   aasink->ascii_parms.contrast = 16;
 278   aasink->ascii_parms.gamma = 1.0;
 279   aasink->ascii_parms.dither = 0;
 280   aasink->ascii_parms.inversion = 0;
 281   aasink->ascii_parms.randomval = 0;
 282   aasink->aa_driver = 0;
 283
 284   aasink->width = -1;
 285   aasink->height = -1;
 286
 287   aasink->clock = NULL;
 288   GST_ELEMENT (aasink)->setclockfunc    = gst_aasink_set_clock;
 289
 290   GST_FLAG_SET(aasink, GST_ELEMENT_THREAD_SUGGESTED);
 291 }
 292
 293 static void
 294 gst_aasink_scale (GstAASink *aasink, gchar *src, gchar *dest,
 295                   gint sw, gint sh,
 296                   gint dw, gint dh)
 297 {
 298   gint ypos, yinc, y;
 299   gint xpos, xinc, x;
 300
 301   g_return_if_fail ((dw != 0) && (dh != 0));
 302
 303   ypos = 0x10000;
 304   yinc = (sh << 16) / dh;
 305   xinc = (sw << 16) / dw;
 306
 307   for (y = dh; y; y--) {
 308     while (ypos > 0x10000) {
 309       ypos -= 0x10000;
 310       src  += sw;
 311     }
 312     xpos = 0x10000;
 313     {
 314       guchar *destp = dest;
 315       guchar *srcp = src;
 316
 317       for ( x=dw; x; x-- ) {
 318         while (xpos >= 0x10000L) {
 319           srcp++;
 320           xpos -= 0x10000L;
 321         }
 322         *destp++ = *srcp;
 323         xpos     += xinc;
 324       }
 325     }
 326     dest += dw;
 327     ypos += yinc;
 328   }
 329 }
 330
 331 static void
 332 gst_aasink_chain (GstPad *pad, GstBuffer *buf)
 333 {
 334   GstAASink *aasink;
 335
 336   g_return_if_fail (pad != NULL);
 337   g_return_if_fail (GST_IS_PAD (pad));
 338   g_return_if_fail (buf != NULL);
 339
 340   aasink = GST_AASINK (gst_pad_get_parent (pad));
 341
 342   gst_aasink_scale (aasink,
 343                     GST_BUFFER_DATA (buf),              /* src */
 344                     aa_image (aasink->context),         /* dest */
 345                     aasink->width,                      /* sw */
 346                     aasink->height,                     /* sh */
 347                     aa_imgwidth (aasink->context),      /* dw */
 348                     aa_imgheight (aasink->context));    /* dh */
 349
 350   GST_DEBUG (0,"videosink: clock wait: %llu", GST_BUFFER_TIMESTAMP(buf));
 351
 352   if (aasink->clock) {
 353     gst_element_clock_wait (GST_ELEMENT (aasink), aasink->clock, GST_BUFFER_TIMESTAMP(buf));
 354   }
 355
 356   aa_render (aasink->context, &aasink->ascii_parms,
 357                   0, 0, aa_imgwidth (aasink->context), aa_imgheight (aasink->context));
 358   aa_flush (aasink->context);
 359   aa_getevent (aasink->context, FALSE);
 360
 361   g_signal_emit(G_OBJECT(aasink),gst_aasink_signals[SIGNAL_FRAME_DISPLAYED], 0);
 362
 363   gst_buffer_unref(buf);
 364 }
 365
 366
 367 static void
 368 gst_aasink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 369 {
 370   GstAASink *aasink;
 371
 372   /* it's not null if we got it, but it might not be ours */
 373   g_return_if_fail (GST_IS_AASINK (object));
 374
 375   aasink = GST_AASINK (object);
 376
 377   switch (prop_id) {
 378     case ARG_WIDTH:
 379       aasink->ascii_surf.width = g_value_get_int (value);
 380       break;
 381     case ARG_HEIGHT:
 382       aasink->ascii_surf.height = g_value_get_int (value);
 383       break;
 384     case ARG_DRIVER: {
 385       aasink->aa_driver = g_value_get_enum (value);
 386       break;
 387     }
 388     case ARG_DITHER: {
 389       aasink->ascii_parms.dither = g_value_get_enum (value);
 390       break;
 391     }
 392     case ARG_BRIGHTNESS: {
 393       aasink->ascii_parms.bright = g_value_get_int (value);
 394       break;
 395     }
 396     case ARG_CONTRAST: {
 397       aasink->ascii_parms.contrast = g_value_get_int (value);
 398       break;
 399     }
 400     case ARG_GAMMA: {
 401       aasink->ascii_parms.gamma = g_value_get_float (value);
 402       break;
 403     }
 404     case ARG_INVERSION: {
 405       aasink->ascii_parms.inversion = g_value_get_boolean (value);
 406       break;
 407     }
 408     case ARG_RANDOMVAL: {
 409       aasink->ascii_parms.randomval = g_value_get_int (value);
 410       break;
 411     }
 412     default:
 413       break;
 414   }
 415 }
 416
 417 static void
 418 gst_aasink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 419 {
 420   GstAASink *aasink;
 421
 422   /* it's not null if we got it, but it might not be ours */
 423   aasink = GST_AASINK(object);
 424
 425   switch (prop_id) {
 426     case ARG_WIDTH: {
 427       g_value_set_int (value, aasink->ascii_surf.width);
 428       break;
 429     }
 430     case ARG_HEIGHT: {
 431       g_value_set_int (value, aasink->ascii_surf.height);
 432       break;
 433     }
 434     case ARG_DRIVER: {
 435       g_value_set_enum (value, aasink->aa_driver);
 436       break;
 437     }
 438     case ARG_DITHER: {
 439       g_value_set_enum (value, aasink->ascii_parms.dither);
 440       break;
 441     }
 442     case ARG_BRIGHTNESS: {
 443       g_value_set_int (value, aasink->ascii_parms.bright);
 444       break;
 445     }
 446     case ARG_CONTRAST: {
 447       g_value_set_int (value, aasink->ascii_parms.contrast);
 448       break;
 449     }
 450     case ARG_GAMMA: {
 451       g_value_set_float (value, aasink->ascii_parms.gamma);
 452       break;
 453     }
 454     case ARG_INVERSION: {
 455       g_value_set_boolean (value, aasink->ascii_parms.inversion);
 456       break;
 457     }
 458     case ARG_RANDOMVAL: {
 459       g_value_set_int (value, aasink->ascii_parms.randomval);
 460       break;
 461     }
 462     case ARG_FRAMES_DISPLAYED: {
 463       g_value_set_int (value, aasink->frames_displayed);
 464       break;
 465     }
 466     case ARG_FRAME_TIME: {
 467       g_value_set_int (value, aasink->frame_time/1000000);
 468       break;
 469     }
 470     default: {
 471       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 472       break;
 473     }
 474   }
 475 }
 476
 477 static gboolean
 478 gst_aasink_open (GstAASink *aasink)
 479 {
 480   g_return_val_if_fail (!GST_FLAG_IS_SET (aasink ,GST_AASINK_OPEN), FALSE);
 481
 482   aa_recommendhidisplay(aa_drivers[aasink->aa_driver]->shortname);
 483
 484   aasink->context = aa_autoinit (&aasink->ascii_surf);
 485   if (aasink->context == NULL) {
 486     gst_element_error (GST_ELEMENT (aasink),
 487                     g_strdup("opening aalib context"));
 488     return FALSE;
 489   }
 490   aa_autoinitkbd(aasink->context, 0);
 491   aa_resizehandler(aasink->context, (void *)aa_resize);
 492
 493   GST_FLAG_SET (aasink, GST_AASINK_OPEN);
 494
 495   return TRUE;
 496 }
 497
 498 static void
 499 gst_aasink_close (GstAASink *aasink)
 500 {
 501   g_return_if_fail (GST_FLAG_IS_SET (aasink ,GST_AASINK_OPEN));
 502
 503   aa_close (aasink->context);
 504
 505   GST_FLAG_UNSET (aasink, GST_AASINK_OPEN);
 506 }
 507
 508 static GstElementStateReturn
 509 gst_aasink_change_state (GstElement *element)
 510 {
 511   g_return_val_if_fail (GST_IS_AASINK (element), GST_STATE_FAILURE);
 512
 513   if (GST_STATE_PENDING (element) == GST_STATE_NULL) {
 514     if (GST_FLAG_IS_SET (element, GST_AASINK_OPEN))
 515       gst_aasink_close (GST_AASINK (element));
 516   } else {
 517     if (!GST_FLAG_IS_SET (element, GST_AASINK_OPEN)) {
 518       if (!gst_aasink_open (GST_AASINK (element)))
 519         return GST_STATE_FAILURE;
 520     }
 521   }
 522
 523   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 524     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 525
 526   return GST_STATE_SUCCESS;
 527 }
 528
 529 static gboolean
 530 plugin_init (GModule *module, GstPlugin *plugin)
 531 {
 532   GstElementFactory *factory;
 533
 534   /* create an elementfactory for the aasink element */
 535   factory = gst_elementfactory_new("aasink",GST_TYPE_AASINK,
 536                                    &gst_aasink_details);
 537   g_return_val_if_fail(factory != NULL, FALSE);
 538
 539   gst_elementfactory_add_padtemplate (factory,
 540                   GST_PADTEMPLATE_GET (sink_template));
 541
 542   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
 543
 544   return TRUE;
 545 }
 546
 547 GstPluginDesc plugin_desc = {
 548   GST_VERSION_MAJOR,
 549   GST_VERSION_MINOR,
 550   "aasink",
 551   plugin_init
 552 };