mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-20 00:31:13 +00:00
Port jpegdec to 0.9; handles 'progressive loading' now, ie. input does no longer need to be one single buffer.
Original commit message from CVS: * configure.ac: * ext/Makefile.am: * ext/jpeg/Makefile.am: * ext/jpeg/gstjpeg.c: (plugin_init): * ext/jpeg/gstjpegdec.c: (gst_jpeg_dec_get_type), (gst_jpeg_dec_finalize), (gst_jpeg_dec_base_init), (gst_jpeg_dec_class_init), (gst_jpeg_dec_fill_input_buffer), (gst_jpeg_dec_init_source), (gst_jpeg_dec_skip_input_data), (gst_jpeg_dec_resync_to_restart), (gst_jpeg_dec_term_source), (gst_jpeg_dec_my_output_message), (gst_jpeg_dec_my_emit_message), (gst_jpeg_dec_my_error_exit), (gst_jpeg_dec_init), (is_jpeg_start_marker), (is_jpeg_end_marker), (gst_jpeg_dec_find_jpeg_header), (gst_jpeg_dec_ensure_header), (gst_jpeg_dec_have_end_marker), (gst_jpeg_dec_parse_tag_has_entropy_segment), (gst_jpeg_dec_parse_image_data), (gst_jpeg_dec_chain), (gst_jpeg_dec_change_state): * ext/jpeg/gstjpegdec.h: Port jpegdec to 0.9; handles 'progressive loading' now, ie. input does no longer need to be one single buffer.
This commit is contained in:
Tim-Philipp Müller
parent
284327da55
commit
7cc1cf7dbb
8 changed files with 643 additions and 238 deletions
23
ChangeLog
23
ChangeLog
|
|
@ -1,3 +1,26 @@
|
|||
2005-08-08 Tim-Philipp Müller <tim at centricular dot net>
|
||||
|
||||
* configure.ac:
|
||||
* ext/Makefile.am:
|
||||
* ext/jpeg/Makefile.am:
|
||||
* ext/jpeg/gstjpeg.c: (plugin_init):
|
||||
* ext/jpeg/gstjpegdec.c: (gst_jpeg_dec_get_type),
|
||||
(gst_jpeg_dec_finalize), (gst_jpeg_dec_base_init),
|
||||
(gst_jpeg_dec_class_init), (gst_jpeg_dec_fill_input_buffer),
|
||||
(gst_jpeg_dec_init_source), (gst_jpeg_dec_skip_input_data),
|
||||
(gst_jpeg_dec_resync_to_restart), (gst_jpeg_dec_term_source),
|
||||
(gst_jpeg_dec_my_output_message), (gst_jpeg_dec_my_emit_message),
|
||||
(gst_jpeg_dec_my_error_exit), (gst_jpeg_dec_init),
|
||||
(is_jpeg_start_marker), (is_jpeg_end_marker),
|
||||
(gst_jpeg_dec_find_jpeg_header), (gst_jpeg_dec_ensure_header),
|
||||
(gst_jpeg_dec_have_end_marker),
|
||||
(gst_jpeg_dec_parse_tag_has_entropy_segment),
|
||||
(gst_jpeg_dec_parse_image_data), (gst_jpeg_dec_chain),
|
||||
(gst_jpeg_dec_change_state):
|
||||
* ext/jpeg/gstjpegdec.h:
|
||||
Port jpegdec to 0.9; handles 'progressive loading' now, ie. input does
|
||||
no longer need to be one single buffer.
|
||||
|
||||
2005-08-04 Andy Wingo <wingo@pobox.com>
|
||||
|
||||
* sys/oss/gstossaudio.c (plugin_init): Second-class citizen.
|
||||
|
|
|
|||
2
common
2
common
|
|
@ -1 +1 @@
|
|||
Subproject commit 694de4dbf4827f372321f0634643a254d7edd986
|
||||
Subproject commit 856fbbfa88621ab67df141ead8d4d3df32c5c176
|
||||
22
configure.ac
22
configure.ac
|
|
@ -447,6 +447,27 @@ GST_CHECK_FEATURE(SIDPLAY, [sidplay plug-in], sidplay, [
|
|||
GST_PATH_SIDPLAY()
|
||||
])
|
||||
|
||||
dnl *** jpeg ***
|
||||
dnl FIXME: we could use header checks here as well IMO
|
||||
translit(dnm, m, l) AM_CONDITIONAL(USE_JPEG, true)
|
||||
GST_CHECK_FEATURE(JPEG, [jpeg], jpegenc jpegdec, [
|
||||
AC_ARG_WITH(jpeg-mmx,
|
||||
[ --with-jpeg-mmx, path to MMX'ified JPEG library])
|
||||
OLD_LIBS="$LIBS"
|
||||
if test x$with_jpeg_mmx != x; then
|
||||
LIBS="$LIBS -L$with_jpeg_mmx"
|
||||
fi
|
||||
AC_CHECK_LIB(jpeg-mmx, jpeg_set_defaults, HAVE_JPEG="yes", HAVE_JPEG="no")
|
||||
JPEG_LIBS="$LIBS -ljpeg-mmx"
|
||||
LIBS="$OLD_LIBS"
|
||||
if test x$HAVE_JPEG != xyes; then
|
||||
AC_CHECK_LIB(jpeg, jpeg_set_defaults, HAVE_JPEG="yes", HAVE_JPEG="no")
|
||||
JPEG_LIBS="-ljpeg"
|
||||
fi
|
||||
AC_SUBST(JPEG_LIBS)
|
||||
])
|
||||
|
||||
|
||||
dnl *** mad ***
|
||||
dnl FIXME: we could use header checks here as well IMO
|
||||
translit(dnm, m, l) AM_CONDITIONAL(USE_MAD, true)
|
||||
|
|
@ -596,6 +617,7 @@ gst/silence/Makefile
|
|||
gst/udp/Makefile
|
||||
gst/videobox/Makefile
|
||||
gst/videofilter/Makefile
|
||||
ext/jpeg/Makefile
|
||||
gst/wavparse/Makefile
|
||||
gst-libs/Makefile
|
||||
gst-libs/gst/Makefile
|
||||
|
|
|
|||
|
|
@ -160,11 +160,11 @@ HERMES_DIR=
|
|||
JACK_DIR=
|
||||
# endif
|
||||
|
||||
# if USE_JPEG
|
||||
# JPEG_DIR=jpeg
|
||||
# else
|
||||
if USE_JPEG
|
||||
JPEG_DIR=jpeg
|
||||
else
|
||||
JPEG_DIR=
|
||||
# endif
|
||||
endif
|
||||
|
||||
# if USE_LADSPA
|
||||
# LADSPA_DIR=ladspa
|
||||
|
|
|
|||
|
|
@ -2,8 +2,14 @@
|
|||
plugin_LTLIBRARIES = libgstjpeg.la
|
||||
|
||||
libgstjpeg_la_SOURCES = \
|
||||
gstjpeg.c gstjpegdec.c gstjpegenc.c \
|
||||
gstsmokeenc.c gstsmokedec.c smokecodec.c
|
||||
gstjpeg.c \
|
||||
gstjpegdec.c
|
||||
|
||||
# gstjpegenc.c
|
||||
# gstsmokeenc.c
|
||||
# gstsmokedec.c
|
||||
# smokecodec.c
|
||||
|
||||
libgstjpeg_la_CFLAGS = $(GST_CFLAGS)
|
||||
libgstjpeg_la_LIBADD = $(JPEG_LIBS)
|
||||
libgstjpeg_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
|
||||
|
|
|
|||
|
|
@ -19,9 +19,14 @@
|
|||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <gst/gst.h>
|
||||
|
||||
#include "gstjpegdec.h"
|
||||
|
||||
#if 0
|
||||
#include "gstjpegenc.h"
|
||||
#include "gstsmokeenc.h"
|
||||
#include "gstsmokedec.h"
|
||||
|
|
@ -42,18 +47,22 @@ smoke_type_find (GstTypeFind * tf, gpointer private)
|
|||
gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, SMOKE_CAPS);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static gboolean
|
||||
plugin_init (GstPlugin * plugin)
|
||||
{
|
||||
#if 0
|
||||
if (!gst_element_register (plugin, "jpegenc", GST_RANK_NONE,
|
||||
GST_TYPE_JPEGENC))
|
||||
return FALSE;
|
||||
#endif
|
||||
|
||||
if (!gst_element_register (plugin, "jpegdec", GST_RANK_PRIMARY,
|
||||
GST_TYPE_JPEGDEC))
|
||||
GST_TYPE_JPEG_DEC))
|
||||
return FALSE;
|
||||
|
||||
#if 0
|
||||
if (!gst_element_register (plugin, "smokeenc", GST_RANK_PRIMARY,
|
||||
GST_TYPE_SMOKEENC))
|
||||
return FALSE;
|
||||
|
|
@ -65,6 +74,7 @@ plugin_init (GstPlugin * plugin)
|
|||
if (!gst_type_find_register (plugin, "video/x-smoke", GST_RANK_PRIMARY,
|
||||
smoke_type_find, NULL, SMOKE_CAPS, NULL))
|
||||
return FALSE;
|
||||
#endif
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,18 +25,40 @@
|
|||
|
||||
#include "gstjpegdec.h"
|
||||
#include <gst/video/video.h>
|
||||
#include "gst/gst-i18n-plugin.h"
|
||||
#include <jerror.h>
|
||||
|
||||
/* elementfactory information */
|
||||
GstElementDetails gst_jpegdec_details = {
|
||||
GstElementDetails gst_jpeg_dec_details = {
|
||||
"JPEG image decoder",
|
||||
"Codec/Decoder/Image",
|
||||
"Decode images from JPEG format",
|
||||
"Wim Taymans <wim.taymans@tvd.be>",
|
||||
};
|
||||
|
||||
GST_DEBUG_CATEGORY (jpegdec_debug);
|
||||
#define GST_CAT_DEFAULT jpegdec_debug
|
||||
#define MIN_WIDTH 16
|
||||
#define MAX_WIDTH 4096
|
||||
#define MIN_HEIGHT 16
|
||||
#define MAX_HEIGHT 4096
|
||||
|
||||
static GstStaticPadTemplate gst_jpeg_dec_src_pad_template =
|
||||
GST_STATIC_PAD_TEMPLATE ("src",
|
||||
GST_PAD_SRC,
|
||||
GST_PAD_ALWAYS,
|
||||
GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("I420"))
|
||||
);
|
||||
|
||||
static GstStaticPadTemplate gst_jpeg_dec_sink_pad_template =
|
||||
GST_STATIC_PAD_TEMPLATE ("sink",
|
||||
GST_PAD_SINK,
|
||||
GST_PAD_ALWAYS,
|
||||
GST_STATIC_CAPS ("image/jpeg, "
|
||||
"width = (int) [ " G_STRINGIFY (MIN_WIDTH) ", " G_STRINGIFY (MAX_WIDTH)
|
||||
" ], " "height = (int) [ " G_STRINGIFY (MIN_HEIGHT) ", "
|
||||
G_STRINGIFY (MAX_HEIGHT) " ], " "framerate = (double) [ 1, MAX ]")
|
||||
);
|
||||
|
||||
GST_DEBUG_CATEGORY (jpeg_dec_debug);
|
||||
#define GST_CAT_DEFAULT jpeg_dec_debug
|
||||
|
||||
/* These macros are adapted from videotestsrc.c
|
||||
* and/or gst-plugins/gst/games/gstvideoimage.c */
|
||||
|
|
@ -55,200 +77,402 @@ GST_DEBUG_CATEGORY (jpegdec_debug);
|
|||
|
||||
#define I420_SIZE(w,h) (I420_V_OFFSET(w,h)+(I420_V_ROWSTRIDE(w)*ROUND_UP_2(h)/2))
|
||||
|
||||
static GstElementClass *parent_class; /* NULL */
|
||||
|
||||
static void gst_jpegdec_base_init (gpointer g_class);
|
||||
static void gst_jpegdec_class_init (GstJpegDec * klass);
|
||||
static void gst_jpegdec_init (GstJpegDec * jpegdec);
|
||||
static void gst_jpeg_dec_base_init (gpointer g_class);
|
||||
static void gst_jpeg_dec_class_init (GstJpegDecClass * klass);
|
||||
static void gst_jpeg_dec_init (GstJpegDec * jpegdec);
|
||||
|
||||
static void gst_jpegdec_chain (GstPad * pad, GstData * _data);
|
||||
static GstPadLinkReturn gst_jpegdec_link (GstPad * pad, const GstCaps * caps);
|
||||
|
||||
static GstElementClass *parent_class = NULL;
|
||||
|
||||
/*static guint gst_jpegdec_signals[LAST_SIGNAL] = { 0 }; */
|
||||
static GstFlowReturn gst_jpeg_dec_chain (GstPad * pad, GstBuffer * buffer);
|
||||
static GstElementStateReturn gst_jpeg_dec_change_state (GstElement * element);
|
||||
|
||||
GType
|
||||
gst_jpegdec_get_type (void)
|
||||
gst_jpeg_dec_get_type (void)
|
||||
{
|
||||
static GType jpegdec_type = 0;
|
||||
static GType type = 0;
|
||||
|
||||
if (!jpegdec_type) {
|
||||
static const GTypeInfo jpegdec_info = {
|
||||
sizeof (GstJpegDec),
|
||||
gst_jpegdec_base_init,
|
||||
if (!type) {
|
||||
static const GTypeInfo jpeg_dec_info = {
|
||||
sizeof (GstJpegDecClass),
|
||||
(GBaseInitFunc) gst_jpeg_dec_base_init,
|
||||
NULL,
|
||||
(GClassInitFunc) gst_jpegdec_class_init,
|
||||
(GClassInitFunc) gst_jpeg_dec_class_init,
|
||||
NULL,
|
||||
NULL,
|
||||
sizeof (GstJpegDec),
|
||||
0,
|
||||
(GInstanceInitFunc) gst_jpegdec_init,
|
||||
(GInstanceInitFunc) gst_jpeg_dec_init,
|
||||
};
|
||||
|
||||
jpegdec_type =
|
||||
g_type_register_static (GST_TYPE_ELEMENT, "GstJpegDec", &jpegdec_info,
|
||||
0);
|
||||
type = g_type_register_static (GST_TYPE_ELEMENT, "GstJpegDec",
|
||||
&jpeg_dec_info, 0);
|
||||
}
|
||||
return jpegdec_type;
|
||||
return type;
|
||||
}
|
||||
|
||||
static GstStaticPadTemplate gst_jpegdec_src_pad_template =
|
||||
GST_STATIC_PAD_TEMPLATE ("src",
|
||||
GST_PAD_SRC,
|
||||
GST_PAD_ALWAYS,
|
||||
GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("I420"))
|
||||
);
|
||||
|
||||
static GstStaticPadTemplate gst_jpegdec_sink_pad_template =
|
||||
GST_STATIC_PAD_TEMPLATE ("sink",
|
||||
GST_PAD_SINK,
|
||||
GST_PAD_ALWAYS,
|
||||
GST_STATIC_CAPS ("image/jpeg, "
|
||||
"width = (int) [ 16, 4096 ], "
|
||||
"height = (int) [ 16, 4096 ], " "framerate = (double) [ 1, MAX ]")
|
||||
);
|
||||
|
||||
static void
|
||||
gst_jpegdec_base_init (gpointer g_class)
|
||||
gst_jpeg_dec_finalize (GObject * object)
|
||||
{
|
||||
GstJpegDec *dec = GST_JPEG_DEC (object);
|
||||
|
||||
jpeg_destroy_decompress (&dec->cinfo);
|
||||
|
||||
if (dec->tempbuf)
|
||||
gst_buffer_unref (dec->tempbuf);
|
||||
|
||||
G_OBJECT_CLASS (parent_class)->finalize (object);
|
||||
}
|
||||
|
||||
static void
|
||||
gst_jpeg_dec_base_init (gpointer g_class)
|
||||
{
|
||||
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
|
||||
|
||||
gst_element_class_add_pad_template (element_class,
|
||||
gst_static_pad_template_get (&gst_jpegdec_src_pad_template));
|
||||
gst_static_pad_template_get (&gst_jpeg_dec_src_pad_template));
|
||||
gst_element_class_add_pad_template (element_class,
|
||||
gst_static_pad_template_get (&gst_jpegdec_sink_pad_template));
|
||||
gst_element_class_set_details (element_class, &gst_jpegdec_details);
|
||||
gst_static_pad_template_get (&gst_jpeg_dec_sink_pad_template));
|
||||
gst_element_class_set_details (element_class, &gst_jpeg_dec_details);
|
||||
}
|
||||
|
||||
static void
|
||||
gst_jpegdec_class_init (GstJpegDec * klass)
|
||||
gst_jpeg_dec_class_init (GstJpegDecClass * klass)
|
||||
{
|
||||
GstElementClass *gstelement_class;
|
||||
GObjectClass *gobject_class;
|
||||
|
||||
gstelement_class = (GstElementClass *) klass;
|
||||
gobject_class = (GObjectClass *) klass;
|
||||
|
||||
parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
|
||||
parent_class = g_type_class_peek_parent (klass);
|
||||
|
||||
GST_DEBUG_CATEGORY_INIT (jpegdec_debug, "jpegdec", 0, "JPEG decoder");
|
||||
}
|
||||
gobject_class->finalize = gst_jpeg_dec_finalize;
|
||||
gstelement_class->change_state = gst_jpeg_dec_change_state;
|
||||
|
||||
static void
|
||||
gst_jpegdec_init_source (j_decompress_ptr cinfo)
|
||||
{
|
||||
GST_DEBUG ("init_source");
|
||||
GST_DEBUG_CATEGORY_INIT (jpeg_dec_debug, "jpegdec", 0, "JPEG decoder");
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gst_jpegdec_fill_input_buffer (j_decompress_ptr cinfo)
|
||||
gst_jpeg_dec_fill_input_buffer (j_decompress_ptr cinfo)
|
||||
{
|
||||
/*
|
||||
struct GstJpegDecSourceMgr *src_mgr;
|
||||
GstJpegDec *dec;
|
||||
|
||||
src_mgr = (struct GstJpegDecSourceMgr*) &cinfo->src;
|
||||
dec = GST_JPEG_DEC (src_mgr->dec);
|
||||
*/
|
||||
GST_DEBUG ("fill_input_buffer");
|
||||
/*
|
||||
g_return_val_if_fail (dec != NULL, TRUE);
|
||||
|
||||
src_mgr->pub.next_input_byte = GST_BUFFER_DATA (dec->tempbuf);
|
||||
src_mgr->pub.bytes_in_buffer = GST_BUFFER_SIZE (dec->tempbuf);
|
||||
*/
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
gst_jpegdec_skip_input_data (j_decompress_ptr cinfo, glong num_bytes)
|
||||
gst_jpeg_dec_init_source (j_decompress_ptr cinfo)
|
||||
{
|
||||
GST_DEBUG ("skip_input_data");
|
||||
GST_DEBUG ("init_source");
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
gst_jpeg_dec_skip_input_data (j_decompress_ptr cinfo, glong num_bytes)
|
||||
{
|
||||
GST_DEBUG ("skip_input_data: %ld bytes", num_bytes);
|
||||
|
||||
if (num_bytes > 0 && cinfo->src->bytes_in_buffer >= num_bytes) {
|
||||
cinfo->src->next_input_byte += (size_t) num_bytes;
|
||||
cinfo->src->bytes_in_buffer -= (size_t) num_bytes;
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gst_jpegdec_resync_to_restart (j_decompress_ptr cinfo, gint desired)
|
||||
gst_jpeg_dec_resync_to_restart (j_decompress_ptr cinfo, gint desired)
|
||||
{
|
||||
GST_DEBUG ("resync_to_start");
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
gst_jpegdec_term_source (j_decompress_ptr cinfo)
|
||||
gst_jpeg_dec_term_source (j_decompress_ptr cinfo)
|
||||
{
|
||||
GST_DEBUG ("term_source");
|
||||
return;
|
||||
}
|
||||
|
||||
METHODDEF (void)
|
||||
gst_jpegdec_my_output_message (j_common_ptr cinfo)
|
||||
gst_jpeg_dec_my_output_message (j_common_ptr cinfo)
|
||||
{
|
||||
// Do nothing
|
||||
return; /* do nothing */
|
||||
}
|
||||
|
||||
METHODDEF (void)
|
||||
gst_jpegdec_my_emit_message (j_common_ptr cinfo, int msg_level)
|
||||
gst_jpeg_dec_my_emit_message (j_common_ptr cinfo, int msg_level)
|
||||
{
|
||||
// Do nothing
|
||||
/* GST_DEBUG ("emit_message: msg_level = %d", msg_level); */
|
||||
return;
|
||||
}
|
||||
|
||||
METHODDEF (void)
|
||||
gst_jpeg_dec_my_error_exit (j_common_ptr cinfo)
|
||||
{
|
||||
struct GstJpegDecErrorMgr *err_mgr = (struct GstJpegDecErrorMgr *) cinfo->err;
|
||||
|
||||
(*cinfo->err->output_message) (cinfo);
|
||||
longjmp (err_mgr->setjmp_buffer, 1);
|
||||
}
|
||||
|
||||
static void
|
||||
gst_jpegdec_init (GstJpegDec * jpegdec)
|
||||
gst_jpeg_dec_init (GstJpegDec * dec)
|
||||
{
|
||||
GST_DEBUG ("initializing");
|
||||
|
||||
/* create the sink and src pads */
|
||||
|
||||
jpegdec->sinkpad =
|
||||
dec->sinkpad =
|
||||
gst_pad_new_from_template (gst_static_pad_template_get
|
||||
(&gst_jpegdec_sink_pad_template), "sink");
|
||||
gst_element_add_pad (GST_ELEMENT (jpegdec), jpegdec->sinkpad);
|
||||
gst_pad_set_chain_function (jpegdec->sinkpad, gst_jpegdec_chain);
|
||||
gst_pad_set_link_function (jpegdec->sinkpad, gst_jpegdec_link);
|
||||
(&gst_jpeg_dec_sink_pad_template), "sink");
|
||||
gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad);
|
||||
gst_pad_set_chain_function (dec->sinkpad,
|
||||
GST_DEBUG_FUNCPTR (gst_jpeg_dec_chain));
|
||||
|
||||
jpegdec->srcpad =
|
||||
dec->srcpad =
|
||||
gst_pad_new_from_template (gst_static_pad_template_get
|
||||
(&gst_jpegdec_src_pad_template), "src");
|
||||
gst_pad_use_explicit_caps (jpegdec->srcpad);
|
||||
gst_element_add_pad (GST_ELEMENT (jpegdec), jpegdec->srcpad);
|
||||
(&gst_jpeg_dec_src_pad_template), "src");
|
||||
gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad);
|
||||
|
||||
/* initialize the jpegdec decoder state */
|
||||
jpegdec->next_time = 0;
|
||||
dec->next_ts = 0;
|
||||
dec->fps = 1.0;
|
||||
|
||||
/* reset the initial video state */
|
||||
jpegdec->format = -1;
|
||||
jpegdec->width = -1;
|
||||
jpegdec->height = -1;
|
||||
dec->width = -1;
|
||||
dec->height = -1;
|
||||
|
||||
jpegdec->line[0] = NULL;
|
||||
jpegdec->line[1] = NULL;
|
||||
jpegdec->line[2] = NULL;
|
||||
dec->line[0] = NULL;
|
||||
dec->line[1] = NULL;
|
||||
dec->line[2] = NULL;
|
||||
|
||||
/* setup jpeglib */
|
||||
memset (&jpegdec->cinfo, 0, sizeof (jpegdec->cinfo));
|
||||
memset (&jpegdec->jerr, 0, sizeof (jpegdec->jerr));
|
||||
jpegdec->cinfo.err = jpeg_std_error (&jpegdec->jerr);
|
||||
jpegdec->cinfo.err->output_message = gst_jpegdec_my_output_message;
|
||||
jpegdec->cinfo.err->emit_message = gst_jpegdec_my_emit_message;
|
||||
memset (&dec->cinfo, 0, sizeof (dec->cinfo));
|
||||
memset (&dec->jerr, 0, sizeof (dec->jerr));
|
||||
dec->cinfo.err = jpeg_std_error (&dec->jerr.pub);
|
||||
dec->jerr.pub.output_message = gst_jpeg_dec_my_output_message;
|
||||
dec->jerr.pub.emit_message = gst_jpeg_dec_my_emit_message;
|
||||
dec->jerr.pub.error_exit = gst_jpeg_dec_my_error_exit;
|
||||
|
||||
jpeg_create_decompress (&jpegdec->cinfo);
|
||||
|
||||
jpegdec->jsrc.init_source = gst_jpegdec_init_source;
|
||||
jpegdec->jsrc.fill_input_buffer = gst_jpegdec_fill_input_buffer;
|
||||
jpegdec->jsrc.skip_input_data = gst_jpegdec_skip_input_data;
|
||||
jpegdec->jsrc.resync_to_restart = gst_jpegdec_resync_to_restart;
|
||||
jpegdec->jsrc.term_source = gst_jpegdec_term_source;
|
||||
jpegdec->cinfo.src = &jpegdec->jsrc;
|
||||
jpeg_create_decompress (&dec->cinfo);
|
||||
|
||||
dec->cinfo.src = (struct jpeg_source_mgr *) &dec->jsrc;
|
||||
dec->cinfo.src->init_source = gst_jpeg_dec_init_source;
|
||||
dec->cinfo.src->fill_input_buffer = gst_jpeg_dec_fill_input_buffer;
|
||||
dec->cinfo.src->skip_input_data = gst_jpeg_dec_skip_input_data;
|
||||
dec->cinfo.src->resync_to_restart = gst_jpeg_dec_resync_to_restart;
|
||||
dec->cinfo.src->term_source = gst_jpeg_dec_term_source;
|
||||
dec->jsrc.dec = dec;
|
||||
}
|
||||
|
||||
static GstPadLinkReturn
|
||||
gst_jpegdec_link (GstPad * pad, const GstCaps * caps)
|
||||
static inline gboolean
|
||||
is_jpeg_start_marker (const guint8 * data)
|
||||
{
|
||||
GstJpegDec *jpegdec = GST_JPEGDEC (gst_pad_get_parent (pad));
|
||||
GstStructure *structure;
|
||||
GstCaps *srccaps;
|
||||
return (data[0] == 0xff && data[1] == 0xd8);
|
||||
}
|
||||
|
||||
structure = gst_caps_get_structure (caps, 0);
|
||||
static inline gboolean
|
||||
is_jpeg_end_marker (const guint8 * data)
|
||||
{
|
||||
return (data[0] == 0xff && data[1] == 0xd9);
|
||||
}
|
||||
|
||||
gst_structure_get_double (structure, "framerate", &jpegdec->fps);
|
||||
gst_structure_get_int (structure, "width", &jpegdec->width);
|
||||
gst_structure_get_int (structure, "height", &jpegdec->height);
|
||||
static gboolean
|
||||
gst_jpeg_dec_find_jpeg_header (GstJpegDec * dec)
|
||||
{
|
||||
const guint8 *data;
|
||||
guint size;
|
||||
|
||||
srccaps = gst_caps_new_simple ("video/x-raw-yuv",
|
||||
"format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
|
||||
"width", G_TYPE_INT, jpegdec->width,
|
||||
"height", G_TYPE_INT, jpegdec->height,
|
||||
"framerate", G_TYPE_DOUBLE, jpegdec->fps, NULL);
|
||||
data = GST_BUFFER_DATA (dec->tempbuf);
|
||||
size = GST_BUFFER_SIZE (dec->tempbuf);
|
||||
|
||||
/* at this point, we're pretty sure that this will be the output
|
||||
* format, so we'll set it. */
|
||||
gst_pad_set_explicit_caps (jpegdec->srcpad, srccaps);
|
||||
g_return_val_if_fail (size >= 2, FALSE);
|
||||
|
||||
return GST_PAD_LINK_OK;
|
||||
while (!is_jpeg_start_marker (data) || data[2] != 0xff) {
|
||||
const guint8 *marker;
|
||||
GstBuffer *tmp;
|
||||
guint off;
|
||||
|
||||
marker = memchr (data + 1, 0xff, size - 1 - 2);
|
||||
if (marker == NULL) {
|
||||
off = size - 1; /* keep last byte */
|
||||
} else {
|
||||
off = marker - data;
|
||||
}
|
||||
|
||||
tmp = gst_buffer_create_sub (dec->tempbuf, off, size - off);
|
||||
gst_buffer_unref (dec->tempbuf);
|
||||
dec->tempbuf = tmp;
|
||||
|
||||
data = GST_BUFFER_DATA (dec->tempbuf);
|
||||
size = GST_BUFFER_SIZE (dec->tempbuf);
|
||||
|
||||
if (size < 2)
|
||||
return FALSE; /* wait for more data */
|
||||
}
|
||||
|
||||
return TRUE; /* got header */
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gst_jpeg_dec_ensure_header (GstJpegDec * dec)
|
||||
{
|
||||
g_return_val_if_fail (dec->tempbuf != NULL, FALSE);
|
||||
|
||||
check_header:
|
||||
|
||||
/* we need at least a start marker (0xff 0xd8)
|
||||
* and an end marker (0xff 0xd9) */
|
||||
if (GST_BUFFER_SIZE (dec->tempbuf) <= 4) {
|
||||
GST_DEBUG ("Not enough data");
|
||||
return FALSE; /* we need more data */
|
||||
}
|
||||
|
||||
if (!is_jpeg_start_marker (GST_BUFFER_DATA (dec->tempbuf))) {
|
||||
GST_DEBUG ("Not a JPEG header, resyncing to header...");
|
||||
if (!gst_jpeg_dec_find_jpeg_header (dec)) {
|
||||
GST_DEBUG ("No JPEG header in current buffer");
|
||||
return FALSE; /* we need more data */
|
||||
}
|
||||
GST_DEBUG ("Found JPEG header");
|
||||
goto check_header; /* buffer might have changed */
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#if 0
|
||||
static gboolean
|
||||
gst_jpeg_dec_have_end_marker (GstJpegDec * dec)
|
||||
{
|
||||
guint8 *data = GST_BUFFER_DATA (dec->tempbuf);
|
||||
guint size = GST_BUFFER_SIZE (dec->tempbuf);
|
||||
|
||||
return (size > 2 && data && is_jpeg_end_marker (data + size - 2));
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline gboolean
|
||||
gst_jpeg_dec_parse_tag_has_entropy_segment (guint8 tag)
|
||||
{
|
||||
if (tag == 0xda || (tag >= 0xd0 && tag <= 0xd7))
|
||||
return TRUE;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* returns image length in bytes if parsed
|
||||
* successfully, otherwise 0 */
|
||||
static guint
|
||||
gst_jpeg_dec_parse_image_data (GstJpegDec * dec)
|
||||
{
|
||||
guint8 *start, *data, *end;
|
||||
guint size;
|
||||
|
||||
size = GST_BUFFER_SIZE (dec->tempbuf);
|
||||
start = GST_BUFFER_DATA (dec->tempbuf);
|
||||
end = start + size;
|
||||
data = start;
|
||||
|
||||
g_return_val_if_fail (is_jpeg_start_marker (data), 0);
|
||||
|
||||
GST_DEBUG ("Parsing jpeg image data (%u bytes)", size);
|
||||
|
||||
/* skip start marker */
|
||||
data += 2;
|
||||
|
||||
while (1) {
|
||||
guint frame_len;
|
||||
|
||||
/* enough bytes left for EOI marker? (we need 0xff 0xNN, thus end-1) */
|
||||
if (data >= end - 1) {
|
||||
GST_DEBUG ("at end of input and no EOI marker found, need more data");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (is_jpeg_end_marker (data)) {
|
||||
GST_DEBUG ("0x%08x: end marker", data - start);
|
||||
goto found_eoi;
|
||||
}
|
||||
|
||||
/* do we need to resync? */
|
||||
if (*data != 0xff) {
|
||||
GST_DEBUG ("Lost sync at 0x%08x, resyncing", data - start);
|
||||
/* at the very least we expect 0xff 0xNN, thus end-1 */
|
||||
while (*data != 0xff && data < end - 1)
|
||||
++data;
|
||||
if (is_jpeg_end_marker (data)) {
|
||||
GST_DEBUG ("resynced to end marker");
|
||||
goto found_eoi;
|
||||
}
|
||||
/* we need 0xFF 0xNN 0xLL 0xLL */
|
||||
if (data >= end - 1 - 2) {
|
||||
GST_DEBUG ("at end of input, without new sync, need more data");
|
||||
return 0;
|
||||
}
|
||||
/* check if we will still be in sync if we interpret
|
||||
* this as a sync point and skip this frame */
|
||||
frame_len = GST_READ_UINT16_BE (data + 2);
|
||||
GST_DEBUG ("possible sync at 0x%08x, frame_len=%u", data - start,
|
||||
frame_len);
|
||||
if (data + 2 + frame_len >= end - 1 || data[2 + frame_len] != 0xff) {
|
||||
/* ignore and continue resyncing until we hit the end
|
||||
* of our data or find a sync point that looks okay */
|
||||
++data;
|
||||
continue;
|
||||
}
|
||||
GST_DEBUG ("found sync at 0x%08x", data - size);
|
||||
}
|
||||
while (*data == 0xff)
|
||||
++data;
|
||||
if (data + 2 >= end)
|
||||
return 0;
|
||||
if (*data >= 0xd0 && *data <= 0xd7)
|
||||
frame_len = 0;
|
||||
else
|
||||
frame_len = GST_READ_UINT16_BE (data + 1);
|
||||
GST_DEBUG ("0x%08x: tag %02x, frame_len=%u", data - start - 1, *data,
|
||||
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, thus end-2 */
|
||||
if (data + 1 + frame_len >= end - 2) {
|
||||
/* theoretically we could have lost sync and not really need more
|
||||
* data, but that's just tough luck and a broken image then */
|
||||
GST_DEBUG ("at end of input and no EOI marker found, need more data");
|
||||
return 0;
|
||||
}
|
||||
if (gst_jpeg_dec_parse_tag_has_entropy_segment (*data)) {
|
||||
guint8 *d2 = data + 1 + frame_len;
|
||||
guint eseglen = 0;
|
||||
|
||||
GST_DEBUG ("0x%08x: finding entropy segment length", data - start - 1);
|
||||
while (1) {
|
||||
if (d2[eseglen] == 0xff && d2[eseglen + 1] != 0x00)
|
||||
break;
|
||||
if (d2 + eseglen >= end - 1)
|
||||
return 0; /* need more data */
|
||||
++eseglen;
|
||||
}
|
||||
frame_len += eseglen;
|
||||
GST_DEBUG ("entropy segment length=%u => frame_len=%u", eseglen,
|
||||
frame_len);
|
||||
}
|
||||
data += 1 + frame_len;
|
||||
}
|
||||
|
||||
found_eoi:
|
||||
/* data is assumed to point to the 0xff sync point of the
|
||||
* EOI marker (so there is one more byte after that) */
|
||||
g_assert (is_jpeg_end_marker (data));
|
||||
return ((data + 1) - start + 1);
|
||||
}
|
||||
|
||||
/* shamelessly ripped from jpegutils.c in mjpegtools */
|
||||
|
|
@ -371,124 +595,236 @@ guarantee_huff_tables (j_decompress_ptr dinfo)
|
|||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gst_jpegdec_chain (GstPad * pad, GstData * _data)
|
||||
static GstFlowReturn
|
||||
gst_jpeg_dec_chain (GstPad * pad, GstBuffer * buf)
|
||||
{
|
||||
GstBuffer *buf = GST_BUFFER (_data);
|
||||
GstJpegDec *jpegdec;
|
||||
guchar *data, *outdata;
|
||||
gulong size, outsize;
|
||||
GstFlowReturn ret;
|
||||
GstJpegDec *dec;
|
||||
GstBuffer *outbuf;
|
||||
|
||||
/*GstMeta *meta; */
|
||||
gint width, height;
|
||||
GstCaps *caps;
|
||||
gulong size, outsize;
|
||||
guchar *data, *outdata;
|
||||
guchar *base[3];
|
||||
gint i, j, k;
|
||||
guint img_len;
|
||||
gint width, height;
|
||||
gint r_h, r_v;
|
||||
gint i, j, k;
|
||||
|
||||
g_return_if_fail (pad != NULL);
|
||||
g_return_if_fail (GST_IS_PAD (pad));
|
||||
g_return_if_fail (buf != NULL);
|
||||
/*g_return_if_fail(GST_IS_BUFFER(buf)); */
|
||||
dec = GST_JPEG_DEC (GST_OBJECT_PARENT (pad));
|
||||
|
||||
jpegdec = GST_JPEGDEC (GST_OBJECT_PARENT (pad));
|
||||
|
||||
if (!GST_PAD_IS_LINKED (jpegdec->srcpad)) {
|
||||
gst_buffer_unref (buf);
|
||||
return;
|
||||
if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (buf))) {
|
||||
dec->next_ts = GST_BUFFER_TIMESTAMP (buf);
|
||||
}
|
||||
|
||||
data = (guchar *) GST_BUFFER_DATA (buf);
|
||||
size = GST_BUFFER_SIZE (buf);
|
||||
GST_LOG_OBJECT (jpegdec, "got buffer of %ld bytes", size);
|
||||
if (dec->tempbuf) {
|
||||
dec->tempbuf = gst_buffer_join (dec->tempbuf, buf);
|
||||
} else {
|
||||
dec->tempbuf = buf;
|
||||
}
|
||||
buf = NULL;
|
||||
|
||||
jpegdec->jsrc.next_input_byte = data;
|
||||
jpegdec->jsrc.bytes_in_buffer = size;
|
||||
if (!gst_jpeg_dec_ensure_header (dec))
|
||||
return GST_FLOW_OK; /* need more data */
|
||||
|
||||
#if 0
|
||||
/* This is a very crude way to handle 'progressive
|
||||
* loading' without parsing the image, and thus
|
||||
* considerably cheaper. It should work for most
|
||||
* most use cases, as with most use cases the end
|
||||
* of the image is also the end of a buffer. */
|
||||
if (!gst_jpeg_dec_have_end_marker (dec))
|
||||
return GST_FLOW_OK; /* need more data */
|
||||
#endif
|
||||
|
||||
GST_LOG_OBJECT (jpegdec, "reading header %08lx", *(gulong *) data);
|
||||
jpeg_read_header (&jpegdec->cinfo, TRUE);
|
||||
/* Parse jpeg image to handle jpeg input that
|
||||
* is not aligned to buffer boundaries */
|
||||
img_len = gst_jpeg_dec_parse_image_data (dec);
|
||||
|
||||
r_h = jpegdec->cinfo.cur_comp_info[0]->h_samp_factor;
|
||||
r_v = jpegdec->cinfo.cur_comp_info[0]->v_samp_factor;
|
||||
if (img_len == 0)
|
||||
return GST_FLOW_OK; /* need more data */
|
||||
|
||||
/*g_print ("%d %d\n", r_h, r_v); */
|
||||
/*g_print ("%d %d\n", jpegdec->cinfo.cur_comp_info[1]->h_samp_factor, jpegdec->cinfo.cur_comp_info[1]->v_samp_factor); */
|
||||
/*g_print ("%d %d\n", jpegdec->cinfo.cur_comp_info[2]->h_samp_factor, jpegdec->cinfo.cur_comp_info[2]->v_samp_factor); */
|
||||
data = (guchar *) GST_BUFFER_DATA (dec->tempbuf);
|
||||
size = img_len;
|
||||
GST_LOG_OBJECT (dec, "image size = %u", img_len);
|
||||
|
||||
jpegdec->cinfo.do_fancy_upsampling = FALSE;
|
||||
jpegdec->cinfo.do_block_smoothing = FALSE;
|
||||
jpegdec->cinfo.out_color_space = JCS_YCbCr;
|
||||
jpegdec->cinfo.dct_method = JDCT_IFAST;
|
||||
jpegdec->cinfo.raw_data_out = TRUE;
|
||||
GST_LOG_OBJECT (jpegdec, "starting decompress");
|
||||
guarantee_huff_tables (&jpegdec->cinfo);
|
||||
jpeg_start_decompress (&jpegdec->cinfo);
|
||||
width = jpegdec->cinfo.output_width;
|
||||
height = jpegdec->cinfo.output_height;
|
||||
dec->jsrc.pub.next_input_byte = data;
|
||||
dec->jsrc.pub.bytes_in_buffer = size;
|
||||
|
||||
if (jpegdec->height != height || jpegdec->line[0] == NULL) {
|
||||
GstCaps *caps;
|
||||
if (setjmp (dec->jerr.setjmp_buffer)) {
|
||||
if (dec->jerr.pub.msg_code == JERR_INPUT_EOF) {
|
||||
GST_DEBUG ("jpeg input EOF error, we probably need more data");
|
||||
return GST_FLOW_OK;
|
||||
}
|
||||
GST_ELEMENT_ERROR (dec, LIBRARY, TOO_LAZY,
|
||||
(_("Failed to decode JPEG image")), (NULL));
|
||||
ret = GST_FLOW_ERROR;
|
||||
goto done;
|
||||
}
|
||||
|
||||
jpegdec->line[0] = g_realloc (jpegdec->line[0], height * sizeof (char *));
|
||||
jpegdec->line[1] = g_realloc (jpegdec->line[1], height * sizeof (char *));
|
||||
jpegdec->line[2] = g_realloc (jpegdec->line[2], height * sizeof (char *));
|
||||
jpegdec->height = height;
|
||||
GST_LOG_OBJECT (dec, "reading header %02x %02x %02x %02x", data[0], data[1],
|
||||
data[2], data[3]);
|
||||
jpeg_read_header (&dec->cinfo, TRUE);
|
||||
|
||||
r_h = dec->cinfo.cur_comp_info[0]->h_samp_factor;
|
||||
r_v = dec->cinfo.cur_comp_info[0]->v_samp_factor;
|
||||
|
||||
GST_DEBUG ("num_components=%d, comps_in_scan=%d\n",
|
||||
dec->cinfo.num_components, dec->cinfo.comps_in_scan);
|
||||
for (i = 0; i < 3; ++i) {
|
||||
GST_DEBUG ("[%d] h_samp_factor=%d, v_samp_factor=%d\n", i,
|
||||
dec->cinfo.cur_comp_info[i]->h_samp_factor,
|
||||
dec->cinfo.cur_comp_info[i]->v_samp_factor);
|
||||
}
|
||||
|
||||
dec->cinfo.do_fancy_upsampling = FALSE;
|
||||
dec->cinfo.do_block_smoothing = FALSE;
|
||||
dec->cinfo.out_color_space = JCS_YCbCr;
|
||||
dec->cinfo.dct_method = JDCT_IFAST;
|
||||
dec->cinfo.raw_data_out = TRUE;
|
||||
GST_LOG_OBJECT (dec, "starting decompress");
|
||||
guarantee_huff_tables (&dec->cinfo);
|
||||
jpeg_start_decompress (&dec->cinfo);
|
||||
width = dec->cinfo.output_width;
|
||||
height = dec->cinfo.output_height;
|
||||
|
||||
if (width < MIN_WIDTH || width > MAX_WIDTH ||
|
||||
height < MIN_HEIGHT || height > MAX_HEIGHT) {
|
||||
GST_ELEMENT_ERROR (dec, STREAM, DECODE,
|
||||
("Picture is too small or too big (%ux%u)", width, height),
|
||||
("Picture is too small or too big (%ux%u)", width, height));
|
||||
ret = GST_FLOW_ERROR;
|
||||
goto done;
|
||||
}
|
||||
|
||||
if (height != dec->height) {
|
||||
dec->line[0] = g_realloc (dec->line[0], height * sizeof (guint8 *));
|
||||
dec->line[1] = g_realloc (dec->line[1], height * sizeof (guint8 *));
|
||||
dec->line[2] = g_realloc (dec->line[2], height * sizeof (guint8 *));
|
||||
dec->height = height;
|
||||
}
|
||||
|
||||
/* FIXME: implement upstream nego for framerate? */
|
||||
caps = gst_caps_new_simple ("video/x-raw-yuv",
|
||||
"format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
|
||||
"width", G_TYPE_INT, width,
|
||||
"height", G_TYPE_INT, height,
|
||||
"framerate", G_TYPE_DOUBLE, jpegdec->fps, NULL);
|
||||
GST_DEBUG_OBJECT (jpegdec, "height changed, setting caps %" GST_PTR_FORMAT,
|
||||
caps);
|
||||
gst_pad_set_explicit_caps (jpegdec->srcpad, caps);
|
||||
gst_caps_free (caps);
|
||||
}
|
||||
"framerate", G_TYPE_DOUBLE, (double) dec->fps, NULL);
|
||||
|
||||
GST_DEBUG_OBJECT (dec, "setting caps %" GST_PTR_FORMAT, caps);
|
||||
|
||||
/* FIXME: someone needs to do the work to figure out how to correctly
|
||||
* calculate an output size that takes into account everything libjpeg
|
||||
* needs, like padding for DCT size and so on. */
|
||||
outsize = I420_SIZE (width, height);
|
||||
outbuf = gst_pad_alloc_buffer (jpegdec->srcpad, GST_BUFFER_OFFSET_NONE,
|
||||
outsize);
|
||||
|
||||
if (gst_pad_alloc_buffer (dec->srcpad, GST_BUFFER_OFFSET_NONE, outsize,
|
||||
caps, &outbuf) != GST_FLOW_OK) {
|
||||
GST_DEBUG_OBJECT (dec, "failed to alloc buffer");
|
||||
gst_caps_unref (caps);
|
||||
return GST_FLOW_ERROR;
|
||||
}
|
||||
|
||||
{
|
||||
GstStructure *str = gst_caps_get_structure (caps, 0);
|
||||
|
||||
if (gst_structure_get_double (str, "framerate", &dec->fps))
|
||||
GST_DEBUG ("framerate = %f\n", dec->fps);
|
||||
|
||||
}
|
||||
|
||||
gst_caps_unref (caps);
|
||||
|
||||
outdata = GST_BUFFER_DATA (outbuf);
|
||||
GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
|
||||
GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf);
|
||||
GST_LOG_OBJECT (jpegdec, "width %d, height %d, buffer size %d", width,
|
||||
GST_BUFFER_TIMESTAMP (outbuf) = dec->next_ts;
|
||||
GST_BUFFER_DURATION (outbuf) = GST_SECOND / dec->fps;
|
||||
GST_LOG_OBJECT (dec, "width %d, height %d, buffer size %d", width,
|
||||
height, outsize);
|
||||
|
||||
dec->next_ts += GST_BUFFER_DURATION (outbuf);
|
||||
|
||||
/* mind the swap, jpeglib outputs blue chroma first */
|
||||
base[0] = outdata + I420_Y_OFFSET (width, height);
|
||||
base[1] = outdata + I420_U_OFFSET (width, height);
|
||||
base[2] = outdata + I420_V_OFFSET (width, height);
|
||||
|
||||
GST_LOG_OBJECT (jpegdec, "decompressing %u",
|
||||
jpegdec->cinfo.rec_outbuf_height);
|
||||
GST_LOG_OBJECT (dec, "decompressing %u", dec->cinfo.rec_outbuf_height);
|
||||
|
||||
for (i = 0; i < height; i += r_v * DCTSIZE) {
|
||||
for (j = 0, k = 0; j < (r_v * DCTSIZE); j += r_v, k++) {
|
||||
jpegdec->line[0][j] = base[0];
|
||||
dec->line[0][j] = base[0];
|
||||
base[0] += I420_Y_ROWSTRIDE (width);
|
||||
if (r_v == 2) {
|
||||
jpegdec->line[0][j + 1] = base[0];
|
||||
dec->line[0][j + 1] = base[0];
|
||||
base[0] += I420_Y_ROWSTRIDE (width);
|
||||
}
|
||||
jpegdec->line[1][k] = base[1];
|
||||
jpegdec->line[2][k] = base[2];
|
||||
dec->line[1][k] = base[1];
|
||||
dec->line[2][k] = base[2];
|
||||
if (r_v == 2 || k & 1) {
|
||||
base[1] += I420_U_ROWSTRIDE (width);
|
||||
base[2] += I420_V_ROWSTRIDE (width);
|
||||
}
|
||||
}
|
||||
/*g_print ("%d\n", jpegdec->cinfo.output_scanline); */
|
||||
jpeg_read_raw_data (&jpegdec->cinfo, jpegdec->line, r_v * DCTSIZE);
|
||||
/* GST_DEBUG ("output_scanline = %d", dec->cinfo.output_scanline); */
|
||||
jpeg_read_raw_data (&dec->cinfo, dec->line, r_v * DCTSIZE);
|
||||
}
|
||||
|
||||
GST_LOG_OBJECT (jpegdec, "decompressing finished");
|
||||
jpeg_finish_decompress (&jpegdec->cinfo);
|
||||
GST_LOG_OBJECT (dec, "decompressing finished");
|
||||
jpeg_finish_decompress (&dec->cinfo);
|
||||
|
||||
GST_LOG_OBJECT (jpegdec, "sending buffer");
|
||||
gst_pad_push (jpegdec->srcpad, GST_DATA (outbuf));
|
||||
GST_LOG_OBJECT (dec, "sending buffer");
|
||||
gst_pad_push (dec->srcpad, outbuf);
|
||||
|
||||
gst_buffer_unref (buf);
|
||||
ret = GST_FLOW_OK;
|
||||
|
||||
done:
|
||||
if (GST_BUFFER_SIZE (dec->tempbuf) == img_len) {
|
||||
gst_buffer_unref (dec->tempbuf);
|
||||
dec->tempbuf = NULL;
|
||||
} else {
|
||||
GstBuffer *buf = gst_buffer_create_sub (dec->tempbuf, img_len,
|
||||
GST_BUFFER_SIZE (dec->tempbuf) - img_len);
|
||||
|
||||
gst_buffer_unref (dec->tempbuf);
|
||||
dec->tempbuf = buf;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static GstElementStateReturn
|
||||
gst_jpeg_dec_change_state (GstElement * element)
|
||||
{
|
||||
GstJpegDec *dec = GST_JPEG_DEC (element);
|
||||
|
||||
switch (GST_STATE_TRANSITION (element)) {
|
||||
case GST_STATE_NULL_TO_READY:
|
||||
dec->line[0] = NULL;
|
||||
dec->line[1] = NULL;
|
||||
dec->line[2] = NULL;
|
||||
dec->next_ts = 0;
|
||||
dec->width = -1;
|
||||
dec->height = -1;
|
||||
break;
|
||||
case GST_STATE_READY_TO_NULL:
|
||||
g_free (dec->line[0]);
|
||||
g_free (dec->line[1]);
|
||||
g_free (dec->line[2]);
|
||||
dec->line[0] = NULL;
|
||||
dec->line[1] = NULL;
|
||||
dec->line[2] = NULL;
|
||||
break;
|
||||
case GST_STATE_PAUSED_TO_READY:
|
||||
if (dec->tempbuf) {
|
||||
gst_buffer_unref (dec->tempbuf);
|
||||
dec->tempbuf = NULL;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (GST_ELEMENT_CLASS (parent_class)->change_state)
|
||||
return GST_ELEMENT_CLASS (parent_class)->change_state (element);
|
||||
|
||||
return GST_STATE_SUCCESS;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,73 +18,81 @@
|
|||
*/
|
||||
|
||||
|
||||
#ifndef __GST_JPEGDEC_H__
|
||||
#define __GST_JPEGDEC_H__
|
||||
#ifndef __GST_JPEG_DEC_H__
|
||||
#define __GST_JPEG_DEC_H__
|
||||
|
||||
|
||||
#include <gst/gst.h>
|
||||
#include <setjmp.h>
|
||||
#include <gst/gstelement.h>
|
||||
|
||||
/* this is a hack hack hack to get around jpeglib header bugs... */
|
||||
#ifdef HAVE_STDLIB_H
|
||||
# undef HAVE_STDLIB_H
|
||||
#endif
|
||||
#include <jpeglib.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
G_BEGIN_DECLS
|
||||
|
||||
|
||||
#define GST_TYPE_JPEGDEC \
|
||||
(gst_jpegdec_get_type())
|
||||
#define GST_JPEGDEC(obj) \
|
||||
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_JPEGDEC,GstJpegDec))
|
||||
#define GST_JPEGDEC_CLASS(klass) \
|
||||
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_JPEGDEC,GstJpegDec))
|
||||
#define GST_IS_JPEGDEC(obj) \
|
||||
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_JPEGDEC))
|
||||
#define GST_IS_JPEGDEC_CLASS(obj) \
|
||||
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_JPEGDEC))
|
||||
#define GST_TYPE_JPEG_DEC \
|
||||
(gst_jpeg_dec_get_type())
|
||||
#define GST_JPEG_DEC(obj) \
|
||||
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_JPEG_DEC,GstJpegDec))
|
||||
#define GST_JPEG_DEC_CLASS(klass) \
|
||||
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_JPEG_DEC,GstJpegDec))
|
||||
#define GST_IS_JPEG_DEC(obj) \
|
||||
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_JPEG_DEC))
|
||||
#define GST_IS_JPEG_DEC_CLASS(obj) \
|
||||
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_JPEG_DEC))
|
||||
|
||||
typedef struct _GstJpegDec GstJpegDec;
|
||||
typedef struct _GstJpegDecClass GstJpegDecClass;
|
||||
|
||||
struct GstJpegDecErrorMgr {
|
||||
struct jpeg_error_mgr pub; /* public fields */
|
||||
jmp_buf setjmp_buffer;
|
||||
};
|
||||
|
||||
struct GstJpegDecSourceMgr {
|
||||
struct jpeg_source_mgr pub; /* public fields */
|
||||
GstJpegDec *dec;
|
||||
};
|
||||
|
||||
/* Can't use GstBaseTransform, because GstBaseTransform
|
||||
* doesn't handle the N buffers in, 1 buffer out case,
|
||||
* but only the 1-in 1-out case */
|
||||
struct _GstJpegDec {
|
||||
GstElement element;
|
||||
|
||||
/* pads */
|
||||
GstPad *sinkpad,*srcpad;
|
||||
GstPad *sinkpad;
|
||||
GstPad *srcpad;
|
||||
|
||||
GstBuffer *tempbuf;
|
||||
|
||||
int parse_state;
|
||||
/* the timestamp of the next frame */
|
||||
guint64 next_time;
|
||||
/* the interval between frames */
|
||||
guint64 time_interval;
|
||||
guint64 next_ts;
|
||||
|
||||
/* video state */
|
||||
gint format;
|
||||
gint width;
|
||||
gint height;
|
||||
guint width;
|
||||
guint height;
|
||||
gdouble fps;
|
||||
/* the size of the output buffer */
|
||||
gint outsize;
|
||||
|
||||
/* the jpeg line buffer */
|
||||
guchar **line[3];
|
||||
|
||||
struct jpeg_decompress_struct cinfo;
|
||||
struct jpeg_error_mgr jerr;
|
||||
struct jpeg_source_mgr jsrc;
|
||||
struct GstJpegDecErrorMgr jerr;
|
||||
struct GstJpegDecSourceMgr jsrc;
|
||||
};
|
||||
|
||||
struct _GstJpegDecClass {
|
||||
GstElementClass parent_class;
|
||||
};
|
||||
|
||||
GType gst_jpegdec_get_type(void);
|
||||
GType gst_jpeg_dec_get_type(void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
G_END_DECLS
|
||||
|
||||
|
||||
#endif /* __GST_JPEGDEC_H__ */
|
||||
#endif /* __GST_JPEG_DEC_H__ */
|
||||
|
|
|
|||
Loading…
Reference in a new issue