/* GStreamer * * jpegparse: a parser for JPEG streams * * Copyright (C) <2009> Arnout Vandecappelle (Essensium/Mind) * Víctor Manuel Jáquez Leal * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser 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-jpegparse * @title: jpegparse * @short_description: JPEG parser * * Parses a JPEG stream into JPEG images. It looks for EOI boundaries to * split a continuous stream into single-frame buffers. Also reads the * image header searching for image properties such as width and height * among others. Jpegparse can also extract metadata (e.g. xmp). * * ## Example launch line * |[ * gst-launch-1.0 -v souphttpsrc location=... ! jpegparse ! matroskamux ! filesink location=... * ]| * The above pipeline fetches a motion JPEG stream from an IP camera over * HTTP and stores it in a matroska file. * */ /* FIXME: output plain JFIF APP marker only. This provides best code reuse. * JPEG decoders would not need to handle this part anymore. Also when remuxing * (... ! jpegparse ! ... ! jifmux ! ...) metadata consolidation would be * easier. */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include "gstjpegparse.h" static GstStaticPadTemplate gst_jpeg_parse_src_pad_template = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("image/jpeg, " "format = (string) { I420, Y41B, UYVY, YV12 }, " "width = (int) [ 0, MAX ]," "height = (int) [ 0, MAX ], " "framerate = (fraction) [ 0/1, MAX ], " "parsed = (boolean) true") ); static GstStaticPadTemplate gst_jpeg_parse_sink_pad_template = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("image/jpeg") ); GST_DEBUG_CATEGORY_STATIC (jpeg_parse_debug); #define GST_CAT_DEFAULT jpeg_parse_debug static GstFlowReturn gst_jpeg_parse_handle_frame (GstBaseParse * bparse, GstBaseParseFrame * frame, gint * skipsize); static gboolean gst_jpeg_parse_set_sink_caps (GstBaseParse * parse, GstCaps * caps); static gboolean gst_jpeg_parse_sink_event (GstBaseParse * parse, GstEvent * event); static gboolean gst_jpeg_parse_start (GstBaseParse * parse); static gboolean gst_jpeg_parse_stop (GstBaseParse * parse); static GstFlowReturn gst_jpeg_parse_pre_push_frame (GstBaseParse * bparse, GstBaseParseFrame * frame); #define gst_jpeg_parse_parent_class parent_class G_DEFINE_TYPE (GstJpegParse, gst_jpeg_parse, GST_TYPE_BASE_PARSE); static void gst_jpeg_parse_class_init (GstJpegParseClass * klass) { GstBaseParseClass *gstbaseparse_class; GstElementClass *gstelement_class; gstbaseparse_class = (GstBaseParseClass *) klass; gstelement_class = (GstElementClass *) klass; gstbaseparse_class->start = gst_jpeg_parse_start; gstbaseparse_class->stop = gst_jpeg_parse_stop; gstbaseparse_class->set_sink_caps = gst_jpeg_parse_set_sink_caps; gstbaseparse_class->sink_event = gst_jpeg_parse_sink_event; gstbaseparse_class->handle_frame = gst_jpeg_parse_handle_frame; gstbaseparse_class->pre_push_frame = gst_jpeg_parse_pre_push_frame; gst_element_class_add_static_pad_template (gstelement_class, &gst_jpeg_parse_src_pad_template); gst_element_class_add_static_pad_template (gstelement_class, &gst_jpeg_parse_sink_pad_template); gst_element_class_set_static_metadata (gstelement_class, "JPEG stream parser", "Video/Parser", "Parse JPEG images into single-frame buffers", "Arnout Vandecappelle (Essensium/Mind) "); GST_DEBUG_CATEGORY_INIT (jpeg_parse_debug, "jpegparse", 0, "JPEG parser"); } static void gst_jpeg_parse_init (GstJpegParse * parse) { parse->next_ts = GST_CLOCK_TIME_NONE; } static gboolean gst_jpeg_parse_set_sink_caps (GstBaseParse * bparse, GstCaps * caps) { GstJpegParse *parse = GST_JPEG_PARSE_CAST (bparse); GstStructure *s = gst_caps_get_structure (caps, 0); const GValue *framerate; if ((framerate = gst_structure_get_value (s, "framerate")) != NULL) { if (GST_VALUE_HOLDS_FRACTION (framerate)) { parse->framerate_numerator = gst_value_get_fraction_numerator (framerate); parse->framerate_denominator = gst_value_get_fraction_denominator (framerate); parse->has_fps = TRUE; GST_DEBUG_OBJECT (parse, "got framerate of %d/%d", parse->framerate_numerator, parse->framerate_denominator); } } return TRUE; } /* * gst_jpeg_parse_skip_to_jpeg_header: * @parse: the parser * * Flush everything until the next JPEG header. The header is considered * to be the a start marker SOI (0xff 0xd8) followed by any other marker * (0xff ...). * * Returns: TRUE if the header was found, FALSE if more data is needed. */ static gboolean gst_jpeg_parse_skip_to_jpeg_header (GstJpegParse * parse, GstMapInfo * mapinfo, gint * skipsize) { gboolean ret = TRUE; GstByteReader reader; if (mapinfo->size < 4) return FALSE; gst_byte_reader_init (&reader, mapinfo->data, mapinfo->size); *skipsize = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffff00, 0xffd8ff00, 0, mapinfo->size); if (*skipsize == -1) { *skipsize = mapinfo->size - 3; /* Last 3 bytes + 1 more may match header. */ ret = FALSE; } return ret; } static inline gboolean gst_jpeg_parse_parse_tag_has_entropy_segment (guint8 tag) { if (tag == SOS || (tag >= RST0 && tag <= RST7)) return TRUE; return FALSE; } /* returns image length in bytes if parsed successfully, * otherwise 0 if more data needed, * if < 0 the absolute value needs to be flushed */ static gint gst_jpeg_parse_get_image_length (GstJpegParse * parse, GstMapInfo * mapinfo) { guint size; gboolean resync; gint offset, noffset; GstByteReader reader; size = mapinfo->size; gst_byte_reader_init (&reader, mapinfo->data, mapinfo->size); /* TODO could be removed as previous functions already guarantee this to be * true */ /* we expect at least 4 bytes, first of which start marker */ if (gst_byte_reader_masked_scan_uint32 (&reader, 0xffff0000, 0xffd80000, 0, 4)) return 0; GST_DEBUG ("Parsing jpeg image data (%u bytes)", size); GST_DEBUG ("Parse state: offset=%d, resync=%d, entropy len=%d", parse->last_offset, parse->last_resync, parse->last_entropy_len); /* offset is 2 less than actual offset; * - adapter needs at least 4 bytes for scanning, * - start and end marker ensure at least that much */ /* resume from state offset */ offset = parse->last_offset; while (1) { guint frame_len; guint32 value; noffset = gst_byte_reader_masked_scan_uint32_peek (&reader, 0x0000ff00, 0x0000ff00, offset, size - offset, &value); /* lost sync if 0xff marker not where expected */ if ((resync = (noffset != offset))) { GST_DEBUG ("Lost sync at 0x%08x, resyncing", offset + 2); } /* may have marker, but could have been resyncng */ resync = resync || parse->last_resync; /* Skip over extra 0xff */ while ((noffset >= 0) && ((value & 0xff) == 0xff)) { noffset++; noffset = gst_byte_reader_masked_scan_uint32_peek (&reader, 0x0000ff00, 0x0000ff00, noffset, size - noffset, &value); } /* enough bytes left for marker? (we need 0xNN after the 0xff) */ if (noffset < 0) { GST_DEBUG ("at end of input and no EOI marker found, need more data"); goto need_more_data; } /* now lock on the marker we found */ offset = noffset; value = value & 0xff; if (value == 0xd9) { GST_DEBUG ("0x%08x: EOI marker", offset + 2); /* clear parse state */ parse->last_resync = FALSE; parse->last_offset = 0; return (offset + 4); } else if (value == 0xd8) { /* Skip this frame if we found another SOI marker */ GST_DEBUG ("0x%08x: SOI marker before EOI, skipping", offset + 2); /* clear parse state */ parse->last_resync = FALSE; parse->last_offset = 0; return -(offset + 2); } if (value >= 0xd0 && value <= 0xd7) frame_len = 0; else { /* peek tag and subsequent length */ if (offset + 2 + 4 > size) goto need_more_data; else gst_byte_reader_masked_scan_uint32_peek (&reader, 0x0, 0x0, offset + 2, 4, &frame_len); frame_len = frame_len & 0xffff; } GST_DEBUG ("0x%08x: tag %02x, frame_len=%u", offset + 2, value, frame_len); /* the frame length includes the 2 bytes for the length; here we want at * least 2 more bytes at the end for an end marker */ if (offset + 2 + 2 + frame_len + 2 > size) { goto need_more_data; } if (gst_jpeg_parse_parse_tag_has_entropy_segment (value)) { guint eseglen = parse->last_entropy_len; GST_DEBUG ("0x%08x: finding entropy segment length", offset + 2); noffset = offset + 2 + frame_len + eseglen; while (1) { noffset = gst_byte_reader_masked_scan_uint32_peek (&reader, 0x0000ff00, 0x0000ff00, noffset, size - noffset, &value); if (noffset < 0) { /* need more data */ parse->last_entropy_len = size - offset - 4 - frame_len - 2; goto need_more_data; } if ((value & 0xff) != 0x00) { eseglen = noffset - offset - frame_len - 2; break; } noffset++; } parse->last_entropy_len = 0; frame_len += eseglen; GST_DEBUG ("entropy segment length=%u => frame_len=%u", eseglen, frame_len); } if (resync) { /* check if we will still be in sync if we interpret * this as a sync point and skip this frame */ noffset = offset + frame_len + 2; noffset = gst_byte_reader_masked_scan_uint32 (&reader, 0x0000ff00, 0x0000ff00, noffset, 4); if (noffset < 0) { /* ignore and continue resyncing until we hit the end * of our data or find a sync point that looks okay */ offset++; continue; } GST_DEBUG ("found sync at 0x%x", offset + 2); } offset += frame_len + 2; } /* EXITS */ need_more_data: { parse->last_offset = offset; parse->last_resync = resync; return 0; } } static inline gboolean gst_jpeg_parse_sof (GstJpegParse * parse, GstByteReader * reader) { guint8 numcomps = 0; /* Number of components in image (1 for gray, 3 for YUV, etc.) */ guint8 precision; /* precision (in bits) for the samples */ guint8 compId[3] G_GNUC_UNUSED; /* unique value identifying each component */ guint8 qtId[3] G_GNUC_UNUSED; /* quantization table ID to use for this comp */ guint8 blockWidth[3]; /* Array[numComponents] giving the number of blocks (horiz) in this component */ guint8 blockHeight[3]; /* Same for the vertical part of this component */ guint8 i, value = 0; gint temp; /* flush length field */ if (!gst_byte_reader_skip (reader, 2)) return FALSE; /* Get sample precision */ if (!gst_byte_reader_get_uint8 (reader, &precision)) return FALSE; /* Get w and h */ if (!gst_byte_reader_get_uint16_be (reader, &parse->height)) return FALSE; if (!gst_byte_reader_get_uint16_be (reader, &parse->width)) return FALSE; /* Get number of components */ if (!gst_byte_reader_get_uint8 (reader, &numcomps)) return FALSE; if (numcomps > 3) /* FIXME */ return FALSE; /* Get decimation and quantization table id for each component */ for (i = 0; i < numcomps; i++) { /* Get component ID number */ if (!gst_byte_reader_get_uint8 (reader, &value)) return FALSE; compId[i] = value; /* Get decimation */ if (!gst_byte_reader_get_uint8 (reader, &value)) return FALSE; blockWidth[i] = (value & 0xf0) >> 4; blockHeight[i] = (value & 0x0f); /* Get quantization table id */ if (!gst_byte_reader_get_uint8 (reader, &value)) return FALSE; qtId[i] = value; } if (numcomps == 1) { /* gray image - no format */ parse->format = ""; } else if (numcomps == 3) { temp = (blockWidth[0] * blockHeight[0]) / (blockWidth[1] * blockHeight[1]); if (temp == 4 && blockHeight[0] == 2) parse->format = "I420"; else if (temp == 4 && blockHeight[0] == 4) parse->format = "Y41B"; else if (temp == 2) parse->format = "UYVY"; else if (temp == 1) parse->format = "YV12"; else parse->format = ""; } else { return FALSE; } GST_DEBUG_OBJECT (parse, "Header parsed"); return TRUE; } static inline gboolean gst_jpeg_parse_skip_marker (GstJpegParse * parse, GstByteReader * reader, guint8 marker) { guint16 size = 0; if (!gst_byte_reader_get_uint16_be (reader, &size)) return FALSE; #ifndef GST_DISABLE_GST_DEBUG /* We'd pry the id of the skipped application segment */ if (marker >= APP0 && marker <= APP15) { const gchar *id_str = NULL; if (gst_byte_reader_peek_string_utf8 (reader, &id_str)) { GST_DEBUG_OBJECT (parse, "unhandled marker %x: '%s' skiping %u bytes", marker, id_str ? id_str : "(NULL)", size); } else { GST_DEBUG_OBJECT (parse, "unhandled marker %x skiping %u bytes", marker, size); } } #else GST_DEBUG_OBJECT (parse, "unhandled marker %x skiping %u bytes", marker, size); #endif // GST_DISABLE_GST_DEBUG if (!gst_byte_reader_skip (reader, size - 2)) return FALSE; return TRUE; } static inline GstTagList * get_tag_list (GstJpegParse * parse) { if (!parse->tags) parse->tags = gst_tag_list_new_empty (); return parse->tags; } static inline void extract_and_queue_tags (GstJpegParse * parse, guint size, guint8 * data, GstTagList * (*tag_func) (GstBuffer * buff)) { GstTagList *tags; GstBuffer *buf; buf = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY, data, size, 0, size, NULL, NULL); tags = tag_func (buf); gst_buffer_unref (buf); if (tags) { GstTagList *taglist = parse->tags; if (taglist) { gst_tag_list_insert (taglist, tags, GST_TAG_MERGE_REPLACE); gst_tag_list_unref (tags); } else { parse->tags = tags; } GST_DEBUG_OBJECT (parse, "collected tags: %" GST_PTR_FORMAT, parse->tags); } } static inline gboolean gst_jpeg_parse_app1 (GstJpegParse * parse, GstByteReader * reader) { guint16 size = 0; const gchar *id_str; const guint8 *data = NULL; if (!gst_byte_reader_get_uint16_be (reader, &size)) return FALSE; size -= 2; /* 2 bytes for the mark */ if (!gst_byte_reader_peek_string_utf8 (reader, &id_str)) return FALSE; if (!strncmp (id_str, "Exif", 4)) { /* skip id + NUL + padding */ if (!gst_byte_reader_skip (reader, 6)) return FALSE; size -= 6; /* handle exif metadata */ if (!gst_byte_reader_get_data (reader, size, &data)) return FALSE; extract_and_queue_tags (parse, size, (guint8 *) data, gst_tag_list_from_exif_buffer_with_tiff_header); GST_LOG_OBJECT (parse, "parsed marker %x: '%s' %u bytes", APP1, id_str, size); } else if (!strncmp (id_str, "http://ns.adobe.com/xap/1.0/", 28)) { /* skip the id + NUL */ if (!gst_byte_reader_skip (reader, 29)) return FALSE; size -= 29; /* handle xmp metadata */ if (!gst_byte_reader_get_data (reader, size, &data)) return FALSE; extract_and_queue_tags (parse, size, (guint8 *) data, gst_tag_list_from_xmp_buffer); GST_LOG_OBJECT (parse, "parsed marker %x: '%s' %u bytes", APP1, id_str, size); } else { /* restore the byte position and size */ reader->size += 2; reader->byte -= 2; if (!gst_jpeg_parse_skip_marker (parse, reader, APP1)) return FALSE; } return TRUE; } static inline gchar * get_utf8_from_data (const guint8 * data, guint16 size) { const gchar *env_vars[] = { "GST_JPEG_TAG_ENCODING", "GST_TAG_ENCODING", NULL }; const char *str = (gchar *) data; return gst_tag_freeform_string_to_utf8 (str, size, env_vars); } /* read comment and post as tag */ static inline gboolean gst_jpeg_parse_com (GstJpegParse * parse, GstByteReader * reader) { const guint8 *data = NULL; guint16 size = 0; gchar *comment; if (!gst_byte_reader_get_uint16_be (reader, &size)) return FALSE; size -= 2; if (!gst_byte_reader_get_data (reader, size, &data)) return FALSE; comment = get_utf8_from_data (data, size); if (comment) { GstTagList *taglist = get_tag_list (parse); gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_COMMENT, comment, NULL); GST_DEBUG_OBJECT (parse, "collected tags: %" GST_PTR_FORMAT, taglist); g_free (comment); } return TRUE; } static gboolean gst_jpeg_parse_read_header (GstJpegParse * parse, GstMapInfo * map, gint len) { GstByteReader reader; guint8 marker = 0; gboolean foundSOF = FALSE; gst_byte_reader_init (&reader, map->data, len); if (!gst_byte_reader_peek_uint8 (&reader, &marker)) goto error; while (marker == 0xff) { if (!gst_byte_reader_skip (&reader, 1)) goto error; if (!gst_byte_reader_get_uint8 (&reader, &marker)) goto error; GST_DEBUG_OBJECT (parse, "marker = %x", marker); switch (marker) { case SOS: /* start of scan (begins compressed data) */ goto done; case SOI: break; case DRI: if (!gst_byte_reader_skip (&reader, 4)) /* fixed size */ goto error; break; case COM: if (!gst_jpeg_parse_com (parse, &reader)) goto error; break; case APP1: if (!gst_jpeg_parse_app1 (parse, &reader)) goto error; break; case DHT: case DQT: /* Ignore these codes */ if (!gst_jpeg_parse_skip_marker (parse, &reader, marker)) goto error; break; case SOF0: /* parse Start Of Frame */ if (!gst_jpeg_parse_sof (parse, &reader)) goto error; foundSOF = TRUE; goto done; default: if (marker == JPG || (marker >= JPG0 && marker <= JPG13) || (marker >= APP0 && marker <= APP15)) { if (!gst_jpeg_parse_skip_marker (parse, &reader, marker)) goto error; } else goto unhandled; } if (!gst_byte_reader_peek_uint8 (&reader, &marker)) goto error; } done: return foundSOF; /* ERRORS */ error: { GST_WARNING_OBJECT (parse, "Error parsing image header (need more than %u bytes available)", gst_byte_reader_get_remaining (&reader)); return FALSE; } unhandled: { GST_WARNING_OBJECT (parse, "unhandled marker %x, leaving", marker); /* Not SOF or SOI. Must not be a JPEG file (or file pointer * is placed wrong). In either case, it's an error. */ return FALSE; } } static gboolean gst_jpeg_parse_set_new_caps (GstJpegParse * parse, gboolean header_ok) { GstCaps *caps; gboolean res; GST_DEBUG_OBJECT (parse, "setting caps on srcpad (hdr_ok=%d, have_fps=%d)", header_ok, parse->has_fps); caps = gst_caps_new_simple ("image/jpeg", "parsed", G_TYPE_BOOLEAN, TRUE, NULL); if (header_ok == TRUE) { gst_caps_set_simple (caps, "format", G_TYPE_STRING, parse->format, "width", G_TYPE_INT, parse->width, "height", G_TYPE_INT, parse->height, NULL); } if (parse->has_fps == TRUE) { /* we have a framerate */ gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION, parse->framerate_numerator, parse->framerate_denominator, NULL); if (!GST_CLOCK_TIME_IS_VALID (parse->duration) && parse->framerate_numerator != 0) { parse->duration = gst_util_uint64_scale_int (GST_SECOND, parse->framerate_denominator, parse->framerate_numerator); } } else { /* unknown duration */ parse->duration = GST_CLOCK_TIME_NONE; gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION, 1, 1, NULL); } GST_DEBUG_OBJECT (parse, "setting downstream caps on %s:%s to %" GST_PTR_FORMAT, GST_DEBUG_PAD_NAME (GST_BASE_PARSE_SRC_PAD (parse)), caps); res = gst_pad_set_caps (GST_BASE_PARSE_SRC_PAD (parse), caps); gst_caps_unref (caps); return res; } static GstFlowReturn gst_jpeg_parse_pre_push_frame (GstBaseParse * bparse, GstBaseParseFrame * frame) { GstJpegParse *parse = GST_JPEG_PARSE_CAST (bparse); GstBuffer *outbuf = frame->buffer; if (parse->has_fps && !GST_CLOCK_TIME_IS_VALID (parse->next_ts)) parse->next_ts = bparse->segment.start; GST_BUFFER_TIMESTAMP (outbuf) = parse->next_ts; if (parse->has_fps && GST_CLOCK_TIME_IS_VALID (parse->next_ts) && GST_CLOCK_TIME_IS_VALID (parse->duration)) { parse->next_ts += parse->duration; } else { parse->duration = GST_CLOCK_TIME_NONE; parse->next_ts = GST_CLOCK_TIME_NONE; } GST_BUFFER_DURATION (outbuf) = parse->duration; return GST_FLOW_OK; } static GstFlowReturn gst_jpeg_parse_handle_frame (GstBaseParse * bparse, GstBaseParseFrame * frame, gint * skipsize) { GstJpegParse *parse = GST_JPEG_PARSE_CAST (bparse); gint len; GstClockTime timestamp, duration; GstMapInfo mapinfo; gboolean header_ok; timestamp = GST_BUFFER_PTS (frame->buffer); duration = GST_BUFFER_DURATION (frame->buffer); if (!gst_buffer_map (frame->buffer, &mapinfo, GST_MAP_READ)) { return GST_FLOW_ERROR; } if (!gst_jpeg_parse_skip_to_jpeg_header (parse, &mapinfo, skipsize)) { gst_buffer_unmap (frame->buffer, &mapinfo); return GST_FLOW_OK; } if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (parse->next_ts))) parse->next_ts = timestamp; if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (duration))) parse->duration = duration; len = gst_jpeg_parse_get_image_length (parse, &mapinfo); if (len == 0) { gst_buffer_unmap (frame->buffer, &mapinfo); return GST_FLOW_OK; } else if (len < 0) { *skipsize = -len; gst_buffer_unmap (frame->buffer, &mapinfo); return GST_FLOW_OK; } /* check if we already have a EOI */ GST_LOG_OBJECT (parse, "parsed image of size %d", len); /* reset the offset (only when we flushed) */ parse->last_offset = 0; parse->last_entropy_len = 0; header_ok = gst_jpeg_parse_read_header (parse, &mapinfo, len); gst_buffer_unmap (frame->buffer, &mapinfo); if (parse->width != parse->caps_width || parse->height != parse->caps_height || parse->framerate_numerator != parse->caps_framerate_numerator || parse->framerate_denominator != parse->caps_framerate_denominator) { if (!gst_jpeg_parse_set_new_caps (parse, header_ok)) { GST_ELEMENT_ERROR (parse, CORE, NEGOTIATION, ("Can't set caps to the src pad"), ("Can't set caps to the src pad")); return GST_FLOW_ERROR; } if (parse->tags) { GST_DEBUG_OBJECT (parse, "Pushing tags: %" GST_PTR_FORMAT, parse->tags); gst_pad_push_event (GST_BASE_PARSE_SRC_PAD (parse), gst_event_new_tag (parse->tags)); parse->tags = NULL; } parse->caps_width = parse->width; parse->caps_height = parse->height; parse->caps_framerate_numerator = parse->framerate_numerator; parse->caps_framerate_denominator = parse->framerate_denominator; } return gst_base_parse_finish_frame (bparse, frame, len); } static gboolean gst_jpeg_parse_sink_event (GstBaseParse * bparse, GstEvent * event) { GstJpegParse *parse = GST_JPEG_PARSE_CAST (bparse); gboolean res = TRUE; GST_DEBUG_OBJECT (parse, "event : %s", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: parse->next_ts = GST_CLOCK_TIME_NONE; parse->duration = GST_CLOCK_TIME_NONE; parse->last_offset = 0; parse->last_entropy_len = 0; parse->last_resync = FALSE; res = GST_BASE_PARSE_CLASS (parent_class)->sink_event (bparse, event); break; case GST_EVENT_TAG:{ if (gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (parse))) res = GST_BASE_PARSE_CLASS (parent_class)->sink_event (bparse, event); else { GstTagList *taglist = NULL; gst_event_parse_tag (event, &taglist); /* Hold on to the tags till the srcpad caps are definitely set */ gst_tag_list_insert (get_tag_list (parse), taglist, GST_TAG_MERGE_REPLACE); GST_DEBUG ("collected tags: %" GST_PTR_FORMAT, parse->tags); gst_event_unref (event); } break; } default: res = GST_BASE_PARSE_CLASS (parent_class)->sink_event (bparse, event); break; } return res; } static gboolean gst_jpeg_parse_start (GstBaseParse * bparse) { GstJpegParse *parse; parse = GST_JPEG_PARSE_CAST (bparse); parse->has_fps = FALSE; parse->width = parse->height = 0; parse->framerate_numerator = 0; parse->framerate_denominator = 1; parse->caps_framerate_numerator = parse->caps_framerate_denominator = 0; parse->caps_width = parse->caps_height = -1; parse->next_ts = GST_CLOCK_TIME_NONE; parse->duration = GST_CLOCK_TIME_NONE; parse->last_offset = 0; parse->last_entropy_len = 0; parse->last_resync = FALSE; parse->tags = NULL; return TRUE; } static gboolean gst_jpeg_parse_stop (GstBaseParse * bparse) { GstJpegParse *parse; parse = GST_JPEG_PARSE_CAST (bparse); if (parse->tags) { gst_tag_list_unref (parse->tags); parse->tags = NULL; } return TRUE; }