2004-06-08 Wim Taymans <wim@fluendo.com>
+ * ext/jpeg/Makefile.am:
+ * ext/jpeg/README:
+ * ext/jpeg/gstjpeg.c: (plugin_init):
+ * ext/jpeg/gstsmokedec.c: (gst_smokedec_get_type),
+ (gst_smokedec_base_init), (gst_smokedec_class_init),
+ (gst_smokedec_init), (gst_smokedec_link), (gst_smokedec_chain):
+ * ext/jpeg/gstsmokedec.h:
+ * ext/jpeg/gstsmokeenc.c: (gst_smokeenc_get_type),
+ (gst_smokeenc_base_init), (gst_smokeenc_class_init),
+ (gst_smokeenc_init), (gst_smokeenc_getcaps), (gst_smokeenc_link),
+ (gst_smokeenc_resync), (gst_smokeenc_chain),
+ (gst_smokeenc_set_property), (gst_smokeenc_get_property):
+ * ext/jpeg/gstsmokeenc.h:
+ * ext/jpeg/smokecodec.c: (smokecodec_init_destination),
+ (smokecodec_flush_destination), (smokecodec_term_destination),
+ (smokecodec_init_source), (smokecodec_fill_input_buffer),
+ (smokecodec_skip_input_data), (smokecodec_resync_to_restart),
+ (smokecodec_term_source), (smokecodec_encode_new),
+ (smokecodec_decode_new), (smokecodec_info_free),
+ (smokecodec_set_quality), (smokecodec_get_quality),
+ (smokecodec_set_threshold), (smokecodec_get_threshold),
+ (smokecodec_set_bitrate), (smokecodec_get_bitrate),
+ (find_best_size), (abs_diff), (put), (smokecodec_encode),
+ (smokecodec_parse_header), (smokecodec_decode):
+ * ext/jpeg/smokecodec.h:
+ Added a new simple jpeg based codec
+
+2004-06-08 Wim Taymans <wim@fluendo.com>
+
* gst/multipart/multipartmux.c: (gst_multipart_mux_class_init),
(gst_multipart_mux_loop):
Fix memory leak
plugin_LTLIBRARIES = libgstjpeg.la
-libgstjpeg_la_SOURCES = gstjpeg.c gstjpegdec.c gstjpegenc.c
+libgstjpeg_la_SOURCES = 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)
--- /dev/null
+The Smoke Codec
+---------------
+
+This is a very simple compression algorithm I was toying with when doing a
+Java based player. Decoding a JPEG in Java has acceptable speed so this codec
+tries to exploit that feature. The algorithm first compares the last and the
+new image and finds all 16x16 blocks that have a squared difference bigger than
+a configurable threshold. Then all these blocks are compressed into an NxM JPEG.
+The quality of the JPEG is inversely proportional to the number of blocks, this
+way, the picture quality degrades with heavy motion scenes but the bitrate stays
+more or less constant.
+Decoding decompresses the JPEG and then updates the old picture with the new
+blocks.
+
+
+TODO:
+----
+- make format extensible
+- motion vectors
+- do some real bitrate control
#include "gstjpegdec.h"
#include "gstjpegenc.h"
+#include "gstsmokeenc.h"
+#include "gstsmokedec.h"
static gboolean
plugin_init (GstPlugin * plugin)
GST_TYPE_JPEGDEC))
return FALSE;
+ if (!gst_element_register (plugin, "smokeenc", GST_RANK_PRIMARY,
+ GST_TYPE_SMOKEENC))
+ return FALSE;
+
+ if (!gst_element_register (plugin, "smokedec", GST_RANK_PRIMARY,
+ GST_TYPE_SMOKEDEC))
+ return FALSE;
+
return TRUE;
}
--- /dev/null
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <string.h>
+
+/*#define DEBUG_ENABLED*/
+#include "gstsmokedec.h"
+#include <gst/video/video.h>
+
+/* elementfactory information */
+GstElementDetails gst_smokedec_details = {
+ "Smoke image decoder",
+ "Codec/Decoder/Image",
+ "Decode images from Smoke format",
+ "Wim Taymans <wim@fluendo.com>",
+};
+
+GST_DEBUG_CATEGORY (smokedec_debug);
+#define GST_CAT_DEFAULT smokedec_debug
+
+/* SmokeDec signals and args */
+enum
+{
+ /* FILL ME */
+ LAST_SIGNAL
+};
+
+enum
+{
+ ARG_0
+ /* FILL ME */
+};
+
+static void gst_smokedec_base_init (gpointer g_class);
+static void gst_smokedec_class_init (GstSmokeDec * klass);
+static void gst_smokedec_init (GstSmokeDec * smokedec);
+
+static void gst_smokedec_chain (GstPad * pad, GstData * _data);
+static GstPadLinkReturn gst_smokedec_link (GstPad * pad, const GstCaps * caps);
+
+static GstElementClass *parent_class = NULL;
+
+/*static guint gst_smokedec_signals[LAST_SIGNAL] = { 0 }; */
+
+GType
+gst_smokedec_get_type (void)
+{
+ static GType smokedec_type = 0;
+
+ if (!smokedec_type) {
+ static const GTypeInfo smokedec_info = {
+ sizeof (GstSmokeDecClass),
+ gst_smokedec_base_init,
+ NULL,
+ (GClassInitFunc) gst_smokedec_class_init,
+ NULL,
+ NULL,
+ sizeof (GstSmokeDec),
+ 0,
+ (GInstanceInitFunc) gst_smokedec_init,
+ };
+
+ smokedec_type =
+ g_type_register_static (GST_TYPE_ELEMENT, "GstSmokeDec", &smokedec_info,
+ 0);
+ }
+ return smokedec_type;
+}
+
+static GstStaticPadTemplate gst_smokedec_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_smokedec_sink_pad_template =
+GST_STATIC_PAD_TEMPLATE ("sink",
+ GST_PAD_SINK,
+ GST_PAD_ALWAYS,
+ GST_STATIC_CAPS ("image/x-smoke, "
+ "width = (int) [ 16, 4096 ], "
+ "height = (int) [ 16, 4096 ], " "framerate = (double) [ 1, MAX ]")
+ );
+
+static void
+gst_smokedec_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_smokedec_src_pad_template));
+ gst_element_class_add_pad_template (element_class,
+ gst_static_pad_template_get (&gst_smokedec_sink_pad_template));
+ gst_element_class_set_details (element_class, &gst_smokedec_details);
+}
+
+static void
+gst_smokedec_class_init (GstSmokeDec * klass)
+{
+ GstElementClass *gstelement_class;
+
+ gstelement_class = (GstElementClass *) klass;
+
+ parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
+
+ GST_DEBUG_CATEGORY_INIT (smokedec_debug, "smokedec", 0, "Smoke decoder");
+}
+
+static void
+gst_smokedec_init (GstSmokeDec * smokedec)
+{
+ GST_DEBUG ("gst_smokedec_init: initializing");
+ /* create the sink and src pads */
+
+ smokedec->sinkpad =
+ gst_pad_new_from_template (gst_static_pad_template_get
+ (&gst_smokedec_sink_pad_template), "sink");
+ gst_element_add_pad (GST_ELEMENT (smokedec), smokedec->sinkpad);
+ gst_pad_set_chain_function (smokedec->sinkpad, gst_smokedec_chain);
+ gst_pad_set_link_function (smokedec->sinkpad, gst_smokedec_link);
+
+ smokedec->srcpad =
+ gst_pad_new_from_template (gst_static_pad_template_get
+ (&gst_smokedec_src_pad_template), "src");
+ gst_pad_use_explicit_caps (smokedec->srcpad);
+ gst_element_add_pad (GST_ELEMENT (smokedec), smokedec->srcpad);
+
+ /* reset the initial video state */
+ smokedec->format = -1;
+ smokedec->width = -1;
+ smokedec->height = -1;
+}
+
+static GstPadLinkReturn
+gst_smokedec_link (GstPad * pad, const GstCaps * caps)
+{
+ GstSmokeDec *smokedec = GST_SMOKEDEC (gst_pad_get_parent (pad));
+ GstStructure *structure;
+ GstCaps *srccaps;
+
+ structure = gst_caps_get_structure (caps, 0);
+
+ gst_structure_get_double (structure, "framerate", &smokedec->fps);
+ gst_structure_get_int (structure, "width", &smokedec->width);
+ gst_structure_get_int (structure, "height", &smokedec->height);
+
+ srccaps = gst_caps_new_simple ("video/x-raw-yuv",
+ "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
+ "width", G_TYPE_INT, smokedec->width,
+ "height", G_TYPE_INT, smokedec->height,
+ "framerate", G_TYPE_DOUBLE, smokedec->fps, NULL);
+
+ /* at this point, we're pretty sure that this will be the output
+ * format, so we'll set it. */
+ gst_pad_set_explicit_caps (smokedec->srcpad, srccaps);
+
+ smokecodec_decode_new (&smokedec->info);
+
+ return GST_PAD_LINK_OK;
+}
+
+static void
+gst_smokedec_chain (GstPad * pad, GstData * _data)
+{
+ GstBuffer *buf = GST_BUFFER (_data);
+ GstSmokeDec *smokedec;
+ guchar *data, *outdata;
+ gulong size, outsize;
+ GstBuffer *outbuf;
+ SmokeCodecFlags flags;
+
+ /*GstMeta *meta; */
+ gint width, height;
+
+ smokedec = GST_SMOKEDEC (GST_OBJECT_PARENT (pad));
+
+ if (!GST_PAD_IS_LINKED (smokedec->srcpad)) {
+ gst_buffer_unref (buf);
+ return;
+ }
+
+ data = (guchar *) GST_BUFFER_DATA (buf);
+ size = GST_BUFFER_SIZE (buf);
+ GST_DEBUG ("gst_smokedec_chain: got buffer of %ld bytes in '%s'", size,
+ GST_OBJECT_NAME (smokedec));
+
+ GST_DEBUG ("gst_smokedec_chain: reading header %08lx", *(gulong *) data);
+ smokecodec_parse_header (smokedec->info, data, size, &flags, &width, &height);
+
+ outbuf = gst_buffer_new ();
+ outsize = GST_BUFFER_SIZE (outbuf) = width * height + width * height / 2;
+ outdata = GST_BUFFER_DATA (outbuf) = g_malloc (outsize);
+ GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
+ GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf);
+
+ if (smokedec->height != height) {
+ GstCaps *caps;
+
+ smokedec->height = height;
+
+ 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, smokedec->fps, NULL);
+ gst_pad_set_explicit_caps (smokedec->srcpad, caps);
+ gst_caps_free (caps);
+ }
+
+ smokecodec_decode (smokedec->info, data, size, outdata);
+
+ GST_DEBUG ("gst_smokedec_chain: sending buffer");
+ gst_pad_push (smokedec->srcpad, GST_DATA (outbuf));
+
+ gst_buffer_unref (buf);
+}
--- /dev/null
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_SMOKEDEC_H__
+#define __GST_SMOKEDEC_H__
+
+
+#include <gst/gst.h>
+#include "smokecodec.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_SMOKEDEC \
+ (gst_smokedec_get_type())
+#define GST_SMOKEDEC(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SMOKEDEC,GstSmokeDec))
+#define GST_SMOKEDEC_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SMOKEDEC,GstSmokeDec))
+#define GST_IS_SMOKEDEC(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SMOKEDEC))
+#define GST_IS_SMOKEDEC_CLASS(obj) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SMOKEDEC))
+
+typedef struct _GstSmokeDec GstSmokeDec;
+typedef struct _GstSmokeDecClass GstSmokeDecClass;
+
+struct _GstSmokeDec {
+ GstElement element;
+
+ /* pads */
+ GstPad *sinkpad,*srcpad;
+
+ /* video state */
+ gint format;
+ gint width;
+ gint height;
+ gdouble fps;
+
+ SmokeCodecInfo *info;
+
+ gint threshold;
+ gint quality;
+ gint smoothing;
+};
+
+struct _GstSmokeDecClass {
+ GstElementClass parent_class;
+};
+
+GType gst_smokedec_get_type(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_SMOKEDEC_H__ */
--- /dev/null
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <string.h>
+
+#include "gstsmokeenc.h"
+#include <gst/video/video.h>
+
+/* elementfactory information */
+GstElementDetails gst_smokeenc_details = {
+ "Smoke image encoder",
+ "Codec/Encoder/Image",
+ "Encode images in the Smoke format",
+ "Wim Taymans <wim@fluendo.com>",
+};
+
+GST_DEBUG_CATEGORY (smokeenc_debug);
+#define GST_CAT_DEFAULT smokeenc_debug
+
+#define SMOKEENC_DEFAULT_MIN_QUALITY 10
+#define SMOKEENC_DEFAULT_MAX_QUALITY 85
+#define SMOKEENC_DEFAULT_THRESHOLD 3000
+#define SMOKEENC_DEFAULT_KEYFRAME 20
+
+/* SmokeEnc signals and args */
+enum
+{
+ FRAME_ENCODED,
+ /* FILL ME */
+ LAST_SIGNAL
+};
+
+enum
+{
+ ARG_0,
+ ARG_MIN_QUALITY,
+ ARG_MAX_QUALITY,
+ ARG_THRESHOLD,
+ ARG_KEYFRAME
+ /* FILL ME */
+};
+
+static void gst_smokeenc_base_init (gpointer g_class);
+static void gst_smokeenc_class_init (GstSmokeEnc * klass);
+static void gst_smokeenc_init (GstSmokeEnc * smokeenc);
+
+static void gst_smokeenc_chain (GstPad * pad, GstData * _data);
+static GstPadLinkReturn gst_smokeenc_link (GstPad * pad, const GstCaps * caps);
+static GstCaps *gst_smokeenc_getcaps (GstPad * pad);
+
+static void gst_smokeenc_resync (GstSmokeEnc * smokeenc);
+static void gst_smokeenc_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec);
+static void gst_smokeenc_get_property (GObject * object, guint prop_id,
+ GValue * value, GParamSpec * pspec);
+
+static GstElementClass *parent_class = NULL;
+
+//static guint gst_smokeenc_signals[LAST_SIGNAL] = { 0 };
+
+GType
+gst_smokeenc_get_type (void)
+{
+ static GType smokeenc_type = 0;
+
+ if (!smokeenc_type) {
+ static const GTypeInfo smokeenc_info = {
+ sizeof (GstSmokeEncClass),
+ gst_smokeenc_base_init,
+ NULL,
+ (GClassInitFunc) gst_smokeenc_class_init,
+ NULL,
+ NULL,
+ sizeof (GstSmokeEnc),
+ 0,
+ (GInstanceInitFunc) gst_smokeenc_init,
+ };
+
+ smokeenc_type =
+ g_type_register_static (GST_TYPE_ELEMENT, "GstSmokeEnc", &smokeenc_info,
+ 0);
+ }
+ return smokeenc_type;
+}
+
+static GstStaticPadTemplate gst_smokeenc_sink_pad_template =
+GST_STATIC_PAD_TEMPLATE ("sink",
+ GST_PAD_SINK,
+ GST_PAD_ALWAYS,
+ GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("I420"))
+ );
+
+static GstStaticPadTemplate gst_smokeenc_src_pad_template =
+GST_STATIC_PAD_TEMPLATE ("src",
+ GST_PAD_SRC,
+ GST_PAD_ALWAYS,
+ GST_STATIC_CAPS ("image/x-smoke, "
+ "width = (int) [ 16, 4096 ], "
+ "height = (int) [ 16, 4096 ], " "framerate = (double) [ 1, MAX ]")
+ );
+
+static void
+gst_smokeenc_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_smokeenc_sink_pad_template));
+ gst_element_class_add_pad_template (element_class,
+ gst_static_pad_template_get (&gst_smokeenc_src_pad_template));
+ gst_element_class_set_details (element_class, &gst_smokeenc_details);
+}
+
+static void
+gst_smokeenc_class_init (GstSmokeEnc * klass)
+{
+ GObjectClass *gobject_class;
+ GstElementClass *gstelement_class;
+
+ gobject_class = (GObjectClass *) klass;
+ gstelement_class = (GstElementClass *) klass;
+
+ parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
+
+ g_object_class_install_property (gobject_class, ARG_MIN_QUALITY,
+ g_param_spec_int ("qmin", "Qmin", "Minimum quality",
+ 0, 100, SMOKEENC_DEFAULT_MIN_QUALITY, G_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class, ARG_MAX_QUALITY,
+ g_param_spec_int ("qmax", "Qmax", "Maximum quality",
+ 0, 100, SMOKEENC_DEFAULT_MAX_QUALITY, G_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class, ARG_THRESHOLD,
+ g_param_spec_int ("threshold", "Threshold", "Motion estimation threshold",
+ 0, 100000000, SMOKEENC_DEFAULT_THRESHOLD, G_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class, ARG_KEYFRAME,
+ g_param_spec_int ("keyframe", "Keyframe",
+ "Insert keyframe every N frames", 1, 100000,
+ SMOKEENC_DEFAULT_KEYFRAME, G_PARAM_READWRITE));
+
+ gobject_class->set_property = gst_smokeenc_set_property;
+ gobject_class->get_property = gst_smokeenc_get_property;
+
+ GST_DEBUG_CATEGORY_INIT (smokeenc_debug, "smokeenc", 0,
+ "Smoke encoding element");
+}
+
+static void
+gst_smokeenc_init (GstSmokeEnc * smokeenc)
+{
+ /* create the sink and src pads */
+ smokeenc->sinkpad =
+ gst_pad_new_from_template (gst_static_pad_template_get
+ (&gst_smokeenc_sink_pad_template), "sink");
+ gst_pad_set_chain_function (smokeenc->sinkpad, gst_smokeenc_chain);
+ gst_pad_set_getcaps_function (smokeenc->sinkpad, gst_smokeenc_getcaps);
+ gst_pad_set_link_function (smokeenc->sinkpad, gst_smokeenc_link);
+ gst_element_add_pad (GST_ELEMENT (smokeenc), smokeenc->sinkpad);
+
+ smokeenc->srcpad =
+ gst_pad_new_from_template (gst_static_pad_template_get
+ (&gst_smokeenc_src_pad_template), "src");
+ gst_pad_set_getcaps_function (smokeenc->sinkpad, gst_smokeenc_getcaps);
+ gst_pad_set_link_function (smokeenc->sinkpad, gst_smokeenc_link);
+ gst_element_add_pad (GST_ELEMENT (smokeenc), smokeenc->srcpad);
+
+ /* reset the initial video state */
+ smokeenc->width = 0;
+ smokeenc->height = 0;
+ smokeenc->frame = 0;
+
+ gst_smokeenc_resync (smokeenc);
+
+ smokeenc->min_quality = SMOKEENC_DEFAULT_MIN_QUALITY;
+ smokeenc->max_quality = SMOKEENC_DEFAULT_MAX_QUALITY;
+ smokeenc->threshold = SMOKEENC_DEFAULT_THRESHOLD;
+ smokeenc->keyframe = SMOKEENC_DEFAULT_KEYFRAME;
+}
+
+static GstCaps *
+gst_smokeenc_getcaps (GstPad * pad)
+{
+ GstSmokeEnc *smokeenc = GST_SMOKEENC (gst_pad_get_parent (pad));
+ GstPad *otherpad;
+ GstCaps *caps;
+ const char *name;
+ int i;
+ GstStructure *structure = NULL;
+
+ /* we want to proxy properties like width, height and framerate from the
+ other end of the element */
+ otherpad = (pad == smokeenc->srcpad) ? smokeenc->sinkpad : smokeenc->srcpad;
+ caps = gst_pad_get_allowed_caps (otherpad);
+ if (pad == smokeenc->srcpad) {
+ name = "image/x-smoke";
+ } else {
+ name = "video/x-raw-yuv";
+ }
+ for (i = 0; i < gst_caps_get_size (caps); i++) {
+ structure = gst_caps_get_structure (caps, i);
+
+ gst_structure_set_name (structure, name);
+ gst_structure_remove_field (structure, "format");
+ /* ... but for the sink pad, we only do I420 anyway, so add that */
+ if (pad == smokeenc->sinkpad) {
+ gst_structure_set (structure, "format", GST_TYPE_FOURCC,
+ GST_STR_FOURCC ("I420"), NULL);
+ }
+ }
+
+ return caps;
+}
+
+static GstPadLinkReturn
+gst_smokeenc_link (GstPad * pad, const GstCaps * caps)
+{
+ GstSmokeEnc *smokeenc = GST_SMOKEENC (gst_pad_get_parent (pad));
+ GstStructure *structure;
+ GstPadLinkReturn ret;
+ GstCaps *othercaps;
+ GstPad *otherpad;
+
+ otherpad = (pad == smokeenc->srcpad) ? smokeenc->sinkpad : smokeenc->srcpad;
+
+ structure = gst_caps_get_structure (caps, 0);
+ gst_structure_get_double (structure, "framerate", &smokeenc->fps);
+ gst_structure_get_int (structure, "width", &smokeenc->width);
+ gst_structure_get_int (structure, "height", &smokeenc->height);
+
+ othercaps = gst_caps_copy (gst_pad_get_pad_template_caps (otherpad));
+ gst_caps_set_simple (othercaps,
+ "width", G_TYPE_INT, smokeenc->width,
+ "height", G_TYPE_INT, smokeenc->height,
+ "framerate", G_TYPE_DOUBLE, smokeenc->fps, NULL);
+
+ ret = gst_pad_try_set_caps (smokeenc->srcpad, othercaps);
+ gst_caps_free (othercaps);
+
+ if (GST_PAD_LINK_SUCCESSFUL (ret)) {
+ gst_smokeenc_resync (smokeenc);
+ }
+
+ return ret;
+}
+
+static void
+gst_smokeenc_resync (GstSmokeEnc * smokeenc)
+{
+ GST_DEBUG ("gst_smokeenc_resync: resync");
+
+ smokecodec_encode_new (&smokeenc->info, smokeenc->width, smokeenc->height);
+ smokecodec_set_quality (smokeenc->info, smokeenc->min_quality,
+ smokeenc->max_quality);
+
+ GST_DEBUG ("gst_smokeenc_resync: resync done");
+}
+
+static void
+gst_smokeenc_chain (GstPad * pad, GstData * _data)
+{
+ GstBuffer *buf = GST_BUFFER (_data);
+ GstSmokeEnc *smokeenc;
+ guchar *data, *outdata;
+ gulong size;
+ gint outsize, encsize;
+ GstBuffer *outbuf;
+ SmokeCodecFlags flags;
+
+ smokeenc = GST_SMOKEENC (GST_OBJECT_PARENT (pad));
+
+ data = GST_BUFFER_DATA (buf);
+ size = GST_BUFFER_SIZE (buf);
+
+ GST_DEBUG ("gst_smokeenc_chain: got buffer of %ld bytes in '%s'", size,
+ GST_OBJECT_NAME (smokeenc));
+
+ outbuf = gst_buffer_new ();
+ outsize = smokeenc->width * smokeenc->height * 3;
+ outdata = GST_BUFFER_DATA (outbuf) = g_malloc (outsize);
+ GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
+ GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf);
+
+ flags = 0;
+ if (smokeenc->frame == 0) {
+ flags |= SMOKECODEC_KEYFRAME;
+ }
+
+ smokeenc->frame = (smokeenc->frame + 1) % smokeenc->keyframe;
+
+ smokecodec_set_quality (smokeenc->info, smokeenc->min_quality,
+ smokeenc->max_quality);
+ smokecodec_set_threshold (smokeenc->info, smokeenc->threshold);
+ smokecodec_encode (smokeenc->info, data, flags, outdata, &encsize);
+ gst_buffer_unref (buf);
+
+ GST_BUFFER_SIZE (outbuf) = encsize;
+ //memset(GST_BUFFER_DATA(outbuf)+encsize, 0, outsize - encsize);
+
+ gst_pad_push (smokeenc->srcpad, GST_DATA (outbuf));
+}
+
+static void
+gst_smokeenc_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec)
+{
+ GstSmokeEnc *smokeenc;
+
+ g_return_if_fail (GST_IS_SMOKEENC (object));
+ smokeenc = GST_SMOKEENC (object);
+
+ switch (prop_id) {
+ case ARG_MIN_QUALITY:
+ smokeenc->min_quality = g_value_get_int (value);
+ break;
+ case ARG_MAX_QUALITY:
+ smokeenc->max_quality = g_value_get_int (value);
+ break;
+ case ARG_THRESHOLD:
+ smokeenc->threshold = g_value_get_int (value);
+ break;
+ case ARG_KEYFRAME:
+ smokeenc->keyframe = g_value_get_int (value);
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gst_smokeenc_get_property (GObject * object, guint prop_id, GValue * value,
+ GParamSpec * pspec)
+{
+ GstSmokeEnc *smokeenc;
+
+ g_return_if_fail (GST_IS_SMOKEENC (object));
+ smokeenc = GST_SMOKEENC (object);
+
+ switch (prop_id) {
+ case ARG_MIN_QUALITY:
+ g_value_set_int (value, smokeenc->min_quality);
+ break;
+ case ARG_MAX_QUALITY:
+ g_value_set_int (value, smokeenc->max_quality);
+ break;
+ case ARG_THRESHOLD:
+ g_value_set_int (value, smokeenc->threshold);
+ break;
+ case ARG_KEYFRAME:
+ g_value_set_int (value, smokeenc->keyframe);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
--- /dev/null
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_SMOKEENC_H__
+#define __GST_SMOKEENC_H__
+
+
+#include <gst/gst.h>
+#include "smokecodec.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_SMOKEENC \
+ (gst_smokeenc_get_type())
+#define GST_SMOKEENC(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SMOKEENC,GstSmokeEnc))
+#define GST_SMOKEENC_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SMOKEENC,GstSmokeEnc))
+#define GST_IS_SMOKEENC(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SMOKEENC))
+#define GST_IS_SMOKEENC_CLASS(obj) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SMOKEENC))
+
+typedef struct _GstSmokeEnc GstSmokeEnc;
+typedef struct _GstSmokeEncClass GstSmokeEncClass;
+
+struct _GstSmokeEnc {
+ GstElement element;
+
+ /* pads */
+ GstPad *sinkpad,*srcpad;
+
+ /* video state */
+ gint format;
+ gint width;
+ gint height;
+ gint frame;
+ gint keyframe;
+ gdouble fps;
+
+ SmokeCodecInfo *info;
+
+ gint threshold;
+ gint min_quality;
+ gint max_quality;
+};
+
+struct _GstSmokeEncClass {
+ GstElementClass parent_class;
+};
+
+GType gst_smokeenc_get_type(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_SMOKEENC_H__ */
--- /dev/null
+/* Smoke codec
+ * Copyright (C) <2004> Wim Taymans <wim@fluendo.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.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>
+
+#include "smokecodec.h"
+
+//#define DEBUG(a...) printf( a );
+#define DEBUG(a,...)
+
+
+struct _SmokeCodecInfo
+{
+ unsigned int width;
+ unsigned int height;
+
+ unsigned int minquality;
+ unsigned int maxquality;
+ unsigned int bitrate;
+ unsigned int threshold;
+
+ unsigned int refdec;
+
+ unsigned char **line[3];
+ unsigned char *compbuf[3];
+
+ struct jpeg_error_mgr jerr;
+
+ struct jpeg_compress_struct cinfo;
+ struct jpeg_destination_mgr jdest;
+
+ struct jpeg_decompress_struct dinfo;
+ struct jpeg_source_mgr jsrc;
+
+ int need_keyframe;
+ unsigned char *reference;
+};
+
+static void
+smokecodec_init_destination (j_compress_ptr cinfo)
+{
+}
+
+static int
+smokecodec_flush_destination (j_compress_ptr cinfo)
+{
+ return 1;
+}
+
+static void
+smokecodec_term_destination (j_compress_ptr cinfo)
+{
+}
+
+static void
+smokecodec_init_source (j_decompress_ptr cinfo)
+{
+}
+
+static int
+smokecodec_fill_input_buffer (j_decompress_ptr cinfo)
+{
+ return 1;
+}
+
+static void
+smokecodec_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
+}
+
+static int
+smokecodec_resync_to_restart (j_decompress_ptr cinfo, int desired)
+{
+ return 1;
+}
+
+static void
+smokecodec_term_source (j_decompress_ptr cinfo)
+{
+}
+
+
+int
+smokecodec_encode_new (SmokeCodecInfo ** info,
+ const unsigned int width, const unsigned int height)
+{
+ SmokeCodecInfo *newinfo;
+ int i, j;
+ unsigned char *base[3];
+
+ if (!info)
+ return SMOKECODEC_NULLPTR;
+ if ((width & 0xf) || (height & 0xf))
+ return SMOKECODEC_WRONGSIZE;
+
+ newinfo = malloc (sizeof (SmokeCodecInfo));
+ if (!newinfo) {
+ return SMOKECODEC_NOMEM;
+ }
+ newinfo->width = width;
+ newinfo->height = height;
+
+ /* setup jpeglib */
+ memset (&newinfo->cinfo, 0, sizeof (newinfo->cinfo));
+ memset (&newinfo->jerr, 0, sizeof (newinfo->jerr));
+ newinfo->cinfo.err = jpeg_std_error (&newinfo->jerr);
+ jpeg_create_compress (&newinfo->cinfo);
+ newinfo->cinfo.input_components = 3;
+ jpeg_set_defaults (&newinfo->cinfo);
+
+ newinfo->cinfo.dct_method = JDCT_FASTEST;
+
+ newinfo->cinfo.raw_data_in = TRUE;
+ newinfo->cinfo.in_color_space = JCS_YCbCr;
+ newinfo->cinfo.comp_info[0].h_samp_factor = 2;
+ newinfo->cinfo.comp_info[0].v_samp_factor = 2;
+ newinfo->cinfo.comp_info[1].h_samp_factor = 1;
+ newinfo->cinfo.comp_info[1].v_samp_factor = 1;
+ newinfo->cinfo.comp_info[2].h_samp_factor = 1;
+ newinfo->cinfo.comp_info[2].v_samp_factor = 1;
+
+ newinfo->line[0] = malloc (DCTSIZE * 2 * sizeof (char *));
+ newinfo->line[1] = malloc (DCTSIZE * sizeof (char *));
+ newinfo->line[2] = malloc (DCTSIZE * sizeof (char *));
+ base[0] = newinfo->compbuf[0] = malloc (256 * 2 * DCTSIZE * 2 * DCTSIZE);
+ base[1] = newinfo->compbuf[1] = malloc (256 * DCTSIZE * DCTSIZE);
+ base[2] = newinfo->compbuf[2] = malloc (256 * DCTSIZE * DCTSIZE);
+
+ for (i = 0, j = 0; i < 2 * DCTSIZE; i += 2, j++) {
+ newinfo->line[0][i] = base[0];
+ base[0] += 2 * DCTSIZE * 256;
+ newinfo->line[0][i + 1] = base[0];
+ base[0] += 2 * DCTSIZE * 256;
+ newinfo->line[1][j] = base[1];
+ base[1] += DCTSIZE * 256;
+ newinfo->line[2][j] = base[2];
+ base[2] += DCTSIZE * 256;
+ }
+
+ newinfo->jdest.init_destination = smokecodec_init_destination;
+ newinfo->jdest.empty_output_buffer = smokecodec_flush_destination;
+ newinfo->jdest.term_destination = smokecodec_term_destination;
+ newinfo->cinfo.dest = &newinfo->jdest;
+
+ jpeg_suppress_tables (&newinfo->cinfo, FALSE);
+
+ memset (&newinfo->dinfo, 0, sizeof (newinfo->dinfo));
+ newinfo->dinfo.err = jpeg_std_error (&newinfo->jerr);
+ jpeg_create_decompress (&newinfo->dinfo);
+
+ newinfo->jsrc.init_source = smokecodec_init_source;
+ newinfo->jsrc.fill_input_buffer = smokecodec_fill_input_buffer;
+ newinfo->jsrc.skip_input_data = smokecodec_skip_input_data;
+ newinfo->jsrc.resync_to_restart = smokecodec_resync_to_restart;
+ newinfo->jsrc.term_source = smokecodec_term_source;
+ newinfo->dinfo.src = &newinfo->jsrc;
+
+ newinfo->need_keyframe = 1;
+ newinfo->threshold = 4000;
+ newinfo->minquality = 10;
+ newinfo->maxquality = 85;
+ newinfo->reference = malloc (3 * (width * height) / 2);
+ newinfo->refdec = 0;
+
+ *info = newinfo;
+
+ return SMOKECODEC_OK;
+}
+
+int
+smokecodec_decode_new (SmokeCodecInfo ** info)
+{
+ return smokecodec_encode_new (info, 16, 16);
+}
+
+int
+smokecodec_info_free (SmokeCodecInfo * info)
+{
+ free (info->line[0]);
+ free (info->line[1]);
+ free (info->line[2]);
+ free (info->compbuf[0]);
+ free (info->compbuf[1]);
+ free (info->compbuf[2]);
+ free (info->reference);
+ jpeg_destroy_compress (&info->cinfo);
+ jpeg_destroy_decompress (&info->dinfo);
+ free (info);
+
+ return SMOKECODEC_OK;
+}
+
+SmokeCodecResult
+smokecodec_set_quality (SmokeCodecInfo * info,
+ const unsigned int min, const unsigned int max)
+{
+ info->minquality = min;
+ info->maxquality = max;
+
+ return SMOKECODEC_OK;
+}
+
+SmokeCodecResult
+smokecodec_get_quality (SmokeCodecInfo * info,
+ unsigned int *min, unsigned int *max)
+{
+ *min = info->minquality;
+ *max = info->maxquality;
+
+ return SMOKECODEC_OK;
+}
+
+SmokeCodecResult
+smokecodec_set_threshold (SmokeCodecInfo * info, const unsigned int threshold)
+{
+ info->threshold = threshold;
+
+ return SMOKECODEC_OK;
+}
+
+SmokeCodecResult
+smokecodec_get_threshold (SmokeCodecInfo * info, unsigned int *threshold)
+{
+ *threshold = info->threshold;
+
+ return SMOKECODEC_OK;
+}
+
+SmokeCodecResult
+smokecodec_set_bitrate (SmokeCodecInfo * info, const unsigned int bitrate)
+{
+ info->bitrate = bitrate;
+
+ return SMOKECODEC_OK;
+}
+
+SmokeCodecResult
+smokecodec_get_bitrate (SmokeCodecInfo * info, unsigned int *bitrate)
+{
+ *bitrate = info->bitrate;
+
+ return SMOKECODEC_OK;
+}
+
+static void
+find_best_size (int blocks, int *width, int *height)
+{
+ int sqchng;
+ int w, h;
+ int best, bestw;
+ int free;
+
+ sqchng = ceil (sqrt (blocks));
+ w = sqchng;
+ h = sqchng;
+
+ DEBUG ("guess: %d %d\n", w, h);
+
+ free = w * h - blocks;
+ best = free;
+ bestw = w;
+
+ while (w < 256) {
+ DEBUG ("current: %d %d\n", w, h);
+ if (free < best) {
+ best = free;
+ bestw = w;
+ if (free == 0)
+ break;
+ }
+ // if we cannot reduce the height, increase width
+ if (free < w) {
+ w++;
+ free += h;
+ }
+ // reduce height while possible
+ while (free >= w) {
+ h--;
+ free -= w;
+ }
+ }
+ *width = bestw;
+ *height = (blocks + best) / bestw;
+}
+
+static int
+abs_diff (const unsigned char *in1, const unsigned char *in2, const int stride)
+{
+ int s;
+ int i, j, diff;
+
+ s = 0;
+
+ for (i = 0; i < 2 * DCTSIZE; i++) {
+ for (j = 0; j < 2 * DCTSIZE; j++) {
+ diff = in1[j] - in2[j];
+ s += diff * diff;
+ }
+ in1 += stride;
+ in2 += stride;
+ }
+ return s;
+}
+
+static void
+put (const unsigned char *src, unsigned char *dest,
+ int width, int height, int srcstride, int deststride)
+{
+ int i, j;
+
+ for (i = 0; i < height; i++) {
+ for (j = 0; j < width; j++) {
+ dest[j] = src[j];
+ }
+ src += srcstride;
+ dest += deststride;
+ }
+}
+
+/* encoding */
+SmokeCodecResult
+smokecodec_encode (SmokeCodecInfo * info,
+ const unsigned char *in,
+ SmokeCodecFlags flags, unsigned char *out, unsigned int *outsize)
+{
+ unsigned int i, j, s;
+ const unsigned char *ip;
+ unsigned char *op;
+ unsigned int blocks, encoding;
+ unsigned int size;
+ unsigned int width, height;
+ unsigned int blocks_w, blocks_h;
+ unsigned int threshold;
+ unsigned int max;
+
+ if (info->need_keyframe) {
+ flags |= SMOKECODEC_KEYFRAME;
+ info->need_keyframe = 0;
+ }
+
+ if (flags & SMOKECODEC_KEYFRAME)
+ threshold = 0;
+ else
+ threshold = info->threshold;
+
+ ip = in;
+ op = info->reference;
+
+ width = info->width;
+ height = info->height;
+
+ blocks_w = width / (DCTSIZE * 2);
+ blocks_h = height / (DCTSIZE * 2);
+
+ max = blocks_w * blocks_h;
+
+#define STORE16(var, pos, x) \
+ var[pos] = (x >> 8); \
+ var[pos+1] = (x & 0xff);
+
+ /* write dimension */
+ STORE16 (out, 0, width);
+ STORE16 (out, 2, height);
+
+ if (!(flags & SMOKECODEC_KEYFRAME)) {
+ int block = 0;
+
+ blocks = 0;
+ for (i = 0; i < height; i += 2 * DCTSIZE) {
+ for (j = 0; j < width; j += 2 * DCTSIZE) {
+ s = abs_diff (ip, op, width);
+ if (s >= threshold) {
+ STORE16 (out, blocks * 2 + 10, block);
+ blocks++;
+ }
+
+ ip += 2 * DCTSIZE;
+ op += 2 * DCTSIZE;
+ block++;
+ }
+ ip += (2 * DCTSIZE - 1) * width;
+ op += (2 * DCTSIZE - 1) * width;
+ }
+ if (blocks == max) {
+ flags |= SMOKECODEC_KEYFRAME;
+ blocks = 0;
+ encoding = max;
+ } else {
+ encoding = blocks;
+ }
+ } else {
+ blocks = 0;
+ encoding = max;
+ }
+ STORE16 (out, 6, blocks);
+ out[4] = (flags & 0xff);
+
+ DEBUG ("blocks %d, encoding %d\n", blocks, encoding);
+
+ info->jdest.next_output_byte = &out[blocks * 2 + 12];
+ info->jdest.free_in_buffer = (*outsize) - 12;
+
+ if (encoding > 0) {
+ int quality;
+
+ if (!(flags & SMOKECODEC_KEYFRAME))
+ find_best_size (encoding, &blocks_w, &blocks_h);
+
+ DEBUG ("best: %d %d\n", blocks_w, blocks_h);
+
+ info->cinfo.image_width = blocks_w * DCTSIZE * 2;
+ info->cinfo.image_height = blocks_h * DCTSIZE * 2;
+
+ if (flags & SMOKECODEC_KEYFRAME) {
+ quality = (info->maxquality * 60) / 100;
+ } else {
+ quality =
+ info->maxquality - ((info->maxquality -
+ info->minquality) * blocks) / max;
+ }
+
+ DEBUG ("set q %d %d %d\n", quality, encoding, max);
+ jpeg_set_quality (&info->cinfo, quality, TRUE);
+ DEBUG ("start\n");
+ jpeg_start_compress (&info->cinfo, TRUE);
+
+ for (i = 0; i < encoding; i++) {
+ int pos;
+ int x, y;
+
+ if (flags & SMOKECODEC_KEYFRAME)
+ pos = i;
+ else
+ pos = (out[i * 2 + 10] << 8) | (out[i * 2 + 11]);
+
+ x = pos % (width / (DCTSIZE * 2));
+ y = pos / (width / (DCTSIZE * 2));
+
+ ip = in + (x * (DCTSIZE * 2)) + (y * (DCTSIZE * 2) * width);
+ op = info->compbuf[0] + (i % blocks_w) * (DCTSIZE * 2);
+ put (ip, op, 2 * DCTSIZE, 2 * DCTSIZE, width, 256 * (DCTSIZE * 2));
+
+ ip = in + width * height + (x * DCTSIZE) + (y * DCTSIZE * width / 2);
+ op = info->compbuf[1] + (i % blocks_w) * (DCTSIZE);
+ put (ip, op, DCTSIZE, DCTSIZE, width / 2, 256 * DCTSIZE);
+
+ ip = in + 5 * (width * height) / 4 + (x * DCTSIZE) +
+ (y * DCTSIZE * width / 2);
+ op = info->compbuf[2] + (i % blocks_w) * (DCTSIZE);
+ put (ip, op, DCTSIZE, DCTSIZE, width / 2, 256 * DCTSIZE);
+
+ if ((i % blocks_w) == (blocks_w - 1) || (i == encoding - 1)) {
+ DEBUG ("write %d\n", pos);
+ jpeg_write_raw_data (&info->cinfo, info->line, 2 * DCTSIZE);
+ }
+ }
+ DEBUG ("finish\n");
+ jpeg_finish_compress (&info->cinfo);
+ }
+
+ size = ((((*outsize) - 12 - info->jdest.free_in_buffer) + 3) & ~3);
+ out[8] = size >> 8;
+ out[9] = size & 0xff;
+
+ *outsize = size + blocks * 2 + 12;
+ DEBUG ("outsize %d\n", *outsize);
+
+ // and decode in reference frame again
+ if (info->refdec) {
+ smokecodec_decode (info, out, *outsize, info->reference);
+ } else {
+ memcpy (info->reference, in, 3 * (width * height) / 2);
+ }
+
+ return SMOKECODEC_OK;
+}
+
+/* decoding */
+SmokeCodecResult
+smokecodec_parse_header (SmokeCodecInfo * info,
+ const unsigned char *in,
+ const unsigned int insize,
+ SmokeCodecFlags * flags, unsigned int *width, unsigned int *height)
+{
+
+ *width = in[0] << 8 | in[1];
+ *height = in[2] << 8 | in[3];
+ *flags = in[4];
+
+ if (info->width != *width || info->height != *height) {
+ DEBUG ("new width: %d %d\n", *width, *height);
+
+ info->reference = realloc (info->reference, 3 * ((*width) * (*height)) / 2);
+ info->width = *width;
+ info->height = *height;
+ }
+
+ return SMOKECODEC_OK;
+}
+
+SmokeCodecResult
+smokecodec_decode (SmokeCodecInfo * info,
+ const unsigned char *in, const unsigned int insize, unsigned char *out)
+{
+ unsigned int width, height;
+ SmokeCodecFlags flags;
+ int i, j;
+ int blocks_w, blocks_h;
+ int blockptr;
+ int blocks, decoding;
+ const unsigned char *ip;
+ unsigned char *op;
+ int res;
+
+ smokecodec_parse_header (info, in, insize, &flags, &width, &height);
+
+ blocks = in[6] << 8 | in[7];
+ DEBUG ("blocks %d\n", blocks);
+
+ if (flags & SMOKECODEC_KEYFRAME)
+ decoding = width / (DCTSIZE * 2) * height / (DCTSIZE * 2);
+ else
+ decoding = blocks;
+
+
+ if (decoding > 0) {
+ info->jsrc.next_input_byte = &in[blocks * 2 + 12];
+ info->jsrc.bytes_in_buffer = insize - (blocks * 2 + 12);
+
+ DEBUG ("header %02x %d\n", in[blocks * 2 + 12], insize);
+ res = jpeg_read_header (&info->dinfo, TRUE);
+ DEBUG ("header %d %d %d\n", res, info->dinfo.image_width,
+ info->dinfo.image_height);
+
+ blocks_w = info->dinfo.image_width / (2 * DCTSIZE);
+ blocks_h = info->dinfo.image_height / (2 * DCTSIZE);
+
+ info->dinfo.output_width = info->dinfo.image_width;
+ info->dinfo.output_height = info->dinfo.image_height;
+
+ DEBUG ("start\n");
+ info->dinfo.do_fancy_upsampling = FALSE;
+ info->dinfo.do_block_smoothing = FALSE;
+ info->dinfo.out_color_space = JCS_YCbCr;
+ info->dinfo.dct_method = JDCT_IFAST;
+ info->dinfo.raw_data_out = TRUE;
+ jpeg_start_decompress (&info->dinfo);
+
+ blockptr = 0;
+
+ for (i = 0; i < blocks_h; i++) {
+ DEBUG ("read\n");
+ jpeg_read_raw_data (&info->dinfo, info->line, 2 * DCTSIZE);
+
+ DEBUG ("copy %d\n", blocks_w);
+ for (j = 0; j < blocks_w; j++) {
+ int pos;
+ int x, y;
+
+ if (flags & SMOKECODEC_KEYFRAME)
+ pos = blockptr;
+ else
+ pos = (in[blockptr * 2 + 10] << 8) | (in[blockptr * 2 + 11]);
+
+ x = pos % (width / (DCTSIZE * 2));
+ y = pos / (width / (DCTSIZE * 2));
+
+ DEBUG ("block %d %d %d\n", pos, x, y);
+
+ ip = info->compbuf[0] + j * (DCTSIZE * 2);
+ op = info->reference + (x * (DCTSIZE * 2)) +
+ (y * (DCTSIZE * 2) * width);
+ put (ip, op, 2 * DCTSIZE, 2 * DCTSIZE, 256 * (DCTSIZE * 2), width);
+
+ ip = info->compbuf[1] + j * (DCTSIZE);
+ op = info->reference + width * height + (x * DCTSIZE) +
+ (y * DCTSIZE * width / 2);
+ put (ip, op, DCTSIZE, DCTSIZE, 256 * DCTSIZE, width / 2);
+
+ ip = info->compbuf[2] + j * (DCTSIZE);
+ op = info->reference + 5 * (width * height) / 4 + (x * DCTSIZE) +
+ (y * DCTSIZE * width / 2);
+ put (ip, op, DCTSIZE, DCTSIZE, 256 * DCTSIZE, width / 2);
+
+ DEBUG ("block done %d %d %d\n", pos, x, y);
+ blockptr++;
+ if (blockptr >= decoding)
+ break;
+ }
+ }
+ DEBUG ("finish\n");
+ jpeg_finish_decompress (&info->dinfo);
+ }
+
+ DEBUG ("copy\n");
+ if (out != info->reference)
+ memcpy (out, info->reference, 3 * (width * height) / 2);
+ DEBUG ("copy done\n");
+
+ return SMOKECODEC_OK;
+}
--- /dev/null
+/* Smoke Codec
+ * Copyright (C) <2004> Wim Taymans <wim@fluendo.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __SMOKECODEC_H__
+#define __SMOKECODEC_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+typedef struct _SmokeCodecInfo SmokeCodecInfo;
+
+typedef enum {
+ SMOKECODEC_WRONGSIZE = -4,
+ SMOKECODEC_ERROR = -3,
+ SMOKECODEC_NOMEM = -2,
+ SMOKECODEC_NULLPTR = -1,
+ SMOKECODEC_OK = 0,
+} SmokeCodecResult;
+
+typedef enum {
+ SMOKECODEC_KEYFRAME = (1<<0),
+ SMOKECODEC_MOTION_VECTORS = (1<<1)
+} SmokeCodecFlags;
+
+
+/* init */
+int smokecodec_encode_new (SmokeCodecInfo **info,
+ const unsigned int width,
+ const unsigned int height);
+
+int smokecodec_decode_new (SmokeCodecInfo **info);
+
+/* config */
+SmokeCodecResult smokecodec_set_quality (SmokeCodecInfo *info,
+ const unsigned int min,
+ const unsigned int max);
+SmokeCodecResult smokecodec_get_quality (SmokeCodecInfo *info,
+ unsigned int *min,
+ unsigned int *max);
+
+SmokeCodecResult smokecodec_set_threshold (SmokeCodecInfo *info,
+ const unsigned int threshold);
+SmokeCodecResult smokecodec_get_threshold (SmokeCodecInfo *info,
+ unsigned int *threshold);
+
+SmokeCodecResult smokecodec_set_bitrate (SmokeCodecInfo *info,
+ const unsigned int bitrate);
+SmokeCodecResult smokecodec_get_bitrate (SmokeCodecInfo *info,
+ unsigned int *bitrate);
+
+/* encoding */
+SmokeCodecResult smokecodec_encode (SmokeCodecInfo *info,
+ const unsigned char *in,
+ SmokeCodecFlags flags,
+ unsigned char *out,
+ unsigned int *outsize);
+
+/* decoding */
+SmokeCodecResult smokecodec_parse_header (SmokeCodecInfo *info,
+ const unsigned char *in,
+ const unsigned int insize,
+ SmokeCodecFlags *flags,
+ unsigned int *width,
+ unsigned int *height);
+
+SmokeCodecResult smokecodec_decode (SmokeCodecInfo *info,
+ const unsigned char *in,
+ const unsigned int insize,
+ unsigned char *out);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __SMOKECODEC_H__ */
projects / platform / upstream / gst-plugins-good.git / commitdiff