ext/jpeg/gstjpegenc.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 /**
  20  * SECTION:element-jpegenc
  21  *
  22  * Encodes jpeg images.
  23  *
  24  * <refsect2>
  25  * <title>Example launch line</title>
  26  * |[
  27  * gst-launch videotestsrc num-buffers=50 ! video/x-raw-yuv, framerate='(fraction)'5/1 ! jpegenc ! avimux ! filesink location=mjpeg.avi
  28  * ]| a pipeline to mux 5 JPEG frames per second into a 10 sec. long motion jpeg
  29  * avi.
  30  * </refsect2>
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36 #include <string.h>
  37
  38 #include "gstjpegenc.h"
  39 #include "gstjpeg.h"
  40 #include <gst/video/video.h>
  41
  42 /* experimental */
  43 /* setting smoothig seems to have no effect in libjepeg
  44 #define ENABLE_SMOOTHING 1
  45 */
  46
  47 GST_DEBUG_CATEGORY_STATIC (jpegenc_debug);
  48 #define GST_CAT_DEFAULT jpegenc_debug
  49
  50 #define JPEG_DEFAULT_QUALITY 85
  51 #define JPEG_DEFAULT_SMOOTHING 0
  52 #define JPEG_DEFAULT_IDCT_METHOD        JDCT_FASTEST
  53
  54 /* JpegEnc signals and args */
  55 enum
  56 {
  57   FRAME_ENCODED,
  58   /* FILL ME */
  59   LAST_SIGNAL
  60 };
  61
  62 enum
  63 {
  64   PROP_0,
  65   PROP_QUALITY,
  66   PROP_SMOOTHING,
  67   PROP_IDCT_METHOD
  68 };
  69
  70 static void gst_jpegenc_reset (GstJpegEnc * enc);
  71 static void gst_jpegenc_base_init (gpointer g_class);
  72 static void gst_jpegenc_class_init (GstJpegEnc * klass);
  73 static void gst_jpegenc_init (GstJpegEnc * jpegenc);
  74 static void gst_jpegenc_finalize (GObject * object);
  75
  76 static GstFlowReturn gst_jpegenc_chain (GstPad * pad, GstBuffer * buf);
  77 static gboolean gst_jpegenc_setcaps (GstPad * pad, GstCaps * caps);
  78 static GstCaps *gst_jpegenc_getcaps (GstPad * pad);
  79
  80 static void gst_jpegenc_resync (GstJpegEnc * jpegenc);
  81 static void gst_jpegenc_set_property (GObject * object, guint prop_id,
  82     const GValue * value, GParamSpec * pspec);
  83 static void gst_jpegenc_get_property (GObject * object, guint prop_id,
  84     GValue * value, GParamSpec * pspec);
  85 static GstStateChangeReturn gst_jpegenc_change_state (GstElement * element,
  86     GstStateChange transition);
  87
  88
  89 static GstElementClass *parent_class = NULL;
  90 static guint gst_jpegenc_signals[LAST_SIGNAL] = { 0 };
  91
  92 GType
  93 gst_jpegenc_get_type (void)
  94 {
  95   static GType jpegenc_type = 0;
  96
  97   if (!jpegenc_type) {
  98     static const GTypeInfo jpegenc_info = {
  99       sizeof (GstJpegEnc),
 100       (GBaseInitFunc) gst_jpegenc_base_init,
 101       NULL,
 102       (GClassInitFunc) gst_jpegenc_class_init,
 103       NULL,
 104       NULL,
 105       sizeof (GstJpegEnc),
 106       0,
 107       (GInstanceInitFunc) gst_jpegenc_init,
 108     };
 109
 110     jpegenc_type =
 111         g_type_register_static (GST_TYPE_ELEMENT, "GstJpegEnc", &jpegenc_info,
 112         0);
 113   }
 114   return jpegenc_type;
 115 }
 116
 117 /* *INDENT-OFF* */
 118 static GstStaticPadTemplate gst_jpegenc_sink_pad_template =
 119 GST_STATIC_PAD_TEMPLATE ("sink",
 120     GST_PAD_SINK,
 121     GST_PAD_ALWAYS,
 122     GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV
 123         ("{ I420, YV12, YUY2, UYVY, Y41B, Y42B, YVYU, Y444 }") "; "
 124         GST_VIDEO_CAPS_RGB "; " GST_VIDEO_CAPS_BGR "; "
 125         GST_VIDEO_CAPS_RGBx "; " GST_VIDEO_CAPS_xRGB "; "
 126         GST_VIDEO_CAPS_BGRx "; " GST_VIDEO_CAPS_xBGR "; "
 127         GST_VIDEO_CAPS_GRAY8)
 128     );
 129 /* *INDENT-ON* */
 130
 131 static GstStaticPadTemplate gst_jpegenc_src_pad_template =
 132 GST_STATIC_PAD_TEMPLATE ("src",
 133     GST_PAD_SRC,
 134     GST_PAD_ALWAYS,
 135     GST_STATIC_CAPS ("image/jpeg, "
 136         "width = (int) [ 16, 65535 ], "
 137         "height = (int) [ 16, 65535 ], " "framerate = (fraction) [ 0/1, MAX ]")
 138     );
 139
 140 static void
 141 gst_jpegenc_base_init (gpointer g_class)
 142 {
 143   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 144
 145   gst_element_class_add_pad_template (element_class,
 146       gst_static_pad_template_get (&gst_jpegenc_sink_pad_template));
 147   gst_element_class_add_pad_template (element_class,
 148       gst_static_pad_template_get (&gst_jpegenc_src_pad_template));
 149   gst_element_class_set_details_simple (element_class, "JPEG image encoder",
 150       "Codec/Encoder/Image",
 151       "Encode images in JPEG format", "Wim Taymans <wim.taymans@tvd.be>");
 152 }
 153
 154 static void
 155 gst_jpegenc_class_init (GstJpegEnc * klass)
 156 {
 157   GObjectClass *gobject_class;
 158   GstElementClass *gstelement_class;
 159
 160   gobject_class = (GObjectClass *) klass;
 161   gstelement_class = (GstElementClass *) klass;
 162
 163   parent_class = g_type_class_peek_parent (klass);
 164
 165   gst_jpegenc_signals[FRAME_ENCODED] =
 166       g_signal_new ("frame-encoded", G_TYPE_FROM_CLASS (klass),
 167       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstJpegEncClass, frame_encoded), NULL,
 168       NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 169
 170   gobject_class->set_property = gst_jpegenc_set_property;
 171   gobject_class->get_property = gst_jpegenc_get_property;
 172
 173
 174   g_object_class_install_property (gobject_class, PROP_QUALITY,
 175       g_param_spec_int ("quality", "Quality", "Quality of encoding",
 176           0, 100, JPEG_DEFAULT_QUALITY,
 177           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 178
 179 #ifdef ENABLE_SMOOTHING
 180   /* disabled, since it doesn't seem to work */
 181   g_object_class_install_property (gobject_class, PROP_SMOOTHING,
 182       g_param_spec_int ("smoothing", "Smoothing", "Smoothing factor",
 183           0, 100, JPEG_DEFAULT_SMOOTHING,
 184           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 185 #endif
 186
 187   g_object_class_install_property (gobject_class, PROP_IDCT_METHOD,
 188       g_param_spec_enum ("idct-method", "IDCT Method",
 189           "The IDCT algorithm to use", GST_TYPE_IDCT_METHOD,
 190           JPEG_DEFAULT_IDCT_METHOD,
 191           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 192
 193   gstelement_class->change_state = gst_jpegenc_change_state;
 194
 195   gobject_class->finalize = gst_jpegenc_finalize;
 196
 197   GST_DEBUG_CATEGORY_INIT (jpegenc_debug, "jpegenc", 0,
 198       "JPEG encoding element");
 199 }
 200
 201 static void
 202 gst_jpegenc_init_destination (j_compress_ptr cinfo)
 203 {
 204   GST_DEBUG ("gst_jpegenc_chain: init_destination");
 205 }
 206
 207 static boolean
 208 gst_jpegenc_flush_destination (j_compress_ptr cinfo)
 209 {
 210   GstBuffer *overflow_buffer;
 211   guint32 old_buffer_size;
 212   GstJpegEnc *jpegenc = (GstJpegEnc *) (cinfo->client_data);
 213   GST_DEBUG_OBJECT (jpegenc,
 214       "gst_jpegenc_chain: flush_destination: buffer too small");
 215
 216   /* Our output buffer wasn't big enough.
 217    * Make a new buffer that's twice the size, */
 218   old_buffer_size = GST_BUFFER_SIZE (jpegenc->output_buffer);
 219   gst_pad_alloc_buffer_and_set_caps (jpegenc->srcpad,
 220       GST_BUFFER_OFFSET_NONE, old_buffer_size * 2,
 221       GST_PAD_CAPS (jpegenc->srcpad), &overflow_buffer);
 222   memcpy (GST_BUFFER_DATA (overflow_buffer),
 223       GST_BUFFER_DATA (jpegenc->output_buffer), old_buffer_size);
 224
 225   gst_buffer_copy_metadata (overflow_buffer, jpegenc->output_buffer,
 226       GST_BUFFER_COPY_TIMESTAMPS);
 227
 228   /* drop it into place, */
 229   gst_buffer_unref (jpegenc->output_buffer);
 230   jpegenc->output_buffer = overflow_buffer;
 231
 232   /* and last, update libjpeg on where to work. */
 233   jpegenc->jdest.next_output_byte =
 234       GST_BUFFER_DATA (jpegenc->output_buffer) + old_buffer_size;
 235   jpegenc->jdest.free_in_buffer =
 236       GST_BUFFER_SIZE (jpegenc->output_buffer) - old_buffer_size;
 237
 238   return TRUE;
 239 }
 240
 241 static void
 242 gst_jpegenc_term_destination (j_compress_ptr cinfo)
 243 {
 244   GstJpegEnc *jpegenc = (GstJpegEnc *) (cinfo->client_data);
 245   GST_DEBUG_OBJECT (jpegenc, "gst_jpegenc_chain: term_source");
 246
 247   /* Trim the buffer size and push it. */
 248   GST_BUFFER_SIZE (jpegenc->output_buffer) =
 249       GST_ROUND_UP_4 (GST_BUFFER_SIZE (jpegenc->output_buffer) -
 250       jpegenc->jdest.free_in_buffer);
 251
 252   g_signal_emit (G_OBJECT (jpegenc), gst_jpegenc_signals[FRAME_ENCODED], 0);
 253
 254   jpegenc->last_ret = gst_pad_push (jpegenc->srcpad, jpegenc->output_buffer);
 255   jpegenc->output_buffer = NULL;
 256 }
 257
 258 static void
 259 gst_jpegenc_init (GstJpegEnc * jpegenc)
 260 {
 261   /* create the sink and src pads */
 262   jpegenc->sinkpad =
 263       gst_pad_new_from_static_template (&gst_jpegenc_sink_pad_template, "sink");
 264   gst_pad_set_chain_function (jpegenc->sinkpad,
 265       GST_DEBUG_FUNCPTR (gst_jpegenc_chain));
 266   gst_pad_set_getcaps_function (jpegenc->sinkpad,
 267       GST_DEBUG_FUNCPTR (gst_jpegenc_getcaps));
 268   gst_pad_set_setcaps_function (jpegenc->sinkpad,
 269       GST_DEBUG_FUNCPTR (gst_jpegenc_setcaps));
 270   gst_element_add_pad (GST_ELEMENT (jpegenc), jpegenc->sinkpad);
 271
 272   jpegenc->srcpad =
 273       gst_pad_new_from_static_template (&gst_jpegenc_src_pad_template, "src");
 274   gst_pad_use_fixed_caps (jpegenc->srcpad);
 275   gst_element_add_pad (GST_ELEMENT (jpegenc), jpegenc->srcpad);
 276
 277   /* reset the initial video state */
 278   jpegenc->width = -1;
 279   jpegenc->height = -1;
 280
 281   /* setup jpeglib */
 282   memset (&jpegenc->cinfo, 0, sizeof (jpegenc->cinfo));
 283   memset (&jpegenc->jerr, 0, sizeof (jpegenc->jerr));
 284   jpegenc->cinfo.err = jpeg_std_error (&jpegenc->jerr);
 285   jpeg_create_compress (&jpegenc->cinfo);
 286
 287   jpegenc->jdest.init_destination = gst_jpegenc_init_destination;
 288   jpegenc->jdest.empty_output_buffer = gst_jpegenc_flush_destination;
 289   jpegenc->jdest.term_destination = gst_jpegenc_term_destination;
 290   jpegenc->cinfo.dest = &jpegenc->jdest;
 291   jpegenc->cinfo.client_data = jpegenc;
 292
 293   /* init properties */
 294   jpegenc->quality = JPEG_DEFAULT_QUALITY;
 295   jpegenc->smoothing = JPEG_DEFAULT_SMOOTHING;
 296   jpegenc->idct_method = JPEG_DEFAULT_IDCT_METHOD;
 297
 298   gst_jpegenc_reset (jpegenc);
 299 }
 300
 301 static void
 302 gst_jpegenc_reset (GstJpegEnc * enc)
 303 {
 304   gint i, j;
 305
 306   g_free (enc->line[0]);
 307   g_free (enc->line[1]);
 308   g_free (enc->line[2]);
 309   enc->line[0] = NULL;
 310   enc->line[1] = NULL;
 311   enc->line[2] = NULL;
 312   for (i = 0; i < 3; i++) {
 313     for (j = 0; j < 4 * DCTSIZE; j++) {
 314       g_free (enc->row[i][j]);
 315       enc->row[i][j] = NULL;
 316     }
 317   }
 318
 319   enc->width = -1;
 320   enc->height = -1;
 321   enc->format = GST_VIDEO_FORMAT_UNKNOWN;
 322   enc->fps_den = enc->par_den = 0;
 323   enc->height = enc->width = 0;
 324 }
 325
 326 static void
 327 gst_jpegenc_finalize (GObject * object)
 328 {
 329   GstJpegEnc *filter = GST_JPEGENC (object);
 330
 331   jpeg_destroy_compress (&filter->cinfo);
 332
 333   G_OBJECT_CLASS (parent_class)->finalize (object);
 334 }
 335
 336 static GstCaps *
 337 gst_jpegenc_getcaps (GstPad * pad)
 338 {
 339   GstJpegEnc *jpegenc = GST_JPEGENC (gst_pad_get_parent (pad));
 340   GstCaps *caps, *othercaps;
 341   const GstCaps *templ;
 342   gint i, j;
 343   GstStructure *structure = NULL;
 344
 345   /* we want to proxy properties like width, height and framerate from the
 346      other end of the element */
 347
 348   othercaps = gst_pad_peer_get_caps_reffed (jpegenc->srcpad);
 349   if (othercaps == NULL ||
 350       gst_caps_is_empty (othercaps) || gst_caps_is_any (othercaps)) {
 351     caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
 352     goto done;
 353   }
 354
 355   caps = gst_caps_new_empty ();
 356   templ = gst_pad_get_pad_template_caps (pad);
 357
 358   for (i = 0; i < gst_caps_get_size (templ); i++) {
 359     /* pick fields from peer caps */
 360     for (j = 0; j < gst_caps_get_size (othercaps); j++) {
 361       GstStructure *s = gst_caps_get_structure (othercaps, j);
 362       const GValue *val;
 363
 364       structure = gst_structure_copy (gst_caps_get_structure (templ, i));
 365       if ((val = gst_structure_get_value (s, "width")))
 366         gst_structure_set_value (structure, "width", val);
 367       if ((val = gst_structure_get_value (s, "height")))
 368         gst_structure_set_value (structure, "height", val);
 369       if ((val = gst_structure_get_value (s, "framerate")))
 370         gst_structure_set_value (structure, "framerate", val);
 371
 372       gst_caps_merge_structure (caps, structure);
 373     }
 374   }
 375
 376 done:
 377
 378   gst_caps_replace (&othercaps, NULL);
 379   gst_object_unref (jpegenc);
 380
 381   return caps;
 382 }
 383
 384 static gboolean
 385 gst_jpegenc_setcaps (GstPad * pad, GstCaps * caps)
 386 {
 387   GstJpegEnc *enc = GST_JPEGENC (gst_pad_get_parent (pad));
 388   GstVideoFormat format;
 389   gint width, height;
 390   gint fps_num, fps_den;
 391   gint par_num, par_den;
 392   gint i;
 393   GstCaps *othercaps;
 394   gboolean ret;
 395
 396   /* get info from caps */
 397   if (!gst_video_format_parse_caps (caps, &format, &width, &height))
 398     goto refuse_caps;
 399   /* optional; pass along if present */
 400   fps_num = fps_den = -1;
 401   par_num = par_den = -1;
 402   gst_video_parse_caps_framerate (caps, &fps_num, &fps_den);
 403   gst_video_parse_caps_pixel_aspect_ratio (caps, &par_num, &par_den);
 404
 405   if (width == enc->width && height == enc->height && enc->format == format
 406       && fps_num == enc->fps_num && fps_den == enc->fps_den
 407       && par_num == enc->par_num && par_den == enc->par_den)
 408     return TRUE;
 409
 410   /* store input description */
 411   enc->format = format;
 412   enc->width = width;
 413   enc->height = height;
 414   enc->fps_num = fps_num;
 415   enc->fps_den = fps_den;
 416   enc->par_num = par_num;
 417   enc->par_den = par_den;
 418
 419   /* prepare a cached image description  */
 420   enc->channels = 3 + (gst_video_format_has_alpha (format) ? 1 : 0);
 421   /* ... but any alpha is disregarded in encoding */
 422   if (gst_video_format_is_gray (format))
 423     enc->channels = 1;
 424   else
 425     enc->channels = 3;
 426   enc->h_max_samp = 0;
 427   enc->v_max_samp = 0;
 428   for (i = 0; i < enc->channels; ++i) {
 429     enc->cwidth[i] = gst_video_format_get_component_width (format, i, width);
 430     enc->cheight[i] = gst_video_format_get_component_height (format, i, height);
 431     enc->offset[i] = gst_video_format_get_component_offset (format, i, width,
 432         height);
 433     enc->stride[i] = gst_video_format_get_row_stride (format, i, width);
 434     enc->inc[i] = gst_video_format_get_pixel_stride (format, i);
 435     enc->h_samp[i] = GST_ROUND_UP_4 (width) / enc->cwidth[i];
 436     enc->h_max_samp = MAX (enc->h_max_samp, enc->h_samp[i]);
 437     enc->v_samp[i] = GST_ROUND_UP_4 (height) / enc->cheight[i];
 438     enc->v_max_samp = MAX (enc->v_max_samp, enc->v_samp[i]);
 439   }
 440   /* samp should only be 1, 2 or 4 */
 441   g_assert (enc->h_max_samp <= 4);
 442   g_assert (enc->v_max_samp <= 4);
 443   /* now invert */
 444   /* maximum is invariant, as one of the components should have samp 1 */
 445   for (i = 0; i < enc->channels; ++i) {
 446     enc->h_samp[i] = enc->h_max_samp / enc->h_samp[i];
 447     enc->v_samp[i] = enc->v_max_samp / enc->v_samp[i];
 448   }
 449   enc->planar = (enc->inc[0] == 1 && enc->inc[1] == 1 && enc->inc[2] == 1);
 450
 451   othercaps = gst_caps_copy (gst_pad_get_pad_template_caps (enc->srcpad));
 452   gst_caps_set_simple (othercaps,
 453       "width", G_TYPE_INT, enc->width, "height", G_TYPE_INT, enc->height, NULL);
 454   if (enc->fps_den > 0)
 455     gst_caps_set_simple (othercaps,
 456         "framerate", GST_TYPE_FRACTION, enc->fps_num, enc->fps_den, NULL);
 457   if (enc->par_den > 0)
 458     gst_caps_set_simple (othercaps,
 459         "pixel-aspect-ratio", GST_TYPE_FRACTION, enc->par_num, enc->par_den,
 460         NULL);
 461
 462   ret = gst_pad_set_caps (enc->srcpad, othercaps);
 463   gst_caps_unref (othercaps);
 464
 465   if (ret)
 466     gst_jpegenc_resync (enc);
 467
 468   gst_object_unref (enc);
 469
 470   return ret;
 471
 472   /* ERRORS */
 473 refuse_caps:
 474   {
 475     GST_WARNING_OBJECT (enc, "refused caps %" GST_PTR_FORMAT, caps);
 476     gst_object_unref (enc);
 477     return FALSE;
 478   }
 479 }
 480
 481 static void
 482 gst_jpegenc_resync (GstJpegEnc * jpegenc)
 483 {
 484   gint width, height;
 485   gint i, j;
 486
 487   GST_DEBUG_OBJECT (jpegenc, "resync");
 488
 489   jpegenc->cinfo.image_width = width = jpegenc->width;
 490   jpegenc->cinfo.image_height = height = jpegenc->height;
 491   jpegenc->cinfo.input_components = jpegenc->channels;
 492
 493   GST_DEBUG_OBJECT (jpegenc, "width %d, height %d", width, height);
 494   GST_DEBUG_OBJECT (jpegenc, "format %d", jpegenc->format);
 495
 496   if (gst_video_format_is_rgb (jpegenc->format)) {
 497     GST_DEBUG_OBJECT (jpegenc, "RGB");
 498     jpegenc->cinfo.in_color_space = JCS_RGB;
 499   } else if (gst_video_format_is_gray (jpegenc->format)) {
 500     GST_DEBUG_OBJECT (jpegenc, "gray");
 501     jpegenc->cinfo.in_color_space = JCS_GRAYSCALE;
 502   } else {
 503     GST_DEBUG_OBJECT (jpegenc, "YUV");
 504     jpegenc->cinfo.in_color_space = JCS_YCbCr;
 505   }
 506
 507   /* input buffer size as max output */
 508   jpegenc->bufsize = gst_video_format_get_size (jpegenc->format, width, height);
 509   jpeg_set_defaults (&jpegenc->cinfo);
 510   jpegenc->cinfo.raw_data_in = TRUE;
 511   /* duh, libjpeg maps RGB to YUV ... and don't expect some conversion */
 512   if (jpegenc->cinfo.in_color_space == JCS_RGB)
 513     jpeg_set_colorspace (&jpegenc->cinfo, JCS_RGB);
 514
 515   GST_DEBUG_OBJECT (jpegenc, "h_max_samp=%d, v_max_samp=%d",
 516       jpegenc->h_max_samp, jpegenc->v_max_samp);
 517   /* image dimension info */
 518   for (i = 0; i < jpegenc->channels; i++) {
 519     GST_DEBUG_OBJECT (jpegenc, "comp %i: h_samp=%d, v_samp=%d", i,
 520         jpegenc->h_samp[i], jpegenc->v_samp[i]);
 521     jpegenc->cinfo.comp_info[i].h_samp_factor = jpegenc->h_samp[i];
 522     jpegenc->cinfo.comp_info[i].v_samp_factor = jpegenc->v_samp[i];
 523     g_free (jpegenc->line[i]);
 524     jpegenc->line[i] = g_new (guchar *, jpegenc->v_max_samp * DCTSIZE);
 525     if (!jpegenc->planar) {
 526       for (j = 0; j < jpegenc->v_max_samp * DCTSIZE; j++) {
 527         g_free (jpegenc->row[i][j]);
 528         jpegenc->row[i][j] = g_malloc (width);
 529         jpegenc->line[i][j] = jpegenc->row[i][j];
 530       }
 531     }
 532   }
 533
 534   /* guard against a potential error in gst_jpegenc_term_destination
 535      which occurs iff bufsize % 4 < free_space_remaining */
 536   jpegenc->bufsize = GST_ROUND_UP_4 (jpegenc->bufsize);
 537
 538   jpeg_suppress_tables (&jpegenc->cinfo, TRUE);
 539
 540   GST_DEBUG_OBJECT (jpegenc, "resync done");
 541 }
 542
 543 static GstFlowReturn
 544 gst_jpegenc_chain (GstPad * pad, GstBuffer * buf)
 545 {
 546   GstFlowReturn ret;
 547   GstJpegEnc *jpegenc;
 548   guchar *data;
 549   gulong size;
 550   guint height;
 551   guchar *base[3], *end[3];
 552   gint i, j, k;
 553
 554   jpegenc = GST_JPEGENC (GST_OBJECT_PARENT (pad));
 555
 556   if (G_UNLIKELY (jpegenc->width <= 0 || jpegenc->height <= 0))
 557     goto not_negotiated;
 558
 559   data = GST_BUFFER_DATA (buf);
 560   size = GST_BUFFER_SIZE (buf);
 561
 562   GST_LOG_OBJECT (jpegenc, "got buffer of %lu bytes", size);
 563
 564   ret =
 565       gst_pad_alloc_buffer_and_set_caps (jpegenc->srcpad,
 566       GST_BUFFER_OFFSET_NONE, jpegenc->bufsize, GST_PAD_CAPS (jpegenc->srcpad),
 567       &jpegenc->output_buffer);
 568
 569   if (ret != GST_FLOW_OK)
 570     goto done;
 571
 572   gst_buffer_copy_metadata (jpegenc->output_buffer, buf,
 573       GST_BUFFER_COPY_TIMESTAMPS);
 574
 575   height = jpegenc->height;
 576
 577   for (i = 0; i < jpegenc->channels; i++) {
 578     base[i] = data + jpegenc->offset[i];
 579     end[i] = base[i] + jpegenc->cheight[i] * jpegenc->stride[i];
 580   }
 581
 582   jpegenc->jdest.next_output_byte = GST_BUFFER_DATA (jpegenc->output_buffer);
 583   jpegenc->jdest.free_in_buffer = GST_BUFFER_SIZE (jpegenc->output_buffer);
 584
 585   /* prepare for raw input */
 586 #if JPEG_LIB_VERSION >= 70
 587   jpegenc->cinfo.do_fancy_downsampling = FALSE;
 588 #endif
 589   jpegenc->cinfo.smoothing_factor = jpegenc->smoothing;
 590   jpegenc->cinfo.dct_method = jpegenc->idct_method;
 591   jpeg_set_quality (&jpegenc->cinfo, jpegenc->quality, TRUE);
 592   jpeg_start_compress (&jpegenc->cinfo, TRUE);
 593
 594   GST_LOG_OBJECT (jpegenc, "compressing");
 595
 596   if (jpegenc->planar) {
 597     for (i = 0; i < height; i += jpegenc->v_max_samp * DCTSIZE) {
 598       for (k = 0; k < jpegenc->channels; k++) {
 599         for (j = 0; j < jpegenc->v_samp[k] * DCTSIZE; j++) {
 600           jpegenc->line[k][j] = base[k];
 601           if (base[k] + jpegenc->stride[k] < end[k])
 602             base[k] += jpegenc->stride[k];
 603         }
 604       }
 605       jpeg_write_raw_data (&jpegenc->cinfo, jpegenc->line,
 606           jpegenc->v_max_samp * DCTSIZE);
 607     }
 608   } else {
 609     for (i = 0; i < height; i += jpegenc->v_max_samp * DCTSIZE) {
 610       for (k = 0; k < jpegenc->channels; k++) {
 611         for (j = 0; j < jpegenc->v_samp[k] * DCTSIZE; j++) {
 612           guchar *src, *dst;
 613           gint l;
 614
 615           /* ouch, copy line */
 616           src = base[k];
 617           dst = jpegenc->line[k][j];
 618           for (l = jpegenc->cwidth[k]; l > 0; l--) {
 619             *dst = *src;
 620             src += jpegenc->inc[k];
 621             dst++;
 622           }
 623           if (base[k] + jpegenc->stride[k] < end[k])
 624             base[k] += jpegenc->stride[k];
 625         }
 626       }
 627       jpeg_write_raw_data (&jpegenc->cinfo, jpegenc->line,
 628           jpegenc->v_max_samp * DCTSIZE);
 629     }
 630   }
 631
 632   /* This will ensure that gst_jpegenc_term_destination is called; we push
 633      the final output buffer from there */
 634   jpeg_finish_compress (&jpegenc->cinfo);
 635   GST_LOG_OBJECT (jpegenc, "compressing done");
 636
 637 done:
 638   gst_buffer_unref (buf);
 639
 640   return ret;
 641
 642 /* ERRORS */
 643 not_negotiated:
 644   {
 645     GST_WARNING_OBJECT (jpegenc, "no input format set (no caps on buffer)");
 646     ret = GST_FLOW_NOT_NEGOTIATED;
 647     goto done;
 648   }
 649 }
 650
 651 static void
 652 gst_jpegenc_set_property (GObject * object, guint prop_id,
 653     const GValue * value, GParamSpec * pspec)
 654 {
 655   GstJpegEnc *jpegenc = GST_JPEGENC (object);
 656
 657   GST_OBJECT_LOCK (jpegenc);
 658
 659   switch (prop_id) {
 660     case PROP_QUALITY:
 661       jpegenc->quality = g_value_get_int (value);
 662       break;
 663 #ifdef ENABLE_SMOOTHING
 664     case PROP_SMOOTHING:
 665       jpegenc->smoothing = g_value_get_int (value);
 666       break;
 667 #endif
 668     case PROP_IDCT_METHOD:
 669       jpegenc->idct_method = g_value_get_enum (value);
 670       break;
 671     default:
 672       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 673       break;
 674   }
 675
 676   GST_OBJECT_UNLOCK (jpegenc);
 677 }
 678
 679 static void
 680 gst_jpegenc_get_property (GObject * object, guint prop_id, GValue * value,
 681     GParamSpec * pspec)
 682 {
 683   GstJpegEnc *jpegenc = GST_JPEGENC (object);
 684
 685   GST_OBJECT_LOCK (jpegenc);
 686
 687   switch (prop_id) {
 688     case PROP_QUALITY:
 689       g_value_set_int (value, jpegenc->quality);
 690       break;
 691 #ifdef ENABLE_SMOOTHING
 692     case PROP_SMOOTHING:
 693       g_value_set_int (value, jpegenc->smoothing);
 694       break;
 695 #endif
 696     case PROP_IDCT_METHOD:
 697       g_value_set_enum (value, jpegenc->idct_method);
 698       break;
 699     default:
 700       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 701       break;
 702   }
 703
 704   GST_OBJECT_UNLOCK (jpegenc);
 705 }
 706
 707 static GstStateChangeReturn
 708 gst_jpegenc_change_state (GstElement * element, GstStateChange transition)
 709 {
 710   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 711   GstJpegEnc *filter = GST_JPEGENC (element);
 712
 713   switch (transition) {
 714     case GST_STATE_CHANGE_NULL_TO_READY:
 715       GST_DEBUG_OBJECT (element, "setting line buffers");
 716       filter->line[0] = NULL;
 717       filter->line[1] = NULL;
 718       filter->line[2] = NULL;
 719       break;
 720     default:
 721       break;
 722   }
 723
 724   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 725   if (ret == GST_STATE_CHANGE_FAILURE)
 726     return ret;
 727
 728   switch (transition) {
 729     case GST_STATE_CHANGE_PAUSED_TO_READY:
 730       gst_jpegenc_reset (filter);
 731       break;
 732     default:
 733       break;
 734   }
 735
 736   return ret;
 737 }