ext/libpng/gstpngdec.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is distributed in the hope that it will be useful,
   5  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   6  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   7  * Library General Public License for more details.
   8  *
   9  * You should have received a copy of the GNU Library General Public
  10  * License along with this library; if not, write to the
  11  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  12  * Boston, MA 02111-1307, USA.
  13  *
  14  */
  15 /**
  16  * SECTION:element-pngdec
  17  *
  18  * Decodes png images. If there is no framerate set on sink caps, it sends EOS
  19  * after the first picture.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include "gstpngdec.h"
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <gst/video/video.h>
  31 #include <gst/gst-i18n-plugin.h>
  32
  33 static const GstElementDetails gst_pngdec_details =
  34 GST_ELEMENT_DETAILS ("PNG image decoder",
  35     "Codec/Decoder/Image",
  36     "Decode a png video frame to a raw image",
  37     "Wim Taymans <wim@fluendo.com>");
  38
  39 GST_DEBUG_CATEGORY_STATIC (pngdec_debug);
  40 #define GST_CAT_DEFAULT pngdec_debug
  41
  42 static void gst_pngdec_base_init (gpointer g_class);
  43 static void gst_pngdec_class_init (GstPngDecClass * klass);
  44 static void gst_pngdec_init (GstPngDec * pngdec);
  45
  46 static gboolean gst_pngdec_libpng_init (GstPngDec * pngdec);
  47 static gboolean gst_pngdec_libpng_clear (GstPngDec * pngdec);
  48
  49 static GstStateChangeReturn gst_pngdec_change_state (GstElement * element,
  50     GstStateChange transition);
  51
  52 static gboolean gst_pngdec_sink_activate_push (GstPad * sinkpad,
  53     gboolean active);
  54 static gboolean gst_pngdec_sink_activate_pull (GstPad * sinkpad,
  55     gboolean active);
  56 static gboolean gst_pngdec_sink_activate (GstPad * sinkpad);
  57
  58 static GstFlowReturn gst_pngdec_caps_create_and_set (GstPngDec * pngdec);
  59
  60 static void gst_pngdec_task (GstPad * pad);
  61 static GstFlowReturn gst_pngdec_chain (GstPad * pad, GstBuffer * buffer);
  62 static gboolean gst_pngdec_sink_event (GstPad * pad, GstEvent * event);
  63 static gboolean gst_pngdec_sink_setcaps (GstPad * pad, GstCaps * caps);
  64
  65 static GstElementClass *parent_class = NULL;
  66
  67 GType
  68 gst_pngdec_get_type (void)
  69 {
  70   static GType pngdec_type = 0;
  71
  72   if (!pngdec_type) {
  73     static const GTypeInfo pngdec_info = {
  74       sizeof (GstPngDecClass),
  75       gst_pngdec_base_init,
  76       NULL,
  77       (GClassInitFunc) gst_pngdec_class_init,
  78       NULL,
  79       NULL,
  80       sizeof (GstPngDec),
  81       0,
  82       (GInstanceInitFunc) gst_pngdec_init,
  83     };
  84
  85     pngdec_type = g_type_register_static (GST_TYPE_ELEMENT, "GstPngDec",
  86         &pngdec_info, 0);
  87   }
  88   return pngdec_type;
  89 }
  90
  91 static GstStaticPadTemplate gst_pngdec_src_pad_template =
  92     GST_STATIC_PAD_TEMPLATE ("src",
  93     GST_PAD_SRC,
  94     GST_PAD_ALWAYS,
  95     GST_STATIC_CAPS (GST_VIDEO_CAPS_RGBA ";" GST_VIDEO_CAPS_RGB)
  96     );
  97
  98 static GstStaticPadTemplate gst_pngdec_sink_pad_template =
  99 GST_STATIC_PAD_TEMPLATE ("sink",
 100     GST_PAD_SINK,
 101     GST_PAD_ALWAYS,
 102     GST_STATIC_CAPS ("image/png")
 103     );
 104
 105 static void
 106 gst_pngdec_base_init (gpointer g_class)
 107 {
 108   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 109
 110   gst_element_class_add_pad_template (element_class,
 111       gst_static_pad_template_get (&gst_pngdec_src_pad_template));
 112   gst_element_class_add_pad_template (element_class,
 113       gst_static_pad_template_get (&gst_pngdec_sink_pad_template));
 114   gst_element_class_set_details (element_class, &gst_pngdec_details);
 115 }
 116
 117 static void
 118 gst_pngdec_class_init (GstPngDecClass * klass)
 119 {
 120   GstElementClass *gstelement_class;
 121
 122   gstelement_class = (GstElementClass *) klass;
 123
 124   parent_class = g_type_class_peek_parent (klass);
 125
 126   gstelement_class->change_state = gst_pngdec_change_state;
 127
 128   GST_DEBUG_CATEGORY_INIT (pngdec_debug, "pngdec", 0, "PNG image decoder");
 129 }
 130
 131 static void
 132 gst_pngdec_init (GstPngDec * pngdec)
 133 {
 134   pngdec->sinkpad =
 135       gst_pad_new_from_static_template (&gst_pngdec_sink_pad_template, "sink");
 136   gst_pad_set_activate_function (pngdec->sinkpad, gst_pngdec_sink_activate);
 137   gst_pad_set_activatepush_function (pngdec->sinkpad,
 138       gst_pngdec_sink_activate_push);
 139   gst_pad_set_activatepull_function (pngdec->sinkpad,
 140       gst_pngdec_sink_activate_pull);
 141   gst_pad_set_chain_function (pngdec->sinkpad, gst_pngdec_chain);
 142   gst_pad_set_event_function (pngdec->sinkpad, gst_pngdec_sink_event);
 143   gst_pad_set_setcaps_function (pngdec->sinkpad, gst_pngdec_sink_setcaps);
 144   gst_element_add_pad (GST_ELEMENT (pngdec), pngdec->sinkpad);
 145
 146   pngdec->srcpad =
 147       gst_pad_new_from_static_template (&gst_pngdec_src_pad_template, "src");
 148   gst_pad_use_fixed_caps (pngdec->srcpad);
 149   gst_element_add_pad (GST_ELEMENT (pngdec), pngdec->srcpad);
 150
 151   pngdec->buffer_out = NULL;
 152   pngdec->png = NULL;
 153   pngdec->info = NULL;
 154   pngdec->endinfo = NULL;
 155   pngdec->setup = FALSE;
 156
 157   pngdec->color_type = -1;
 158   pngdec->width = -1;
 159   pngdec->height = -1;
 160   pngdec->bpp = -1;
 161   pngdec->fps_n = 0;
 162   pngdec->fps_d = 1;
 163
 164   pngdec->in_timestamp = GST_CLOCK_TIME_NONE;
 165   pngdec->in_duration = GST_CLOCK_TIME_NONE;
 166
 167   gst_segment_init (&pngdec->segment, GST_FORMAT_UNDEFINED);
 168
 169   pngdec->image_ready = FALSE;
 170 }
 171
 172 static void
 173 user_error_fn (png_structp png_ptr, png_const_charp error_msg)
 174 {
 175   GST_ERROR ("%s", error_msg);
 176 }
 177
 178 static void
 179 user_warning_fn (png_structp png_ptr, png_const_charp warning_msg)
 180 {
 181   GST_WARNING ("%s", warning_msg);
 182 }
 183
 184 static void
 185 user_info_callback (png_structp png_ptr, png_infop info)
 186 {
 187   GstPngDec *pngdec = NULL;
 188   GstFlowReturn ret = GST_FLOW_OK;
 189   size_t buffer_size;
 190   GstBuffer *buffer = NULL;
 191
 192   pngdec = GST_PNGDEC (png_ptr->io_ptr);
 193
 194   GST_LOG ("info ready");
 195
 196   /* Generate the caps and configure */
 197   ret = gst_pngdec_caps_create_and_set (pngdec);
 198   if (ret != GST_FLOW_OK) {
 199     goto beach;
 200   }
 201
 202   /* Allocate output buffer */
 203   pngdec->rowbytes = png_get_rowbytes (pngdec->png, pngdec->info);
 204   buffer_size = pngdec->height * GST_ROUND_UP_4 (pngdec->rowbytes);
 205   ret =
 206       gst_pad_alloc_buffer_and_set_caps (pngdec->srcpad, GST_BUFFER_OFFSET_NONE,
 207       buffer_size, GST_PAD_CAPS (pngdec->srcpad), &buffer);
 208   if (ret != GST_FLOW_OK) {
 209     goto beach;
 210   }
 211
 212   pngdec->buffer_out = buffer;
 213
 214 beach:
 215   pngdec->ret = ret;
 216 }
 217
 218 static void
 219 user_endrow_callback (png_structp png_ptr, png_bytep new_row,
 220     png_uint_32 row_num, int pass)
 221 {
 222   GstPngDec *pngdec = NULL;
 223
 224   pngdec = GST_PNGDEC (png_ptr->io_ptr);
 225
 226   /* FIXME: implement interlaced pictures */
 227
 228   /* If buffer_out doesn't exist, it means buffer_alloc failed, which
 229    * will already have set the return code */
 230   if (GST_IS_BUFFER (pngdec->buffer_out)) {
 231     size_t offset = row_num * GST_ROUND_UP_4 (pngdec->rowbytes);
 232
 233     GST_LOG ("got row %u, copying in buffer %p at offset %" G_GSIZE_FORMAT,
 234         (guint) row_num, pngdec->buffer_out, offset);
 235     memcpy (GST_BUFFER_DATA (pngdec->buffer_out) + offset, new_row,
 236         pngdec->rowbytes);
 237     pngdec->ret = GST_FLOW_OK;
 238   }
 239 }
 240
 241 static gboolean
 242 buffer_clip (GstPngDec * dec, GstBuffer * buffer)
 243 {
 244   gboolean res = TRUE;
 245   gint64 cstart, cstop;
 246
 247
 248   if ((!GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (buffer))) ||
 249       (!GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DURATION (buffer))) ||
 250       (dec->segment.format != GST_FORMAT_TIME))
 251     goto beach;
 252
 253   cstart = GST_BUFFER_TIMESTAMP (buffer);
 254   cstop = GST_BUFFER_DURATION (buffer);
 255
 256   if ((res = gst_segment_clip (&dec->segment, GST_FORMAT_TIME,
 257               cstart, cstart + cstop, &cstart, &cstop))) {
 258     GST_BUFFER_TIMESTAMP (buffer) = cstart;
 259     GST_BUFFER_DURATION (buffer) = cstop - cstart;
 260   }
 261
 262 beach:
 263   return res;
 264 }
 265
 266 static void
 267 user_end_callback (png_structp png_ptr, png_infop info)
 268 {
 269   GstPngDec *pngdec = NULL;
 270
 271   pngdec = GST_PNGDEC (png_ptr->io_ptr);
 272
 273   GST_LOG_OBJECT (pngdec, "and we are done reading this image");
 274
 275   if (!pngdec->buffer_out)
 276     return;
 277
 278   if (GST_CLOCK_TIME_IS_VALID (pngdec->in_timestamp))
 279     GST_BUFFER_TIMESTAMP (pngdec->buffer_out) = pngdec->in_timestamp;
 280   if (GST_CLOCK_TIME_IS_VALID (pngdec->in_duration))
 281     GST_BUFFER_DURATION (pngdec->buffer_out) = pngdec->in_duration;
 282
 283   /* buffer clipping */
 284   if (buffer_clip (pngdec, pngdec->buffer_out)) {
 285     /* Push our buffer and then EOS if needed */
 286     GST_LOG_OBJECT (pngdec, "pushing buffer with ts=%" GST_TIME_FORMAT,
 287         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (pngdec->buffer_out)));
 288
 289     pngdec->ret = gst_pad_push (pngdec->srcpad, pngdec->buffer_out);
 290   } else {
 291     GST_LOG_OBJECT (pngdec, "dropped decoded buffer");
 292     gst_buffer_unref (pngdec->buffer_out);
 293   }
 294   pngdec->buffer_out = NULL;
 295   pngdec->image_ready = TRUE;
 296 }
 297
 298 static void
 299 user_read_data (png_structp png_ptr, png_bytep data, png_size_t length)
 300 {
 301   GstPngDec *pngdec;
 302   GstBuffer *buffer;
 303   GstFlowReturn ret = GST_FLOW_OK;
 304   guint size;
 305
 306   pngdec = GST_PNGDEC (png_ptr->io_ptr);
 307
 308   GST_LOG ("reading %" G_GSIZE_FORMAT " bytes of data at offset %d", length,
 309       pngdec->offset);
 310
 311   ret = gst_pad_pull_range (pngdec->sinkpad, pngdec->offset, length, &buffer);
 312   if (ret != GST_FLOW_OK)
 313     goto pause;
 314
 315   size = GST_BUFFER_SIZE (buffer);
 316
 317   if (size != length)
 318     goto short_buffer;
 319
 320   memcpy (data, GST_BUFFER_DATA (buffer), size);
 321
 322   gst_buffer_unref (buffer);
 323
 324   pngdec->offset += length;
 325
 326   return;
 327
 328   /* ERRORS */
 329 pause:
 330   {
 331     GST_INFO_OBJECT (pngdec, "pausing task, reason %s",
 332         gst_flow_get_name (ret));
 333     gst_pad_pause_task (pngdec->sinkpad);
 334     if (GST_FLOW_IS_FATAL (ret) || ret == GST_FLOW_NOT_LINKED) {
 335       GST_ELEMENT_ERROR (pngdec, STREAM, FAILED,
 336           (_("Internal data stream error.")),
 337           ("stream stopped, reason %s", gst_flow_get_name (ret)));
 338       gst_pad_push_event (pngdec->srcpad, gst_event_new_eos ());
 339     }
 340     return;
 341   }
 342 short_buffer:
 343   {
 344     gst_buffer_unref (buffer);
 345     GST_ELEMENT_ERROR (pngdec, STREAM, FAILED,
 346         (_("Internal data stream error.")),
 347         ("Read %u, needed %u bytes", size, length));
 348     ret = GST_FLOW_ERROR;
 349     goto pause;
 350   }
 351 }
 352
 353 static GstFlowReturn
 354 gst_pngdec_caps_create_and_set (GstPngDec * pngdec)
 355 {
 356   GstFlowReturn ret = GST_FLOW_OK;
 357   GstCaps *caps = NULL, *res = NULL;
 358   GstPadTemplate *templ = NULL;
 359   gint bpc = 0, color_type;
 360   png_uint_32 width, height;
 361
 362   g_return_val_if_fail (GST_IS_PNGDEC (pngdec), GST_FLOW_ERROR);
 363
 364   /* Get bits per channel */
 365   bpc = png_get_bit_depth (pngdec->png, pngdec->info);
 366
 367   /* We don't handle 16 bits per color, strip down to 8 */
 368   if (bpc == 16) {
 369     GST_LOG_OBJECT (pngdec,
 370         "this is a 16 bits per channel PNG image, strip down to 8 bits");
 371     png_set_strip_16 (pngdec->png);
 372   }
 373
 374   /* Get Color type */
 375   color_type = png_get_color_type (pngdec->png, pngdec->info);
 376
 377 #if 0
 378   /* We used to have this HACK to reverse the outgoing bytes, but the problem
 379    * that originally required the hack seems to have been in ffmpegcolorspace's
 380    * RGBA descriptions. It doesn't seem needed now that's fixed, but might
 381    * still be needed on big-endian systems, I'm not sure. J.S. 6/7/2007 */
 382   if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 383     png_set_bgr (pngdec->png);
 384 #endif
 385
 386   /* Gray scale converted to RGB and upscaled to 8 bits */
 387   if ((color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ||
 388       (color_type == PNG_COLOR_TYPE_GRAY)) {
 389     GST_LOG_OBJECT (pngdec, "converting grayscale png to RGB");
 390     png_set_gray_to_rgb (pngdec->png);
 391     if (bpc < 8) {              /* Convert to 8 bits */
 392       GST_LOG_OBJECT (pngdec, "converting grayscale image to 8 bits");
 393       png_set_gray_1_2_4_to_8 (pngdec->png);
 394     }
 395   }
 396
 397   /* Palette converted to RGB */
 398   if (color_type == PNG_COLOR_TYPE_PALETTE) {
 399     GST_LOG_OBJECT (pngdec, "converting palette png to RGB");
 400     png_set_palette_to_rgb (pngdec->png);
 401   }
 402
 403   /* Update the info structure */
 404   png_read_update_info (pngdec->png, pngdec->info);
 405
 406   /* Get IHDR header again after transformation settings */
 407
 408   png_get_IHDR (pngdec->png, pngdec->info, &width, &height,
 409       &bpc, &pngdec->color_type, NULL, NULL, NULL);
 410
 411   pngdec->width = width;
 412   pngdec->height = height;
 413
 414   GST_LOG_OBJECT (pngdec, "this is a %dx%d PNG image", pngdec->width,
 415       pngdec->height);
 416
 417   switch (pngdec->color_type) {
 418     case PNG_COLOR_TYPE_RGB:
 419       GST_LOG_OBJECT (pngdec, "we have no alpha channel, depth is 24 bits");
 420       pngdec->bpp = 24;
 421       break;
 422     case PNG_COLOR_TYPE_RGB_ALPHA:
 423       GST_LOG_OBJECT (pngdec, "we have an alpha channel, depth is 32 bits");
 424       pngdec->bpp = 32;
 425       break;
 426     default:
 427       GST_ELEMENT_ERROR (pngdec, STREAM, NOT_IMPLEMENTED, (NULL),
 428           ("pngdec does not support this color type"));
 429       ret = GST_FLOW_NOT_SUPPORTED;
 430       goto beach;
 431   }
 432
 433   caps = gst_caps_new_simple ("video/x-raw-rgb",
 434       "width", G_TYPE_INT, pngdec->width,
 435       "height", G_TYPE_INT, pngdec->height,
 436       "bpp", G_TYPE_INT, pngdec->bpp,
 437       "framerate", GST_TYPE_FRACTION, pngdec->fps_n, pngdec->fps_d, NULL);
 438
 439   templ = gst_static_pad_template_get (&gst_pngdec_src_pad_template);
 440
 441   res = gst_caps_intersect (caps, gst_pad_template_get_caps (templ));
 442
 443   gst_caps_unref (caps);
 444   gst_object_unref (templ);
 445
 446   if (!gst_pad_set_caps (pngdec->srcpad, res))
 447     ret = GST_FLOW_NOT_NEGOTIATED;
 448
 449   GST_DEBUG_OBJECT (pngdec, "our caps %" GST_PTR_FORMAT, res);
 450
 451   gst_caps_unref (res);
 452
 453   /* Push a newsegment event */
 454   if (pngdec->need_newsegment) {
 455     gst_pad_push_event (pngdec->srcpad,
 456         gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, 0, -1, 0));
 457     pngdec->need_newsegment = FALSE;
 458   }
 459
 460 beach:
 461   return ret;
 462 }
 463
 464 static void
 465 gst_pngdec_task (GstPad * pad)
 466 {
 467   GstPngDec *pngdec;
 468   GstBuffer *buffer = NULL;
 469   size_t buffer_size = 0;
 470   gint i = 0;
 471   png_bytep *rows, inp;
 472   png_uint_32 rowbytes;
 473   GstFlowReturn ret = GST_FLOW_OK;
 474
 475   pngdec = GST_PNGDEC (GST_OBJECT_PARENT (pad));
 476
 477   GST_LOG_OBJECT (pngdec, "read frame");
 478
 479   /* Let libpng come back here on error */
 480   if (setjmp (png_jmpbuf (pngdec->png))) {
 481     ret = GST_FLOW_ERROR;
 482     goto pause;
 483   }
 484
 485   /* Set reading callback */
 486   png_set_read_fn (pngdec->png, pngdec, user_read_data);
 487
 488   /* Read info */
 489   png_read_info (pngdec->png, pngdec->info);
 490
 491   /* Generate the caps and configure */
 492   ret = gst_pngdec_caps_create_and_set (pngdec);
 493   if (ret != GST_FLOW_OK) {
 494     goto pause;
 495   }
 496
 497   /* Allocate output buffer */
 498   rowbytes = png_get_rowbytes (pngdec->png, pngdec->info);
 499   buffer_size = pngdec->height * GST_ROUND_UP_4 (rowbytes);
 500   ret =
 501       gst_pad_alloc_buffer_and_set_caps (pngdec->srcpad, GST_BUFFER_OFFSET_NONE,
 502       buffer_size, GST_PAD_CAPS (pngdec->srcpad), &buffer);
 503   if (ret != GST_FLOW_OK)
 504     goto pause;
 505
 506   rows = (png_bytep *) g_malloc (sizeof (png_bytep) * pngdec->height);
 507
 508   inp = GST_BUFFER_DATA (buffer);
 509
 510   for (i = 0; i < pngdec->height; i++) {
 511     rows[i] = inp;
 512     inp += GST_ROUND_UP_4 (rowbytes);
 513   }
 514
 515   /* Read the actual picture */
 516   png_read_image (pngdec->png, rows);
 517   free (rows);
 518
 519   /* Push the raw RGB frame */
 520   ret = gst_pad_push (pngdec->srcpad, buffer);
 521   if (ret != GST_FLOW_OK)
 522     goto pause;
 523
 524   /* And we are done */
 525   gst_pad_pause_task (pngdec->sinkpad);
 526   gst_pad_push_event (pngdec->srcpad, gst_event_new_eos ());
 527   return;
 528
 529 pause:
 530   {
 531     GST_INFO_OBJECT (pngdec, "pausing task, reason %s",
 532         gst_flow_get_name (ret));
 533     gst_pad_pause_task (pngdec->sinkpad);
 534     if (GST_FLOW_IS_FATAL (ret) || ret == GST_FLOW_NOT_LINKED) {
 535       GST_ELEMENT_ERROR (pngdec, STREAM, FAILED,
 536           (_("Internal data stream error.")),
 537           ("stream stopped, reason %s", gst_flow_get_name (ret)));
 538       gst_pad_push_event (pngdec->srcpad, gst_event_new_eos ());
 539     }
 540   }
 541 }
 542
 543 static GstFlowReturn
 544 gst_pngdec_chain (GstPad * pad, GstBuffer * buffer)
 545 {
 546   GstPngDec *pngdec;
 547   GstFlowReturn ret = GST_FLOW_OK;
 548
 549   pngdec = GST_PNGDEC (gst_pad_get_parent (pad));
 550
 551   GST_LOG_OBJECT (pngdec, "Got buffer, size=%u", GST_BUFFER_SIZE (buffer));
 552
 553   if (G_UNLIKELY (!pngdec->setup))
 554     goto not_configured;
 555
 556   /* Something is going wrong in our callbacks */
 557   ret = pngdec->ret;
 558   if (G_UNLIKELY (ret != GST_FLOW_OK)) {
 559     GST_WARNING_OBJECT (pngdec, "we have a pending return code of %d", ret);
 560     goto beach;
 561   }
 562
 563   /* Let libpng come back here on error */
 564   if (setjmp (png_jmpbuf (pngdec->png))) {
 565     GST_WARNING_OBJECT (pngdec, "error during decoding");
 566     ret = GST_FLOW_ERROR;
 567     goto beach;
 568   }
 569
 570   pngdec->in_timestamp = GST_BUFFER_TIMESTAMP (buffer);
 571   pngdec->in_duration = GST_BUFFER_DURATION (buffer);
 572
 573   /* Progressive loading of the PNG image */
 574   png_process_data (pngdec->png, pngdec->info, GST_BUFFER_DATA (buffer),
 575       GST_BUFFER_SIZE (buffer));
 576
 577   if (pngdec->image_ready) {
 578     if (pngdec->framed) {
 579       /* Reset ourselves for the next frame */
 580       gst_pngdec_libpng_clear (pngdec);
 581       gst_pngdec_libpng_init (pngdec);
 582       GST_LOG_OBJECT (pngdec, "setting up callbacks for next frame");
 583       png_set_progressive_read_fn (pngdec->png, pngdec,
 584           user_info_callback, user_endrow_callback, user_end_callback);
 585     } else {
 586       GST_LOG_OBJECT (pngdec, "sending EOS");
 587       pngdec->ret = gst_pad_push_event (pngdec->srcpad, gst_event_new_eos ());
 588     }
 589     pngdec->image_ready = FALSE;
 590   }
 591
 592   /* grab new return code */
 593   ret = pngdec->ret;
 594
 595   /* And release the buffer */
 596   gst_buffer_unref (buffer);
 597
 598 beach:
 599   gst_object_unref (pngdec);
 600
 601   return ret;
 602
 603   /* ERRORS */
 604 not_configured:
 605   {
 606     GST_LOG_OBJECT (pngdec, "we are not configured yet");
 607     ret = GST_FLOW_WRONG_STATE;
 608     goto beach;
 609   }
 610 }
 611
 612 static gboolean
 613 gst_pngdec_sink_setcaps (GstPad * pad, GstCaps * caps)
 614 {
 615   GstStructure *s;
 616   GstPngDec *pngdec;
 617   gint num, denom;
 618
 619   pngdec = GST_PNGDEC (gst_pad_get_parent (pad));
 620
 621   s = gst_caps_get_structure (caps, 0);
 622   if (gst_structure_get_fraction (s, "framerate", &num, &denom)) {
 623     GST_DEBUG_OBJECT (pngdec, "framed input");
 624     pngdec->framed = TRUE;
 625     pngdec->fps_n = num;
 626     pngdec->fps_d = denom;
 627   } else {
 628     GST_DEBUG_OBJECT (pngdec, "single picture input");
 629     pngdec->framed = FALSE;
 630     pngdec->fps_n = 0;
 631     pngdec->fps_d = 1;
 632   }
 633
 634   gst_object_unref (pngdec);
 635   return TRUE;
 636 }
 637
 638 static gboolean
 639 gst_pngdec_sink_event (GstPad * pad, GstEvent * event)
 640 {
 641   GstPngDec *pngdec;
 642   gboolean res;
 643
 644   pngdec = GST_PNGDEC (gst_pad_get_parent (pad));
 645
 646   switch (GST_EVENT_TYPE (event)) {
 647     case GST_EVENT_NEWSEGMENT:{
 648       gdouble rate, arate;
 649       gboolean update;
 650       gint64 start, stop, position;
 651       GstFormat fmt;
 652
 653       gst_event_parse_new_segment_full (event, &update, &rate, &arate, &fmt,
 654           &start, &stop, &position);
 655
 656       gst_segment_set_newsegment_full (&pngdec->segment, update, rate, arate,
 657           fmt, start, stop, position);
 658
 659       GST_LOG_OBJECT (pngdec, "NEWSEGMENT (%s)", gst_format_get_name (fmt));
 660
 661       if (fmt == GST_FORMAT_TIME) {
 662         pngdec->need_newsegment = FALSE;
 663         res = gst_pad_push_event (pngdec->srcpad, event);
 664       } else {
 665         gst_event_unref (event);
 666         res = TRUE;
 667       }
 668       break;
 669     }
 670     case GST_EVENT_FLUSH_STOP:
 671     {
 672       gst_pngdec_libpng_clear (pngdec);
 673       gst_pngdec_libpng_init (pngdec);
 674       png_set_progressive_read_fn (pngdec->png, pngdec,
 675           user_info_callback, user_endrow_callback, user_end_callback);
 676       pngdec->ret = GST_FLOW_OK;
 677       gst_segment_init (&pngdec->segment, GST_FORMAT_UNDEFINED);
 678       res = gst_pad_push_event (pngdec->srcpad, event);
 679       break;
 680     }
 681     case GST_EVENT_EOS:
 682     {
 683       GST_LOG_OBJECT (pngdec, "EOS");
 684       gst_pngdec_libpng_clear (pngdec);
 685       pngdec->ret = GST_FLOW_UNEXPECTED;
 686       res = gst_pad_push_event (pngdec->srcpad, event);
 687       break;
 688     }
 689     default:
 690       res = gst_pad_push_event (pngdec->srcpad, event);
 691       break;
 692   }
 693
 694   gst_object_unref (pngdec);
 695   return res;
 696 }
 697
 698
 699 /* Clean up the libpng structures */
 700 static gboolean
 701 gst_pngdec_libpng_clear (GstPngDec * pngdec)
 702 {
 703   png_infopp info = NULL, endinfo = NULL;
 704
 705   g_return_val_if_fail (GST_IS_PNGDEC (pngdec), FALSE);
 706
 707   GST_LOG ("cleaning up libpng structures");
 708
 709   if (pngdec->info) {
 710     info = &pngdec->info;
 711   }
 712
 713   if (pngdec->endinfo) {
 714     endinfo = &pngdec->endinfo;
 715   }
 716
 717   if (pngdec->png) {
 718     png_destroy_read_struct (&(pngdec->png), info, endinfo);
 719     pngdec->png = NULL;
 720     pngdec->info = NULL;
 721     pngdec->endinfo = NULL;
 722   }
 723
 724   pngdec->bpp = pngdec->color_type = pngdec->height = pngdec->width = -1;
 725   pngdec->offset = 0;
 726   pngdec->rowbytes = 0;
 727   pngdec->buffer_out = NULL;
 728
 729   pngdec->setup = FALSE;
 730
 731   pngdec->in_timestamp = GST_CLOCK_TIME_NONE;
 732   pngdec->in_duration = GST_CLOCK_TIME_NONE;
 733
 734   return TRUE;
 735 }
 736
 737 static gboolean
 738 gst_pngdec_libpng_init (GstPngDec * pngdec)
 739 {
 740   g_return_val_if_fail (GST_IS_PNGDEC (pngdec), FALSE);
 741
 742   if (pngdec->setup)
 743     return TRUE;
 744
 745   GST_LOG ("init libpng structures");
 746
 747   /* initialize png struct stuff */
 748   pngdec->png = png_create_read_struct (PNG_LIBPNG_VER_STRING,
 749       (png_voidp) NULL, user_error_fn, user_warning_fn);
 750
 751   if (pngdec->png == NULL)
 752     goto init_failed;
 753
 754   pngdec->info = png_create_info_struct (pngdec->png);
 755   if (pngdec->info == NULL)
 756     goto info_failed;
 757
 758   pngdec->endinfo = png_create_info_struct (pngdec->png);
 759   if (pngdec->endinfo == NULL)
 760     goto endinfo_failed;
 761
 762   pngdec->setup = TRUE;
 763
 764   return TRUE;
 765
 766   /* ERRORS */
 767 init_failed:
 768   {
 769     GST_ELEMENT_ERROR (pngdec, LIBRARY, INIT, (NULL),
 770         ("Failed to initialize png structure"));
 771     return FALSE;
 772   }
 773 info_failed:
 774   {
 775     gst_pngdec_libpng_clear (pngdec);
 776     GST_ELEMENT_ERROR (pngdec, LIBRARY, INIT, (NULL),
 777         ("Failed to initialize info structure"));
 778     return FALSE;
 779   }
 780 endinfo_failed:
 781   {
 782     gst_pngdec_libpng_clear (pngdec);
 783     GST_ELEMENT_ERROR (pngdec, LIBRARY, INIT, (NULL),
 784         ("Failed to initialize endinfo structure"));
 785     return FALSE;
 786   }
 787 }
 788
 789 static GstStateChangeReturn
 790 gst_pngdec_change_state (GstElement * element, GstStateChange transition)
 791 {
 792   GstStateChangeReturn ret;
 793   GstPngDec *pngdec;
 794
 795   pngdec = GST_PNGDEC (element);
 796
 797   switch (transition) {
 798     case GST_STATE_CHANGE_READY_TO_PAUSED:
 799       gst_pngdec_libpng_init (pngdec);
 800       pngdec->need_newsegment = TRUE;
 801       pngdec->framed = FALSE;
 802       pngdec->ret = GST_FLOW_OK;
 803       gst_segment_init (&pngdec->segment, GST_FORMAT_UNDEFINED);
 804       break;
 805     default:
 806       break;
 807   }
 808
 809   ret = parent_class->change_state (element, transition);
 810   if (ret != GST_STATE_CHANGE_SUCCESS)
 811     return ret;
 812
 813   switch (transition) {
 814     case GST_STATE_CHANGE_PAUSED_TO_READY:
 815       gst_pngdec_libpng_clear (pngdec);
 816       break;
 817     default:
 818       break;
 819   }
 820
 821   return ret;
 822 }
 823
 824 /* this function gets called when we activate ourselves in push mode. */
 825 static gboolean
 826 gst_pngdec_sink_activate_push (GstPad * sinkpad, gboolean active)
 827 {
 828   GstPngDec *pngdec;
 829
 830   pngdec = GST_PNGDEC (GST_OBJECT_PARENT (sinkpad));
 831
 832   pngdec->ret = GST_FLOW_OK;
 833
 834   if (active) {
 835     /* Let libpng come back here on error */
 836     if (setjmp (png_jmpbuf (pngdec->png)))
 837       goto setup_failed;
 838
 839     GST_LOG ("setting up progressive loading callbacks");
 840     png_set_progressive_read_fn (pngdec->png, pngdec,
 841         user_info_callback, user_endrow_callback, user_end_callback);
 842   }
 843   return TRUE;
 844
 845 setup_failed:
 846   {
 847     GST_LOG ("failed setting up libpng jmpbuf");
 848     gst_pngdec_libpng_clear (pngdec);
 849     return FALSE;
 850   }
 851 }
 852
 853 /* this function gets called when we activate ourselves in pull mode.
 854  * We can perform  random access to the resource and we start a task
 855  * to start reading */
 856 static gboolean
 857 gst_pngdec_sink_activate_pull (GstPad * sinkpad, gboolean active)
 858 {
 859   GstPngDec *pngdec;
 860
 861   pngdec = GST_PNGDEC (GST_OBJECT_PARENT (sinkpad));
 862
 863   if (active) {
 864     return gst_pad_start_task (sinkpad, (GstTaskFunction) gst_pngdec_task,
 865         sinkpad);
 866   } else {
 867     return gst_pad_stop_task (sinkpad);
 868   }
 869 }
 870
 871 /* this function is called when the pad is activated and should start
 872  * processing data.
 873  *
 874  * We check if we can do random access to decide if we work push or
 875  * pull based.
 876  */
 877 static gboolean
 878 gst_pngdec_sink_activate (GstPad * sinkpad)
 879 {
 880   if (gst_pad_check_pull_range (sinkpad)) {
 881     return gst_pad_activate_pull (sinkpad, TRUE);
 882   } else {
 883     return gst_pad_activate_push (sinkpad, TRUE);
 884   }
 885 }