gstreamer/gst/jpegformat/gstjpegparse.c
Sreerenj Balachandran 9a090538be jpegparse: Fix APP1 marker segment parsing
Reposition the bytereader for proper skipping of
APP1 marker segment if it is not Exif.

https://bugzilla.gnome.org/show_bug.cgi?id=795117
2018-04-16 14:00:39 -08:00

944 lines
27 KiB
C

/* GStreamer
*
* jpegparse: a parser for JPEG streams
*
* Copyright (C) <2009> Arnout Vandecappelle (Essensium/Mind) <arnout@mind.be>
* Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
*
* 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 <config.h>
#endif
#include <string.h>
#include <gst/base/gstbytereader.h>
#include <gst/tag/tag.h>
#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
struct _GstJpegParsePrivate
{
guint last_offset;
guint last_entropy_len;
gboolean last_resync;
/* negotiated state */
gint caps_width, caps_height;
gint caps_framerate_numerator;
gint caps_framerate_denominator;
/* the parsed frame size */
guint16 width, height;
/* format color space */
const gchar *format;
/* TRUE if the src caps sets a specific framerate */
gboolean has_fps;
/* the (expected) timestamp of the next frame */
guint64 next_ts;
/* duration of the current frame */
guint64 duration;
/* video state */
gint framerate_numerator;
gint framerate_denominator;
/* tags */
GstTagList *tags;
};
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;
GObjectClass *gobject_class;
gstbaseparse_class = (GstBaseParseClass *) klass;
gstelement_class = (GstElementClass *) klass;
gobject_class = (GObjectClass *) klass;
g_type_class_add_private (gobject_class, sizeof (GstJpegParsePrivate));
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) <arnout@mind.be>");
GST_DEBUG_CATEGORY_INIT (jpeg_parse_debug, "jpegparse", 0, "JPEG parser");
}
static void
gst_jpeg_parse_init (GstJpegParse * parse)
{
parse->priv = G_TYPE_INSTANCE_GET_PRIVATE (parse, GST_TYPE_JPEG_PARSE,
GstJpegParsePrivate);
parse->priv->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->priv->framerate_numerator =
gst_value_get_fraction_numerator (framerate);
parse->priv->framerate_denominator =
gst_value_get_fraction_denominator (framerate);
parse->priv->has_fps = TRUE;
GST_DEBUG_OBJECT (parse, "got framerate of %d/%d",
parse->priv->framerate_numerator, parse->priv->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->priv->last_offset, parse->priv->last_resync,
parse->priv->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->priv->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->priv->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->priv->last_resync = FALSE;
parse->priv->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->priv->last_resync = FALSE;
parse->priv->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->priv->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->priv->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->priv->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->priv->last_offset = offset;
parse->priv->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->priv->height))
return FALSE;
if (!gst_byte_reader_get_uint16_be (reader, &parse->priv->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->priv->format = "";
} else if (numcomps == 3) {
temp = (blockWidth[0] * blockHeight[0]) / (blockWidth[1] * blockHeight[1]);
if (temp == 4 && blockHeight[0] == 2)
parse->priv->format = "I420";
else if (temp == 4 && blockHeight[0] == 4)
parse->priv->format = "Y41B";
else if (temp == 2)
parse->priv->format = "UYVY";
else if (temp == 1)
parse->priv->format = "YV12";
else
parse->priv->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->priv->tags)
parse->priv->tags = gst_tag_list_new_empty ();
return parse->priv->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->priv->tags;
if (taglist) {
gst_tag_list_insert (taglist, tags, GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (tags);
} else {
parse->priv->tags = tags;
}
GST_DEBUG_OBJECT (parse, "collected tags: %" GST_PTR_FORMAT,
parse->priv->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->priv->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->priv->format,
"width", G_TYPE_INT, parse->priv->width,
"height", G_TYPE_INT, parse->priv->height, NULL);
}
if (parse->priv->has_fps == TRUE) {
/* we have a framerate */
gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION,
parse->priv->framerate_numerator,
parse->priv->framerate_denominator, NULL);
if (!GST_CLOCK_TIME_IS_VALID (parse->priv->duration)
&& parse->priv->framerate_numerator != 0) {
parse->priv->duration = gst_util_uint64_scale_int (GST_SECOND,
parse->priv->framerate_denominator, parse->priv->framerate_numerator);
}
} else {
/* unknown duration */
parse->priv->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;
GST_BUFFER_TIMESTAMP (outbuf) = parse->priv->next_ts;
if (parse->priv->has_fps && GST_CLOCK_TIME_IS_VALID (parse->priv->next_ts)
&& GST_CLOCK_TIME_IS_VALID (parse->priv->duration)) {
parse->priv->next_ts += parse->priv->duration;
} else {
parse->priv->duration = GST_CLOCK_TIME_NONE;
parse->priv->next_ts = GST_CLOCK_TIME_NONE;
}
GST_BUFFER_DURATION (outbuf) = parse->priv->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->priv->next_ts)))
parse->priv->next_ts = timestamp;
if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (duration)))
parse->priv->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->priv->last_offset = 0;
parse->priv->last_entropy_len = 0;
header_ok = gst_jpeg_parse_read_header (parse, &mapinfo, len);
gst_buffer_unmap (frame->buffer, &mapinfo);
if (parse->priv->width != parse->priv->caps_width
|| parse->priv->height != parse->priv->caps_height
|| parse->priv->framerate_numerator !=
parse->priv->caps_framerate_numerator
|| parse->priv->framerate_denominator !=
parse->priv->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->priv->tags) {
GST_DEBUG_OBJECT (parse, "Pushing tags: %" GST_PTR_FORMAT,
parse->priv->tags);
gst_pad_push_event (GST_BASE_PARSE_SRC_PAD (parse),
gst_event_new_tag (parse->priv->tags));
parse->priv->tags = NULL;
}
parse->priv->caps_width = parse->priv->width;
parse->priv->caps_height = parse->priv->height;
parse->priv->caps_framerate_numerator = parse->priv->framerate_numerator;
parse->priv->caps_framerate_denominator =
parse->priv->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->priv->next_ts = GST_CLOCK_TIME_NONE;
parse->priv->duration = GST_CLOCK_TIME_NONE;
parse->priv->last_offset = 0;
parse->priv->last_entropy_len = 0;
parse->priv->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->priv->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->priv->has_fps = FALSE;
parse->priv->width = parse->priv->height = 0;
parse->priv->framerate_numerator = 0;
parse->priv->framerate_denominator = 1;
parse->priv->caps_framerate_numerator =
parse->priv->caps_framerate_denominator = 0;
parse->priv->caps_width = parse->priv->caps_height = -1;
parse->priv->next_ts = GST_CLOCK_TIME_NONE;
parse->priv->duration = GST_CLOCK_TIME_NONE;
parse->priv->last_offset = 0;
parse->priv->last_entropy_len = 0;
parse->priv->last_resync = FALSE;
parse->priv->tags = NULL;
return TRUE;
}
static gboolean
gst_jpeg_parse_stop (GstBaseParse * bparse)
{
GstJpegParse *parse;
parse = GST_JPEG_PARSE_CAST (bparse);
if (parse->priv->tags) {
gst_tag_list_unref (parse->priv->tags);
parse->priv->tags = NULL;
}
return TRUE;
}