| /* GStreamer |
| * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu> |
| * Copyright (C) 2012 Collabora Ltd. |
| * Author : Edward Hervey <edward@collabora.com> |
| * Copyright (C) 2013 Collabora Ltd. |
| * Author : Sebastian Dröge <sebastian.droege@collabora.co.uk> |
| * Olivier Crete <olivier.crete@collabora.com> |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public |
| * License along with this library; if not, write to the |
| * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| * |
| */ |
| /** |
| * SECTION:element-pngdec |
| * |
| * Decodes png images. If there is no framerate set on sink caps, it sends EOS |
| * after the first picture. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include "gstpngdec.h" |
| |
| #include <stdlib.h> |
| #include <string.h> |
| #include <gst/base/gstbytereader.h> |
| #include <gst/video/video.h> |
| #include <gst/video/gstvideometa.h> |
| #include <gst/video/gstvideopool.h> |
| #include <gst/gst-i18n-plugin.h> |
| |
| GST_DEBUG_CATEGORY_STATIC (pngdec_debug); |
| #define GST_CAT_DEFAULT pngdec_debug |
| |
| static gboolean gst_pngdec_libpng_init (GstPngDec * pngdec); |
| |
| static GstFlowReturn gst_pngdec_caps_create_and_set (GstPngDec * pngdec); |
| |
| static gboolean gst_pngdec_start (GstVideoDecoder * decoder); |
| static gboolean gst_pngdec_stop (GstVideoDecoder * decoder); |
| static gboolean gst_pngdec_flush (GstVideoDecoder * decoder); |
| static gboolean gst_pngdec_set_format (GstVideoDecoder * Decoder, |
| GstVideoCodecState * state); |
| static GstFlowReturn gst_pngdec_parse (GstVideoDecoder * decoder, |
| GstVideoCodecFrame * frame, GstAdapter * adapter, gboolean at_eos); |
| static GstFlowReturn gst_pngdec_handle_frame (GstVideoDecoder * decoder, |
| GstVideoCodecFrame * frame); |
| static gboolean gst_pngdec_decide_allocation (GstVideoDecoder * decoder, |
| GstQuery * query); |
| static gboolean gst_pngdec_sink_event (GstVideoDecoder * bdec, |
| GstEvent * event); |
| |
| #define parent_class gst_pngdec_parent_class |
| G_DEFINE_TYPE (GstPngDec, gst_pngdec, GST_TYPE_VIDEO_DECODER); |
| |
| static GstStaticPadTemplate gst_pngdec_src_pad_template = |
| GST_STATIC_PAD_TEMPLATE ("src", |
| GST_PAD_SRC, |
| GST_PAD_ALWAYS, |
| GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE |
| ("{ RGBA, RGB, ARGB64, GRAY8, GRAY16_BE }")) |
| ); |
| |
| static GstStaticPadTemplate gst_pngdec_sink_pad_template = |
| GST_STATIC_PAD_TEMPLATE ("sink", |
| GST_PAD_SINK, |
| GST_PAD_ALWAYS, |
| GST_STATIC_CAPS ("image/png") |
| ); |
| |
| static void |
| gst_pngdec_class_init (GstPngDecClass * klass) |
| { |
| GstElementClass *element_class = (GstElementClass *) klass; |
| GstVideoDecoderClass *vdec_class = (GstVideoDecoderClass *) klass; |
| |
| gst_element_class_add_static_pad_template (element_class, |
| &gst_pngdec_src_pad_template); |
| gst_element_class_add_static_pad_template (element_class, |
| &gst_pngdec_sink_pad_template); |
| gst_element_class_set_static_metadata (element_class, "PNG image decoder", |
| "Codec/Decoder/Image", "Decode a png video frame to a raw image", |
| "Wim Taymans <wim@fluendo.com>"); |
| |
| vdec_class->start = gst_pngdec_start; |
| vdec_class->stop = gst_pngdec_stop; |
| vdec_class->flush = gst_pngdec_flush; |
| vdec_class->set_format = gst_pngdec_set_format; |
| vdec_class->parse = gst_pngdec_parse; |
| vdec_class->handle_frame = gst_pngdec_handle_frame; |
| vdec_class->decide_allocation = gst_pngdec_decide_allocation; |
| vdec_class->sink_event = gst_pngdec_sink_event; |
| |
| GST_DEBUG_CATEGORY_INIT (pngdec_debug, "pngdec", 0, "PNG image decoder"); |
| } |
| |
| static void |
| gst_pngdec_init (GstPngDec * pngdec) |
| { |
| pngdec->png = NULL; |
| pngdec->info = NULL; |
| pngdec->endinfo = NULL; |
| |
| pngdec->color_type = -1; |
| |
| pngdec->image_ready = FALSE; |
| pngdec->read_data = 0; |
| |
| gst_video_decoder_set_use_default_pad_acceptcaps (GST_VIDEO_DECODER_CAST |
| (pngdec), TRUE); |
| GST_PAD_SET_ACCEPT_TEMPLATE (GST_VIDEO_DECODER_SINK_PAD (pngdec)); |
| } |
| |
| static void |
| user_error_fn (png_structp png_ptr, png_const_charp error_msg) |
| { |
| GST_ERROR ("%s", error_msg); |
| } |
| |
| static void |
| user_warning_fn (png_structp png_ptr, png_const_charp warning_msg) |
| { |
| GST_WARNING ("%s", warning_msg); |
| } |
| |
| static void |
| user_info_callback (png_structp png_ptr, png_infop info) |
| { |
| GstPngDec *pngdec = NULL; |
| GstFlowReturn ret; |
| |
| GST_LOG ("info ready"); |
| |
| pngdec = GST_PNGDEC (png_get_io_ptr (png_ptr)); |
| /* Generate the caps and configure */ |
| ret = gst_pngdec_caps_create_and_set (pngdec); |
| if (ret != GST_FLOW_OK) { |
| goto beach; |
| } |
| |
| /* Allocate output buffer */ |
| ret = |
| gst_video_decoder_allocate_output_frame (GST_VIDEO_DECODER (pngdec), |
| pngdec->current_frame); |
| if (G_UNLIKELY (ret != GST_FLOW_OK)) |
| GST_DEBUG_OBJECT (pngdec, "failed to acquire buffer"); |
| |
| beach: |
| pngdec->ret = ret; |
| } |
| |
| static gboolean |
| gst_pngdec_set_format (GstVideoDecoder * decoder, GstVideoCodecState * state) |
| { |
| GstPngDec *pngdec = (GstPngDec *) decoder; |
| |
| if (pngdec->input_state) |
| gst_video_codec_state_unref (pngdec->input_state); |
| pngdec->input_state = gst_video_codec_state_ref (state); |
| |
| /* We'll set format later on */ |
| |
| return TRUE; |
| } |
| |
| static void |
| user_endrow_callback (png_structp png_ptr, png_bytep new_row, |
| png_uint_32 row_num, int pass) |
| { |
| GstPngDec *pngdec = NULL; |
| |
| pngdec = GST_PNGDEC (png_get_io_ptr (png_ptr)); |
| |
| /* If buffer_out doesn't exist, it means buffer_alloc failed, which |
| * will already have set the return code */ |
| if (new_row && GST_IS_BUFFER (pngdec->current_frame->output_buffer)) { |
| GstVideoFrame frame; |
| GstBuffer *buffer = pngdec->current_frame->output_buffer; |
| size_t offset; |
| guint8 *data; |
| |
| if (!gst_video_frame_map (&frame, &pngdec->output_state->info, buffer, |
| GST_MAP_WRITE)) { |
| pngdec->ret = GST_FLOW_ERROR; |
| return; |
| } |
| |
| data = GST_VIDEO_FRAME_COMP_DATA (&frame, 0); |
| offset = row_num * GST_VIDEO_FRAME_COMP_STRIDE (&frame, 0); |
| GST_LOG ("got row %u at pass %d, copying in buffer %p at offset %" |
| G_GSIZE_FORMAT, (guint) row_num, pass, |
| pngdec->current_frame->output_buffer, offset); |
| png_progressive_combine_row (pngdec->png, data + offset, new_row); |
| gst_video_frame_unmap (&frame); |
| pngdec->ret = GST_FLOW_OK; |
| } else |
| pngdec->ret = GST_FLOW_OK; |
| } |
| |
| static void |
| user_end_callback (png_structp png_ptr, png_infop info) |
| { |
| GstPngDec *pngdec = NULL; |
| |
| pngdec = GST_PNGDEC (png_get_io_ptr (png_ptr)); |
| |
| GST_LOG_OBJECT (pngdec, "and we are done reading this image"); |
| |
| if (!pngdec->current_frame->output_buffer) |
| return; |
| |
| gst_buffer_unmap (pngdec->current_frame->input_buffer, |
| &pngdec->current_frame_map); |
| |
| pngdec->ret = |
| gst_video_decoder_finish_frame (GST_VIDEO_DECODER (pngdec), |
| pngdec->current_frame); |
| |
| pngdec->image_ready = TRUE; |
| } |
| |
| |
| static GstFlowReturn |
| gst_pngdec_caps_create_and_set (GstPngDec * pngdec) |
| { |
| GstFlowReturn ret = GST_FLOW_OK; |
| gint bpc = 0, color_type; |
| png_uint_32 width, height; |
| GstVideoFormat format = GST_VIDEO_FORMAT_UNKNOWN; |
| |
| g_return_val_if_fail (GST_IS_PNGDEC (pngdec), GST_FLOW_ERROR); |
| |
| /* Get bits per channel */ |
| bpc = png_get_bit_depth (pngdec->png, pngdec->info); |
| |
| /* Get Color type */ |
| color_type = png_get_color_type (pngdec->png, pngdec->info); |
| |
| /* Add alpha channel if 16-bit depth, but not for GRAY images */ |
| if ((bpc > 8) && (color_type != PNG_COLOR_TYPE_GRAY)) { |
| png_set_add_alpha (pngdec->png, 0xffff, PNG_FILLER_BEFORE); |
| png_set_swap (pngdec->png); |
| } |
| #if 0 |
| /* We used to have this HACK to reverse the outgoing bytes, but the problem |
| * that originally required the hack seems to have been in videoconvert's |
| * RGBA descriptions. It doesn't seem needed now that's fixed, but might |
| * still be needed on big-endian systems, I'm not sure. J.S. 6/7/2007 */ |
| if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
| png_set_bgr (pngdec->png); |
| #endif |
| |
| /* Gray scale with alpha channel converted to RGB */ |
| if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { |
| GST_LOG_OBJECT (pngdec, |
| "converting grayscale png with alpha channel to RGB"); |
| png_set_gray_to_rgb (pngdec->png); |
| } |
| |
| /* Gray scale converted to upscaled to 8 bits */ |
| if ((color_type == PNG_COLOR_TYPE_GRAY_ALPHA) || |
| (color_type == PNG_COLOR_TYPE_GRAY)) { |
| if (bpc < 8) { /* Convert to 8 bits */ |
| GST_LOG_OBJECT (pngdec, "converting grayscale image to 8 bits"); |
| #if PNG_LIBPNG_VER < 10400 |
| png_set_gray_1_2_4_to_8 (pngdec->png); |
| #else |
| png_set_expand_gray_1_2_4_to_8 (pngdec->png); |
| #endif |
| } |
| } |
| |
| /* Palette converted to RGB */ |
| if (color_type == PNG_COLOR_TYPE_PALETTE) { |
| GST_LOG_OBJECT (pngdec, "converting palette png to RGB"); |
| png_set_palette_to_rgb (pngdec->png); |
| } |
| |
| png_set_interlace_handling (pngdec->png); |
| |
| /* Update the info structure */ |
| png_read_update_info (pngdec->png, pngdec->info); |
| |
| /* Get IHDR header again after transformation settings */ |
| png_get_IHDR (pngdec->png, pngdec->info, &width, &height, |
| &bpc, &pngdec->color_type, NULL, NULL, NULL); |
| |
| GST_LOG_OBJECT (pngdec, "this is a %dx%d PNG image", (gint) width, |
| (gint) height); |
| |
| switch (pngdec->color_type) { |
| case PNG_COLOR_TYPE_RGB: |
| GST_LOG_OBJECT (pngdec, "we have no alpha channel, depth is 24 bits"); |
| if (bpc == 8) |
| format = GST_VIDEO_FORMAT_RGB; |
| break; |
| case PNG_COLOR_TYPE_RGB_ALPHA: |
| GST_LOG_OBJECT (pngdec, |
| "we have an alpha channel, depth is 32 or 64 bits"); |
| if (bpc == 8) |
| format = GST_VIDEO_FORMAT_RGBA; |
| else if (bpc == 16) |
| format = GST_VIDEO_FORMAT_ARGB64; |
| break; |
| case PNG_COLOR_TYPE_GRAY: |
| GST_LOG_OBJECT (pngdec, |
| "We have an gray image, depth is 8 or 16 (be) bits"); |
| if (bpc == 8) |
| format = GST_VIDEO_FORMAT_GRAY8; |
| else if (bpc == 16) |
| format = GST_VIDEO_FORMAT_GRAY16_BE; |
| break; |
| default: |
| break; |
| } |
| |
| if (format == GST_VIDEO_FORMAT_UNKNOWN) { |
| GST_ELEMENT_ERROR (pngdec, STREAM, NOT_IMPLEMENTED, (NULL), |
| ("pngdec does not support this color type")); |
| ret = GST_FLOW_NOT_SUPPORTED; |
| goto beach; |
| } |
| |
| /* Check if output state changed */ |
| if (pngdec->output_state) { |
| GstVideoInfo *info = &pngdec->output_state->info; |
| |
| if (width == GST_VIDEO_INFO_WIDTH (info) && |
| height == GST_VIDEO_INFO_HEIGHT (info) && |
| GST_VIDEO_INFO_FORMAT (info) == format) { |
| goto beach; |
| } |
| gst_video_codec_state_unref (pngdec->output_state); |
| } |
| #ifdef HAVE_LIBPNG_1_5 |
| if ((pngdec->color_type & PNG_COLOR_MASK_COLOR) |
| && !(pngdec->color_type & PNG_COLOR_MASK_PALETTE) |
| && png_get_valid (pngdec->png, pngdec->info, PNG_INFO_iCCP)) { |
| png_charp icc_name; |
| png_bytep icc_profile; |
| int icc_compression_type; |
| png_uint_32 icc_proflen = 0; |
| png_uint_32 ret = png_get_iCCP (pngdec->png, pngdec->info, &icc_name, |
| &icc_compression_type, &icc_profile, &icc_proflen); |
| |
| if ((ret & PNG_INFO_iCCP)) { |
| gpointer gst_icc_prof = g_memdup (icc_profile, icc_proflen); |
| GstBuffer *tagbuffer = NULL; |
| GstSample *tagsample = NULL; |
| GstTagList *taglist = NULL; |
| GstStructure *info = NULL; |
| GstCaps *caps; |
| |
| GST_DEBUG_OBJECT (pngdec, "extracted ICC profile '%s' length=%i", |
| icc_name, (guint32) icc_proflen); |
| |
| tagbuffer = gst_buffer_new_wrapped (gst_icc_prof, icc_proflen); |
| |
| caps = gst_caps_new_empty_simple ("application/vnd.iccprofile"); |
| info = gst_structure_new_empty ("application/vnd.iccprofile"); |
| |
| if (icc_name) |
| gst_structure_set (info, "icc-name", G_TYPE_STRING, icc_name, NULL); |
| |
| tagsample = gst_sample_new (tagbuffer, caps, NULL, info); |
| |
| gst_buffer_unref (tagbuffer); |
| gst_caps_unref (caps); |
| |
| taglist = gst_tag_list_new_empty (); |
| gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND, GST_TAG_ATTACHMENT, |
| tagsample, NULL); |
| gst_sample_unref (tagsample); |
| |
| gst_video_decoder_merge_tags (GST_VIDEO_DECODER (pngdec), taglist, |
| GST_TAG_MERGE_APPEND); |
| gst_tag_list_unref (taglist); |
| } |
| } |
| #endif |
| |
| pngdec->output_state = |
| gst_video_decoder_set_output_state (GST_VIDEO_DECODER (pngdec), format, |
| width, height, pngdec->input_state); |
| gst_video_decoder_negotiate (GST_VIDEO_DECODER (pngdec)); |
| GST_DEBUG ("Final %d %d", GST_VIDEO_INFO_WIDTH (&pngdec->output_state->info), |
| GST_VIDEO_INFO_HEIGHT (&pngdec->output_state->info)); |
| |
| beach: |
| return ret; |
| } |
| |
| static GstFlowReturn |
| gst_pngdec_handle_frame (GstVideoDecoder * decoder, GstVideoCodecFrame * frame) |
| { |
| GstPngDec *pngdec = (GstPngDec *) decoder; |
| GstFlowReturn ret = GST_FLOW_OK; |
| |
| GST_LOG_OBJECT (pngdec, "Got buffer, size=%u", |
| (guint) gst_buffer_get_size (frame->input_buffer)); |
| |
| /* Let libpng come back here on error */ |
| if (setjmp (png_jmpbuf (pngdec->png))) { |
| GST_WARNING_OBJECT (pngdec, "error during decoding"); |
| ret = GST_FLOW_ERROR; |
| goto beach; |
| } |
| |
| pngdec->current_frame = frame; |
| |
| /* Progressive loading of the PNG image */ |
| if (!gst_buffer_map (frame->input_buffer, &pngdec->current_frame_map, |
| GST_MAP_READ)) { |
| GST_WARNING_OBJECT (pngdec, "Failed to map input buffer"); |
| ret = GST_FLOW_ERROR; |
| goto beach; |
| } |
| |
| png_process_data (pngdec->png, pngdec->info, |
| pngdec->current_frame_map.data, pngdec->current_frame_map.size); |
| |
| if (pngdec->image_ready) { |
| /* Reset ourselves for the next frame */ |
| gst_pngdec_flush (decoder); |
| GST_LOG_OBJECT (pngdec, "setting up callbacks for next frame"); |
| png_set_progressive_read_fn (pngdec->png, pngdec, |
| user_info_callback, user_endrow_callback, user_end_callback); |
| pngdec->image_ready = FALSE; |
| } else { |
| /* An error happened and we have to unmap */ |
| gst_buffer_unmap (pngdec->current_frame->input_buffer, |
| &pngdec->current_frame_map); |
| } |
| |
| ret = pngdec->ret; |
| beach: |
| |
| return ret; |
| } |
| |
| /* Based on pngparse */ |
| #define PNG_SIGNATURE G_GUINT64_CONSTANT (0x89504E470D0A1A0A) |
| |
| static GstFlowReturn |
| gst_pngdec_parse (GstVideoDecoder * decoder, GstVideoCodecFrame * frame, |
| GstAdapter * adapter, gboolean at_eos) |
| { |
| gsize toadd = 0; |
| GstByteReader reader; |
| gconstpointer data; |
| guint64 signature; |
| gsize size; |
| GstPngDec *pngdec = (GstPngDec *) decoder; |
| |
| GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame); |
| |
| /* FIXME : The overhead of using scan_uint32 is massive */ |
| |
| size = gst_adapter_available (adapter); |
| GST_DEBUG ("Parsing PNG image data (%" G_GSIZE_FORMAT " bytes)", size); |
| |
| if (size < 8) |
| goto need_more_data; |
| |
| data = gst_adapter_map (adapter, size); |
| gst_byte_reader_init (&reader, data, size); |
| |
| if (pngdec->read_data == 0) { |
| if (!gst_byte_reader_peek_uint64_be (&reader, &signature)) |
| goto need_more_data; |
| |
| if (signature != PNG_SIGNATURE) { |
| for (;;) { |
| guint offset; |
| |
| offset = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff, |
| 0x89504E47, 0, gst_byte_reader_get_remaining (&reader)); |
| |
| if (offset == -1) { |
| gst_adapter_flush (adapter, |
| gst_byte_reader_get_remaining (&reader) - 4); |
| goto need_more_data; |
| } |
| |
| if (!gst_byte_reader_skip (&reader, offset)) |
| goto need_more_data; |
| |
| if (!gst_byte_reader_peek_uint64_be (&reader, &signature)) |
| goto need_more_data; |
| |
| if (signature == PNG_SIGNATURE) { |
| /* We're skipping, go out, we'll be back */ |
| gst_adapter_flush (adapter, gst_byte_reader_get_pos (&reader)); |
| goto need_more_data; |
| } |
| if (!gst_byte_reader_skip (&reader, 4)) |
| goto need_more_data; |
| } |
| } |
| pngdec->read_data = 8; |
| } |
| |
| if (!gst_byte_reader_skip (&reader, pngdec->read_data)) |
| goto need_more_data; |
| |
| for (;;) { |
| guint32 length; |
| guint32 code; |
| |
| if (!gst_byte_reader_get_uint32_be (&reader, &length)) |
| goto need_more_data; |
| if (!gst_byte_reader_get_uint32_le (&reader, &code)) |
| goto need_more_data; |
| |
| if (!gst_byte_reader_skip (&reader, length + 4)) |
| goto need_more_data; |
| |
| if (code == GST_MAKE_FOURCC ('I', 'E', 'N', 'D')) { |
| /* Have complete frame */ |
| toadd = gst_byte_reader_get_pos (&reader); |
| GST_DEBUG_OBJECT (decoder, "Have complete frame of size %" G_GSIZE_FORMAT, |
| toadd); |
| pngdec->read_data = 0; |
| goto have_full_frame; |
| } else |
| pngdec->read_data += length + 12; |
| } |
| |
| g_assert_not_reached (); |
| return GST_FLOW_ERROR; |
| |
| need_more_data: |
| return GST_VIDEO_DECODER_FLOW_NEED_DATA; |
| |
| have_full_frame: |
| if (toadd) |
| gst_video_decoder_add_to_frame (decoder, toadd); |
| return gst_video_decoder_have_frame (decoder); |
| } |
| |
| static gboolean |
| gst_pngdec_decide_allocation (GstVideoDecoder * bdec, GstQuery * query) |
| { |
| GstBufferPool *pool = NULL; |
| GstStructure *config; |
| |
| if (!GST_VIDEO_DECODER_CLASS (parent_class)->decide_allocation (bdec, query)) |
| return FALSE; |
| |
| if (gst_query_get_n_allocation_pools (query) > 0) |
| gst_query_parse_nth_allocation_pool (query, 0, &pool, NULL, NULL, NULL); |
| |
| if (pool == NULL) |
| return FALSE; |
| |
| config = gst_buffer_pool_get_config (pool); |
| if (gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL)) { |
| gst_buffer_pool_config_add_option (config, |
| GST_BUFFER_POOL_OPTION_VIDEO_META); |
| } |
| gst_buffer_pool_set_config (pool, config); |
| gst_object_unref (pool); |
| |
| return TRUE; |
| } |
| |
| static gboolean |
| gst_pngdec_sink_event (GstVideoDecoder * bdec, GstEvent * event) |
| { |
| const GstSegment *segment; |
| |
| if (GST_EVENT_TYPE (event) != GST_EVENT_SEGMENT) |
| goto done; |
| |
| gst_event_parse_segment (event, &segment); |
| |
| if (segment->format == GST_FORMAT_TIME) |
| gst_video_decoder_set_packetized (bdec, TRUE); |
| else |
| gst_video_decoder_set_packetized (bdec, FALSE); |
| |
| done: |
| return GST_VIDEO_DECODER_CLASS (parent_class)->sink_event (bdec, event); |
| } |
| |
| static gboolean |
| gst_pngdec_libpng_init (GstPngDec * pngdec) |
| { |
| g_return_val_if_fail (GST_IS_PNGDEC (pngdec), FALSE); |
| |
| GST_LOG ("init libpng structures"); |
| |
| /* initialize png struct stuff */ |
| pngdec->png = png_create_read_struct (PNG_LIBPNG_VER_STRING, |
| (png_voidp) NULL, user_error_fn, user_warning_fn); |
| |
| if (pngdec->png == NULL) |
| goto init_failed; |
| |
| pngdec->info = png_create_info_struct (pngdec->png); |
| if (pngdec->info == NULL) |
| goto info_failed; |
| |
| pngdec->endinfo = png_create_info_struct (pngdec->png); |
| if (pngdec->endinfo == NULL) |
| goto endinfo_failed; |
| |
| png_set_progressive_read_fn (pngdec->png, pngdec, |
| user_info_callback, user_endrow_callback, user_end_callback); |
| |
| return TRUE; |
| |
| /* ERRORS */ |
| init_failed: |
| { |
| GST_ELEMENT_ERROR (pngdec, LIBRARY, INIT, (NULL), |
| ("Failed to initialize png structure")); |
| return FALSE; |
| } |
| info_failed: |
| { |
| GST_ELEMENT_ERROR (pngdec, LIBRARY, INIT, (NULL), |
| ("Failed to initialize info structure")); |
| return FALSE; |
| } |
| endinfo_failed: |
| { |
| GST_ELEMENT_ERROR (pngdec, LIBRARY, INIT, (NULL), |
| ("Failed to initialize endinfo structure")); |
| return FALSE; |
| } |
| } |
| |
| |
| static void |
| gst_pngdec_libpng_clear (GstPngDec * pngdec) |
| { |
| png_infopp info = NULL, endinfo = NULL; |
| |
| GST_LOG ("cleaning up libpng structures"); |
| |
| if (pngdec->info) { |
| info = &pngdec->info; |
| } |
| |
| if (pngdec->endinfo) { |
| endinfo = &pngdec->endinfo; |
| } |
| |
| if (pngdec->png) { |
| png_destroy_read_struct (&(pngdec->png), info, endinfo); |
| pngdec->png = NULL; |
| pngdec->info = NULL; |
| pngdec->endinfo = NULL; |
| } |
| |
| pngdec->color_type = -1; |
| pngdec->read_data = 0; |
| } |
| |
| static gboolean |
| gst_pngdec_start (GstVideoDecoder * decoder) |
| { |
| GstPngDec *pngdec = (GstPngDec *) decoder; |
| |
| gst_video_decoder_set_packetized (GST_VIDEO_DECODER (pngdec), FALSE); |
| gst_pngdec_libpng_init (pngdec); |
| |
| return TRUE; |
| } |
| |
| static gboolean |
| gst_pngdec_stop (GstVideoDecoder * decoder) |
| { |
| GstPngDec *pngdec = (GstPngDec *) decoder; |
| |
| gst_pngdec_libpng_clear (pngdec); |
| |
| if (pngdec->input_state) { |
| gst_video_codec_state_unref (pngdec->input_state); |
| pngdec->input_state = NULL; |
| } |
| if (pngdec->output_state) { |
| gst_video_codec_state_unref (pngdec->output_state); |
| pngdec->output_state = NULL; |
| } |
| |
| return TRUE; |
| } |
| |
| /* Clean up the libpng structures */ |
| static gboolean |
| gst_pngdec_flush (GstVideoDecoder * decoder) |
| { |
| gst_pngdec_libpng_clear ((GstPngDec *) decoder); |
| gst_pngdec_libpng_init ((GstPngDec *) decoder); |
| |
| return TRUE; |
| } |