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  * SECTION:element-aasink
  21  * @see_also: #GstCACASink
  22  *
  23  * Displays video as b/w ascii art.
  24  *
  25  * <refsect2>
  26  * <title>Example launch line</title>
  27  * |[
  28  * gst-launch filesrc location=test.avi ! decodebin ! ffmpegcolorspace ! aasink
  29  * ]| This pipeline renders a video to ascii art into a separate window.
  30  * |[
  31  * gst-launch filesrc location=test.avi ! decodebin ! ffmpegcolorspace ! aasink driver=curses
  32  * ]| This pipeline renders a video to ascii art into the current terminal.
  33  * </refsect2>
  34  */
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39
  40 #include <string.h>
  41 #include <sys/time.h>
  42
  43 #include <gst/video/gstvideometa.h>
  44 #include "gstaasink.h"
  45
  46 /* aasink signals and args */
  47 enum
  48 {
  49   LAST_SIGNAL
  50 };
  51
  52
  53 enum
  54 {
  55   PROP_0,
  56   PROP_WIDTH,
  57   PROP_HEIGHT,
  58   PROP_DRIVER,
  59   PROP_DITHER,
  60   PROP_BRIGHTNESS,
  61   PROP_CONTRAST,
  62   PROP_GAMMA,
  63   PROP_INVERSION,
  64   PROP_RANDOMVAL,
  65   PROP_FRAMES_DISPLAYED,
  66   PROP_FRAME_TIME
  67 };
  68
  69 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  70     GST_PAD_SINK,
  71     GST_PAD_ALWAYS,
  72     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("I420"))
  73     );
  74
  75 static GstCaps *gst_aasink_fixate (GstBaseSink * bsink, GstCaps * caps);
  76 static gboolean gst_aasink_setcaps (GstBaseSink * bsink, GstCaps * caps);
  77 static void gst_aasink_get_times (GstBaseSink * bsink, GstBuffer * buffer,
  78     GstClockTime * start, GstClockTime * end);
  79 static gboolean gst_aasink_propose_allocation (GstBaseSink * bsink,
  80     GstQuery * query);
  81 static GstFlowReturn gst_aasink_show_frame (GstVideoSink * videosink,
  82     GstBuffer * buffer);
  83
  84 static void gst_aasink_set_property (GObject * object, guint prop_id,
  85     const GValue * value, GParamSpec * pspec);
  86 static void gst_aasink_get_property (GObject * object, guint prop_id,
  87     GValue * value, GParamSpec * pspec);
  88
  89 static GstStateChangeReturn gst_aasink_change_state (GstElement * element,
  90     GstStateChange transition);
  91
  92 #define gst_aasink_parent_class parent_class
  93 G_DEFINE_TYPE (GstAASink, gst_aasink, GST_TYPE_VIDEO_SINK);
  94
  95 #define GST_TYPE_AADRIVERS (gst_aasink_drivers_get_type())
  96 static GType
  97 gst_aasink_drivers_get_type (void)
  98 {
  99   static GType driver_type = 0;
 100
 101   if (!driver_type) {
 102     GEnumValue *drivers;
 103     const struct aa_driver *driver;
 104     gint n_drivers;
 105     gint i;
 106
 107     for (n_drivers = 0; aa_drivers[n_drivers]; n_drivers++) {
 108       /* count number of drivers */
 109     }
 110
 111     drivers = g_new0 (GEnumValue, n_drivers + 1);
 112
 113     for (i = 0; i < n_drivers; i++) {
 114       driver = aa_drivers[i];
 115       drivers[i].value = i;
 116       drivers[i].value_name = g_strdup (driver->name);
 117       drivers[i].value_nick = g_utf8_strdown (driver->shortname, -1);
 118     }
 119     drivers[i].value = 0;
 120     drivers[i].value_name = NULL;
 121     drivers[i].value_nick = NULL;
 122
 123     driver_type = g_enum_register_static ("GstAASinkDrivers", drivers);
 124   }
 125   return driver_type;
 126 }
 127
 128 #define GST_TYPE_AADITHER (gst_aasink_dither_get_type())
 129 static GType
 130 gst_aasink_dither_get_type (void)
 131 {
 132   static GType dither_type = 0;
 133
 134   if (!dither_type) {
 135     GEnumValue *ditherers;
 136     gint n_ditherers;
 137     gint i;
 138
 139     for (n_ditherers = 0; aa_dithernames[n_ditherers]; n_ditherers++) {
 140       /* count number of ditherers */
 141     }
 142
 143     ditherers = g_new0 (GEnumValue, n_ditherers + 1);
 144
 145     for (i = 0; i < n_ditherers; i++) {
 146       ditherers[i].value = i;
 147       ditherers[i].value_name = g_strdup (aa_dithernames[i]);
 148       ditherers[i].value_nick =
 149           g_strdelimit (g_strdup (aa_dithernames[i]), " _", '-');
 150     }
 151     ditherers[i].value = 0;
 152     ditherers[i].value_name = NULL;
 153     ditherers[i].value_nick = NULL;
 154
 155     dither_type = g_enum_register_static ("GstAASinkDitherers", ditherers);
 156   }
 157   return dither_type;
 158 }
 159
 160 static void
 161 gst_aasink_class_init (GstAASinkClass * klass)
 162 {
 163   GObjectClass *gobject_class;
 164   GstElementClass *gstelement_class;
 165   GstBaseSinkClass *gstbasesink_class;
 166   GstVideoSinkClass *gstvideosink_class;
 167
 168   gobject_class = (GObjectClass *) klass;
 169   gstelement_class = (GstElementClass *) klass;
 170   gstbasesink_class = (GstBaseSinkClass *) klass;
 171   gstvideosink_class = (GstVideoSinkClass *) klass;
 172
 173   gobject_class->set_property = gst_aasink_set_property;
 174   gobject_class->get_property = gst_aasink_get_property;
 175
 176   /* FIXME: add long property descriptions */
 177   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_WIDTH,
 178       g_param_spec_int ("width", "width", "width", G_MININT, G_MAXINT, 0,
 179           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 180   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HEIGHT,
 181       g_param_spec_int ("height", "height", "height", G_MININT, G_MAXINT, 0,
 182           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 183   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_DRIVER,
 184       g_param_spec_enum ("driver", "driver", "driver", GST_TYPE_AADRIVERS, 0,
 185           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 186   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_DITHER,
 187       g_param_spec_enum ("dither", "dither", "dither", GST_TYPE_AADITHER, 0,
 188           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 189   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_BRIGHTNESS,
 190       g_param_spec_int ("brightness", "brightness", "brightness", G_MININT,
 191           G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 192   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_CONTRAST,
 193       g_param_spec_int ("contrast", "contrast", "contrast", G_MININT, G_MAXINT,
 194           0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 195   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_GAMMA,
 196       g_param_spec_float ("gamma", "gamma", "gamma", 0.0, 5.0, 1.0,
 197           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 198   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_INVERSION,
 199       g_param_spec_boolean ("inversion", "inversion", "inversion", TRUE,
 200           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 201   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_RANDOMVAL,
 202       g_param_spec_int ("randomval", "randomval", "randomval", G_MININT,
 203           G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 204   g_object_class_install_property (G_OBJECT_CLASS (klass),
 205       PROP_FRAMES_DISPLAYED, g_param_spec_int ("frames-displayed",
 206           "frames displayed", "frames displayed", G_MININT, G_MAXINT, 0,
 207           G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 208   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_FRAME_TIME,
 209       g_param_spec_int ("frame-time", "frame time", "frame time", G_MININT,
 210           G_MAXINT, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 211
 212   gst_element_class_add_pad_template (gstelement_class,
 213       gst_static_pad_template_get (&sink_template));
 214
 215   gst_element_class_set_details_simple (gstelement_class,
 216       "ASCII art video sink", "Sink/Video", "An ASCII art videosink",
 217       "Wim Taymans <wim.taymans@chello.be>");
 218
 219   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_aasink_change_state);
 220
 221   gstbasesink_class->fixate = GST_DEBUG_FUNCPTR (gst_aasink_fixate);
 222   gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_aasink_setcaps);
 223   gstbasesink_class->get_times = GST_DEBUG_FUNCPTR (gst_aasink_get_times);
 224   gstbasesink_class->propose_allocation =
 225       GST_DEBUG_FUNCPTR (gst_aasink_propose_allocation);
 226
 227   gstvideosink_class->show_frame = GST_DEBUG_FUNCPTR (gst_aasink_show_frame);
 228 }
 229
 230 static GstCaps *
 231 gst_aasink_fixate (GstBaseSink * bsink, GstCaps * caps)
 232 {
 233   GstStructure *structure;
 234
 235   caps = gst_caps_make_writable (caps);
 236
 237   structure = gst_caps_get_structure (caps, 0);
 238
 239   gst_structure_fixate_field_nearest_int (structure, "width", 320);
 240   gst_structure_fixate_field_nearest_int (structure, "height", 240);
 241   gst_structure_fixate_field_nearest_fraction (structure, "framerate", 30, 1);
 242
 243   caps = GST_BASE_SINK_CLASS (parent_class)->fixate (bsink, caps);
 244
 245   return caps;
 246 }
 247
 248 static gboolean
 249 gst_aasink_setcaps (GstBaseSink * basesink, GstCaps * caps)
 250 {
 251   GstAASink *aasink;
 252   GstVideoInfo info;
 253
 254   aasink = GST_AASINK (basesink);
 255
 256   if (!gst_video_info_from_caps (&info, caps))
 257     goto invalid_caps;
 258
 259   aasink->info = info;
 260
 261   return TRUE;
 262
 263   /* ERRORS */
 264 invalid_caps:
 265   {
 266     GST_DEBUG_OBJECT (aasink, "invalid caps");
 267     return FALSE;
 268   }
 269 }
 270
 271 static void
 272 gst_aasink_init (GstAASink * aasink)
 273 {
 274   memcpy (&aasink->ascii_surf, &aa_defparams,
 275       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
 285 static void
 286 gst_aasink_scale (GstAASink * aasink, guchar * src, guchar * dest,
 287     gint sw, gint sh, gint ss, gint dw, gint dh)
 288 {
 289   gint ypos, yinc, y;
 290   gint xpos, xinc, x;
 291
 292   g_return_if_fail ((dw != 0) && (dh != 0));
 293
 294   ypos = 0x10000;
 295   yinc = (sh << 16) / dh;
 296   xinc = (sw << 16) / dw;
 297
 298   for (y = dh; y; y--) {
 299     while (ypos > 0x10000) {
 300       ypos -= 0x10000;
 301       src += ss;
 302     }
 303     xpos = 0x10000;
 304     {
 305       guchar *destp = dest;
 306       guchar *srcp = src;
 307
 308       for (x = dw; x; x--) {
 309         while (xpos >= 0x10000L) {
 310           srcp++;
 311           xpos -= 0x10000L;
 312         }
 313         *destp++ = *srcp;
 314         xpos += xinc;
 315       }
 316     }
 317     dest += dw;
 318     ypos += yinc;
 319   }
 320 }
 321
 322 static void
 323 gst_aasink_get_times (GstBaseSink * sink, GstBuffer * buffer,
 324     GstClockTime * start, GstClockTime * end)
 325 {
 326   *start = GST_BUFFER_TIMESTAMP (buffer);
 327   if (GST_BUFFER_DURATION_IS_VALID (buffer))
 328     *end = *start + GST_BUFFER_DURATION (buffer);
 329 }
 330
 331 static gboolean
 332 gst_aasink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
 333 {
 334   GstCaps *caps;
 335   GstVideoInfo info;
 336   guint size;
 337
 338   gst_query_parse_allocation (query, &caps, NULL);
 339
 340   if (caps == NULL)
 341     goto no_caps;
 342
 343   if (!gst_video_info_from_caps (&info, caps))
 344     goto invalid_caps;
 345
 346   size = GST_VIDEO_INFO_SIZE (&info);
 347
 348   /* we need at least 2 buffer because we hold on to the last one */
 349   gst_query_set_allocation_params (query, size, 2, 0, 0, 0, 0, NULL);
 350
 351   /* we support various metadata */
 352   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE);
 353
 354   return TRUE;
 355
 356   /* ERRORS */
 357 no_caps:
 358   {
 359     GST_DEBUG_OBJECT (bsink, "no caps specified");
 360     return FALSE;
 361   }
 362 invalid_caps:
 363   {
 364     GST_DEBUG_OBJECT (bsink, "invalid caps specified");
 365     return FALSE;
 366   }
 367 }
 368
 369 static GstFlowReturn
 370 gst_aasink_show_frame (GstVideoSink * videosink, GstBuffer * buffer)
 371 {
 372   GstAASink *aasink;
 373   GstVideoFrame frame;
 374
 375   aasink = GST_AASINK (videosink);
 376
 377   GST_DEBUG ("show frame");
 378
 379   if (!gst_video_frame_map (&frame, &aasink->info, buffer, GST_MAP_READ))
 380     goto invalid_frame;
 381
 382   gst_aasink_scale (aasink, GST_VIDEO_FRAME_PLANE_DATA (&frame, 0),     /* src */
 383       aa_image (aasink->context),       /* dest */
 384       GST_VIDEO_INFO_WIDTH (&aasink->info),     /* sw */
 385       GST_VIDEO_INFO_HEIGHT (&aasink->info),    /* sh */
 386       GST_VIDEO_FRAME_PLANE_STRIDE (&frame, 0), /* ss */
 387       aa_imgwidth (aasink->context),    /* dw */
 388       aa_imgheight (aasink->context));  /* dh */
 389
 390   aa_render (aasink->context, &aasink->ascii_parms,
 391       0, 0, aa_imgwidth (aasink->context), aa_imgheight (aasink->context));
 392   aa_flush (aasink->context);
 393   aa_getevent (aasink->context, FALSE);
 394   gst_video_frame_unmap (&frame);
 395
 396   return GST_FLOW_OK;
 397
 398   /* ERRORS */
 399 invalid_frame:
 400   {
 401     GST_DEBUG_OBJECT (aasink, "invalid frame");
 402     return GST_FLOW_ERROR;
 403   }
 404 }
 405
 406
 407 static void
 408 gst_aasink_set_property (GObject * object, guint prop_id, const GValue * value,
 409     GParamSpec * pspec)
 410 {
 411   GstAASink *aasink;
 412
 413   aasink = GST_AASINK (object);
 414
 415   switch (prop_id) {
 416     case PROP_WIDTH:
 417       aasink->ascii_surf.width = g_value_get_int (value);
 418       break;
 419     case PROP_HEIGHT:
 420       aasink->ascii_surf.height = g_value_get_int (value);
 421       break;
 422     case PROP_DRIVER:{
 423       aasink->aa_driver = g_value_get_enum (value);
 424       break;
 425     }
 426     case PROP_DITHER:{
 427       aasink->ascii_parms.dither = g_value_get_enum (value);
 428       break;
 429     }
 430     case PROP_BRIGHTNESS:{
 431       aasink->ascii_parms.bright = g_value_get_int (value);
 432       break;
 433     }
 434     case PROP_CONTRAST:{
 435       aasink->ascii_parms.contrast = g_value_get_int (value);
 436       break;
 437     }
 438     case PROP_GAMMA:{
 439       aasink->ascii_parms.gamma = g_value_get_float (value);
 440       break;
 441     }
 442     case PROP_INVERSION:{
 443       aasink->ascii_parms.inversion = g_value_get_boolean (value);
 444       break;
 445     }
 446     case PROP_RANDOMVAL:{
 447       aasink->ascii_parms.randomval = g_value_get_int (value);
 448       break;
 449     }
 450     default:
 451       break;
 452   }
 453 }
 454
 455 static void
 456 gst_aasink_get_property (GObject * object, guint prop_id, GValue * value,
 457     GParamSpec * pspec)
 458 {
 459   GstAASink *aasink;
 460
 461   aasink = GST_AASINK (object);
 462
 463   switch (prop_id) {
 464     case PROP_WIDTH:{
 465       g_value_set_int (value, aasink->ascii_surf.width);
 466       break;
 467     }
 468     case PROP_HEIGHT:{
 469       g_value_set_int (value, aasink->ascii_surf.height);
 470       break;
 471     }
 472     case PROP_DRIVER:{
 473       g_value_set_enum (value, aasink->aa_driver);
 474       break;
 475     }
 476     case PROP_DITHER:{
 477       g_value_set_enum (value, aasink->ascii_parms.dither);
 478       break;
 479     }
 480     case PROP_BRIGHTNESS:{
 481       g_value_set_int (value, aasink->ascii_parms.bright);
 482       break;
 483     }
 484     case PROP_CONTRAST:{
 485       g_value_set_int (value, aasink->ascii_parms.contrast);
 486       break;
 487     }
 488     case PROP_GAMMA:{
 489       g_value_set_float (value, aasink->ascii_parms.gamma);
 490       break;
 491     }
 492     case PROP_INVERSION:{
 493       g_value_set_boolean (value, aasink->ascii_parms.inversion);
 494       break;
 495     }
 496     case PROP_RANDOMVAL:{
 497       g_value_set_int (value, aasink->ascii_parms.randomval);
 498       break;
 499     }
 500     case PROP_FRAMES_DISPLAYED:{
 501       g_value_set_int (value, aasink->frames_displayed);
 502       break;
 503     }
 504     case PROP_FRAME_TIME:{
 505       g_value_set_int (value, aasink->frame_time / 1000000);
 506       break;
 507     }
 508     default:{
 509       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 510       break;
 511     }
 512   }
 513 }
 514
 515 static gboolean
 516 gst_aasink_open (GstAASink * aasink)
 517 {
 518   if (!aasink->context) {
 519     aa_recommendhidisplay (aa_drivers[aasink->aa_driver]->shortname);
 520
 521     aasink->context = aa_autoinit (&aasink->ascii_surf);
 522     if (aasink->context == NULL) {
 523       GST_ELEMENT_ERROR (GST_ELEMENT (aasink), LIBRARY, TOO_LAZY, (NULL),
 524           ("error opening aalib context"));
 525       return FALSE;
 526     }
 527     aa_autoinitkbd (aasink->context, 0);
 528     aa_resizehandler (aasink->context, (void *) aa_resize);
 529   }
 530   return TRUE;
 531 }
 532
 533 static gboolean
 534 gst_aasink_close (GstAASink * aasink)
 535 {
 536   aa_close (aasink->context);
 537   aasink->context = NULL;
 538
 539   return TRUE;
 540 }
 541
 542 static GstStateChangeReturn
 543 gst_aasink_change_state (GstElement * element, GstStateChange transition)
 544 {
 545   GstStateChangeReturn ret;
 546
 547
 548   switch (transition) {
 549     case GST_STATE_CHANGE_NULL_TO_READY:
 550       break;
 551     case GST_STATE_CHANGE_READY_TO_PAUSED:
 552       if (!gst_aasink_open (GST_AASINK (element)))
 553         goto open_failed;
 554       break;
 555     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 556       break;
 557     default:
 558       break;
 559   }
 560
 561   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 562
 563   switch (transition) {
 564     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 565       break;
 566     case GST_STATE_CHANGE_PAUSED_TO_READY:
 567       break;
 568     case GST_STATE_CHANGE_READY_TO_NULL:
 569       gst_aasink_close (GST_AASINK (element));
 570       break;
 571     default:
 572       break;
 573   }
 574
 575   return ret;
 576
 577 open_failed:
 578   {
 579     return GST_STATE_CHANGE_FAILURE;
 580   }
 581 }
 582
 583 static gboolean
 584 plugin_init (GstPlugin * plugin)
 585 {
 586   if (!gst_element_register (plugin, "aasink", GST_RANK_NONE, GST_TYPE_AASINK))
 587     return FALSE;
 588
 589   return TRUE;
 590 }
 591
 592 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 593     GST_VERSION_MINOR,
 594     "aasink",
 595     "ASCII Art video sink",
 596     plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);