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_static_pad_template (element_class,
 146       &gst_jpegenc_sink_pad_template);
 147   gst_element_class_add_static_pad_template (element_class,
 148       &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_BUFFER_SIZE (jpegenc->output_buffer) - jpegenc->jdest.free_in_buffer;
 250
 251   g_signal_emit (G_OBJECT (jpegenc), gst_jpegenc_signals[FRAME_ENCODED], 0);
 252
 253   jpegenc->last_ret = gst_pad_push (jpegenc->srcpad, jpegenc->output_buffer);
 254   jpegenc->output_buffer = NULL;
 255 }
 256
 257 static void
 258 gst_jpegenc_init (GstJpegEnc * jpegenc)
 259 {
 260   /* create the sink and src pads */
 261   jpegenc->sinkpad =
 262       gst_pad_new_from_static_template (&gst_jpegenc_sink_pad_template, "sink");
 263   gst_pad_set_chain_function (jpegenc->sinkpad,
 264       GST_DEBUG_FUNCPTR (gst_jpegenc_chain));
 265   gst_pad_set_getcaps_function (jpegenc->sinkpad,
 266       GST_DEBUG_FUNCPTR (gst_jpegenc_getcaps));
 267   gst_pad_set_setcaps_function (jpegenc->sinkpad,
 268       GST_DEBUG_FUNCPTR (gst_jpegenc_setcaps));
 269   gst_element_add_pad (GST_ELEMENT (jpegenc), jpegenc->sinkpad);
 270
 271   jpegenc->srcpad =
 272       gst_pad_new_from_static_template (&gst_jpegenc_src_pad_template, "src");
 273   gst_pad_use_fixed_caps (jpegenc->srcpad);
 274   gst_element_add_pad (GST_ELEMENT (jpegenc), jpegenc->srcpad);
 275
 276   /* reset the initial video state */
 277   jpegenc->width = -1;
 278   jpegenc->height = -1;
 279
 280   /* setup jpeglib */
 281   memset (&jpegenc->cinfo, 0, sizeof (jpegenc->cinfo));
 282   memset (&jpegenc->jerr, 0, sizeof (jpegenc->jerr));
 283   jpegenc->cinfo.err = jpeg_std_error (&jpegenc->jerr);
 284   jpeg_create_compress (&jpegenc->cinfo);
 285
 286   jpegenc->jdest.init_destination = gst_jpegenc_init_destination;
 287   jpegenc->jdest.empty_output_buffer = gst_jpegenc_flush_destination;
 288   jpegenc->jdest.term_destination = gst_jpegenc_term_destination;
 289   jpegenc->cinfo.dest = &jpegenc->jdest;
 290   jpegenc->cinfo.client_data = jpegenc;
 291
 292   /* init properties */
 293   jpegenc->quality = JPEG_DEFAULT_QUALITY;
 294   jpegenc->smoothing = JPEG_DEFAULT_SMOOTHING;
 295   jpegenc->idct_method = JPEG_DEFAULT_IDCT_METHOD;
 296
 297   gst_jpegenc_reset (jpegenc);
 298 }
 299
 300 static void
 301 gst_jpegenc_reset (GstJpegEnc * enc)
 302 {
 303   gint i, j;
 304
 305   g_free (enc->line[0]);
 306   g_free (enc->line[1]);
 307   g_free (enc->line[2]);
 308   enc->line[0] = NULL;
 309   enc->line[1] = NULL;
 310   enc->line[2] = NULL;
 311   for (i = 0; i < 3; i++) {
 312     for (j = 0; j < 4 * DCTSIZE; j++) {
 313       g_free (enc->row[i][j]);
 314       enc->row[i][j] = NULL;
 315     }
 316   }
 317
 318   enc->width = -1;
 319   enc->height = -1;
 320   enc->format = GST_VIDEO_FORMAT_UNKNOWN;
 321   enc->fps_den = enc->par_den = 0;
 322   enc->height = enc->width = 0;
 323 }
 324
 325 static void
 326 gst_jpegenc_finalize (GObject * object)
 327 {
 328   GstJpegEnc *filter = GST_JPEGENC (object);
 329
 330   jpeg_destroy_compress (&filter->cinfo);
 331
 332   G_OBJECT_CLASS (parent_class)->finalize (object);
 333 }
 334
 335 static GstCaps *
 336 gst_jpegenc_getcaps (GstPad * pad)
 337 {
 338   GstJpegEnc *jpegenc = GST_JPEGENC (gst_pad_get_parent (pad));
 339   GstCaps *caps, *othercaps;
 340   const GstCaps *templ;
 341   gint i, j;
 342   GstStructure *structure = NULL;
 343
 344   /* we want to proxy properties like width, height and framerate from the
 345      other end of the element */
 346
 347   othercaps = gst_pad_peer_get_caps_reffed (jpegenc->srcpad);
 348   if (othercaps == NULL ||
 349       gst_caps_is_empty (othercaps) || gst_caps_is_any (othercaps)) {
 350     caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
 351     goto done;
 352   }
 353
 354   caps = gst_caps_new_empty ();
 355   templ = gst_pad_get_pad_template_caps (pad);
 356
 357   for (i = 0; i < gst_caps_get_size (templ); i++) {
 358     /* pick fields from peer caps */
 359     for (j = 0; j < gst_caps_get_size (othercaps); j++) {
 360       GstStructure *s = gst_caps_get_structure (othercaps, j);
 361       const GValue *val;
 362
 363       structure = gst_structure_copy (gst_caps_get_structure (templ, i));
 364       if ((val = gst_structure_get_value (s, "width")))
 365         gst_structure_set_value (structure, "width", val);
 366       if ((val = gst_structure_get_value (s, "height")))
 367         gst_structure_set_value (structure, "height", val);
 368       if ((val = gst_structure_get_value (s, "framerate")))
 369         gst_structure_set_value (structure, "framerate", val);
 370
 371       gst_caps_merge_structure (caps, structure);
 372     }
 373   }
 374
 375 done:
 376
 377   gst_caps_replace (&othercaps, NULL);
 378   gst_object_unref (jpegenc);
 379
 380   return caps;
 381 }
 382
 383 static gboolean
 384 gst_jpegenc_setcaps (GstPad * pad, GstCaps * caps)
 385 {
 386   GstJpegEnc *enc = GST_JPEGENC (gst_pad_get_parent (pad));
 387   GstVideoFormat format;
 388   gint width, height;
 389   gint fps_num, fps_den;
 390   gint par_num, par_den;
 391   gint i;
 392   GstCaps *othercaps;
 393   gboolean ret;
 394
 395   /* get info from caps */
 396   if (!gst_video_format_parse_caps (caps, &format, &width, &height))
 397     goto refuse_caps;
 398   /* optional; pass along if present */
 399   fps_num = fps_den = -1;
 400   par_num = par_den = -1;
 401   gst_video_parse_caps_framerate (caps, &fps_num, &fps_den);
 402   gst_video_parse_caps_pixel_aspect_ratio (caps, &par_num, &par_den);
 403
 404   if (width == enc->width && height == enc->height && enc->format == format
 405       && fps_num == enc->fps_num && fps_den == enc->fps_den
 406       && par_num == enc->par_num && par_den == enc->par_den)
 407     return TRUE;
 408
 409   /* store input description */
 410   enc->format = format;
 411   enc->width = width;
 412   enc->height = height;
 413   enc->fps_num = fps_num;
 414   enc->fps_den = fps_den;
 415   enc->par_num = par_num;
 416   enc->par_den = par_den;
 417
 418   /* prepare a cached image description  */
 419   enc->channels = 3 + (gst_video_format_has_alpha (format) ? 1 : 0);
 420   /* ... but any alpha is disregarded in encoding */
 421   if (gst_video_format_is_gray (format))
 422     enc->channels = 1;
 423   else
 424     enc->channels = 3;
 425   enc->h_max_samp = 0;
 426   enc->v_max_samp = 0;
 427   for (i = 0; i < enc->channels; ++i) {
 428     enc->cwidth[i] = gst_video_format_get_component_width (format, i, width);
 429     enc->cheight[i] = gst_video_format_get_component_height (format, i, height);
 430     enc->offset[i] = gst_video_format_get_component_offset (format, i, width,
 431         height);
 432     enc->stride[i] = gst_video_format_get_row_stride (format, i, width);
 433     enc->inc[i] = gst_video_format_get_pixel_stride (format, i);
 434     enc->h_samp[i] = GST_ROUND_UP_4 (width) / enc->cwidth[i];
 435     enc->h_max_samp = MAX (enc->h_max_samp, enc->h_samp[i]);
 436     enc->v_samp[i] = GST_ROUND_UP_4 (height) / enc->cheight[i];
 437     enc->v_max_samp = MAX (enc->v_max_samp, enc->v_samp[i]);
 438   }
 439   /* samp should only be 1, 2 or 4 */
 440   g_assert (enc->h_max_samp <= 4);
 441   g_assert (enc->v_max_samp <= 4);
 442   /* now invert */
 443   /* maximum is invariant, as one of the components should have samp 1 */
 444   for (i = 0; i < enc->channels; ++i) {
 445     enc->h_samp[i] = enc->h_max_samp / enc->h_samp[i];
 446     enc->v_samp[i] = enc->v_max_samp / enc->v_samp[i];
 447   }
 448   enc->planar = (enc->inc[0] == 1 && enc->inc[1] == 1 && enc->inc[2] == 1);
 449
 450   othercaps = gst_caps_copy (gst_pad_get_pad_template_caps (enc->srcpad));
 451   gst_caps_set_simple (othercaps,
 452       "width", G_TYPE_INT, enc->width, "height", G_TYPE_INT, enc->height, NULL);
 453   if (enc->fps_den > 0)
 454     gst_caps_set_simple (othercaps,
 455         "framerate", GST_TYPE_FRACTION, enc->fps_num, enc->fps_den, NULL);
 456   if (enc->par_den > 0)
 457     gst_caps_set_simple (othercaps,
 458         "pixel-aspect-ratio", GST_TYPE_FRACTION, enc->par_num, enc->par_den,
 459         NULL);
 460
 461   ret = gst_pad_set_caps (enc->srcpad, othercaps);
 462   gst_caps_unref (othercaps);
 463
 464   if (ret)
 465     gst_jpegenc_resync (enc);
 466
 467   gst_object_unref (enc);
 468
 469   return ret;
 470
 471   /* ERRORS */
 472 refuse_caps:
 473   {
 474     GST_WARNING_OBJECT (enc, "refused caps %" GST_PTR_FORMAT, caps);
 475     gst_object_unref (enc);
 476     return FALSE;
 477   }
 478 }
 479
 480 static void
 481 gst_jpegenc_resync (GstJpegEnc * jpegenc)
 482 {
 483   gint width, height;
 484   gint i, j;
 485
 486   GST_DEBUG_OBJECT (jpegenc, "resync");
 487
 488   jpegenc->cinfo.image_width = width = jpegenc->width;
 489   jpegenc->cinfo.image_height = height = jpegenc->height;
 490   jpegenc->cinfo.input_components = jpegenc->channels;
 491
 492   GST_DEBUG_OBJECT (jpegenc, "width %d, height %d", width, height);
 493   GST_DEBUG_OBJECT (jpegenc, "format %d", jpegenc->format);
 494
 495   if (gst_video_format_is_rgb (jpegenc->format)) {
 496     GST_DEBUG_OBJECT (jpegenc, "RGB");
 497     jpegenc->cinfo.in_color_space = JCS_RGB;
 498   } else if (gst_video_format_is_gray (jpegenc->format)) {
 499     GST_DEBUG_OBJECT (jpegenc, "gray");
 500     jpegenc->cinfo.in_color_space = JCS_GRAYSCALE;
 501   } else {
 502     GST_DEBUG_OBJECT (jpegenc, "YUV");
 503     jpegenc->cinfo.in_color_space = JCS_YCbCr;
 504   }
 505
 506   /* input buffer size as max output */
 507   jpegenc->bufsize = gst_video_format_get_size (jpegenc->format, width, height);
 508   jpeg_set_defaults (&jpegenc->cinfo);
 509   jpegenc->cinfo.raw_data_in = TRUE;
 510   /* duh, libjpeg maps RGB to YUV ... and don't expect some conversion */
 511   if (jpegenc->cinfo.in_color_space == JCS_RGB)
 512     jpeg_set_colorspace (&jpegenc->cinfo, JCS_RGB);
 513
 514   GST_DEBUG_OBJECT (jpegenc, "h_max_samp=%d, v_max_samp=%d",
 515       jpegenc->h_max_samp, jpegenc->v_max_samp);
 516   /* image dimension info */
 517   for (i = 0; i < jpegenc->channels; i++) {
 518     GST_DEBUG_OBJECT (jpegenc, "comp %i: h_samp=%d, v_samp=%d", i,
 519         jpegenc->h_samp[i], jpegenc->v_samp[i]);
 520     jpegenc->cinfo.comp_info[i].h_samp_factor = jpegenc->h_samp[i];
 521     jpegenc->cinfo.comp_info[i].v_samp_factor = jpegenc->v_samp[i];
 522     g_free (jpegenc->line[i]);
 523     jpegenc->line[i] = g_new (guchar *, jpegenc->v_max_samp * DCTSIZE);
 524     if (!jpegenc->planar) {
 525       for (j = 0; j < jpegenc->v_max_samp * DCTSIZE; j++) {
 526         g_free (jpegenc->row[i][j]);
 527         jpegenc->row[i][j] = g_malloc (width);
 528         jpegenc->line[i][j] = jpegenc->row[i][j];
 529       }
 530     }
 531   }
 532
 533   /* guard against a potential error in gst_jpegenc_term_destination
 534      which occurs iff bufsize % 4 < free_space_remaining */
 535   jpegenc->bufsize = GST_ROUND_UP_4 (jpegenc->bufsize);
 536
 537   jpeg_suppress_tables (&jpegenc->cinfo, TRUE);
 538
 539   GST_DEBUG_OBJECT (jpegenc, "resync done");
 540 }
 541
 542 static GstFlowReturn
 543 gst_jpegenc_chain (GstPad * pad, GstBuffer * buf)
 544 {
 545   GstFlowReturn ret;
 546   GstJpegEnc *jpegenc;
 547   guchar *data;
 548   gulong size;
 549   guint height;
 550   guchar *base[3], *end[3];
 551   gint i, j, k;
 552
 553   jpegenc = GST_JPEGENC (GST_OBJECT_PARENT (pad));
 554
 555   if (G_UNLIKELY (jpegenc->width <= 0 || jpegenc->height <= 0))
 556     goto not_negotiated;
 557
 558   data = GST_BUFFER_DATA (buf);
 559   size = GST_BUFFER_SIZE (buf);
 560
 561   GST_LOG_OBJECT (jpegenc, "got buffer of %lu bytes", size);
 562
 563   ret =
 564       gst_pad_alloc_buffer_and_set_caps (jpegenc->srcpad,
 565       GST_BUFFER_OFFSET_NONE, jpegenc->bufsize, GST_PAD_CAPS (jpegenc->srcpad),
 566       &jpegenc->output_buffer);
 567
 568   if (ret != GST_FLOW_OK)
 569     goto done;
 570
 571   gst_buffer_copy_metadata (jpegenc->output_buffer, buf,
 572       GST_BUFFER_COPY_TIMESTAMPS);
 573
 574   height = jpegenc->height;
 575
 576   for (i = 0; i < jpegenc->channels; i++) {
 577     base[i] = data + jpegenc->offset[i];
 578     end[i] = base[i] + jpegenc->cheight[i] * jpegenc->stride[i];
 579   }
 580
 581   jpegenc->jdest.next_output_byte = GST_BUFFER_DATA (jpegenc->output_buffer);
 582   jpegenc->jdest.free_in_buffer = GST_BUFFER_SIZE (jpegenc->output_buffer);
 583
 584   /* prepare for raw input */
 585 #if JPEG_LIB_VERSION >= 70
 586   jpegenc->cinfo.do_fancy_downsampling = FALSE;
 587 #endif
 588   jpegenc->cinfo.smoothing_factor = jpegenc->smoothing;
 589   jpegenc->cinfo.dct_method = jpegenc->idct_method;
 590   jpeg_set_quality (&jpegenc->cinfo, jpegenc->quality, TRUE);
 591   jpeg_start_compress (&jpegenc->cinfo, TRUE);
 592
 593   GST_LOG_OBJECT (jpegenc, "compressing");
 594
 595   if (jpegenc->planar) {
 596     for (i = 0; i < height; i += jpegenc->v_max_samp * DCTSIZE) {
 597       for (k = 0; k < jpegenc->channels; k++) {
 598         for (j = 0; j < jpegenc->v_samp[k] * DCTSIZE; j++) {
 599           jpegenc->line[k][j] = base[k];
 600           if (base[k] + jpegenc->stride[k] < end[k])
 601             base[k] += jpegenc->stride[k];
 602         }
 603       }
 604       jpeg_write_raw_data (&jpegenc->cinfo, jpegenc->line,
 605           jpegenc->v_max_samp * DCTSIZE);
 606     }
 607   } else {
 608     for (i = 0; i < height; i += jpegenc->v_max_samp * DCTSIZE) {
 609       for (k = 0; k < jpegenc->channels; k++) {
 610         for (j = 0; j < jpegenc->v_samp[k] * DCTSIZE; j++) {
 611           guchar *src, *dst;
 612           gint l;
 613
 614           /* ouch, copy line */
 615           src = base[k];
 616           dst = jpegenc->line[k][j];
 617           for (l = jpegenc->cwidth[k]; l > 0; l--) {
 618             *dst = *src;
 619             src += jpegenc->inc[k];
 620             dst++;
 621           }
 622           if (base[k] + jpegenc->stride[k] < end[k])
 623             base[k] += jpegenc->stride[k];
 624         }
 625       }
 626       jpeg_write_raw_data (&jpegenc->cinfo, jpegenc->line,
 627           jpegenc->v_max_samp * DCTSIZE);
 628     }
 629   }
 630
 631   /* This will ensure that gst_jpegenc_term_destination is called; we push
 632      the final output buffer from there */
 633   jpeg_finish_compress (&jpegenc->cinfo);
 634   GST_LOG_OBJECT (jpegenc, "compressing done");
 635
 636 done:
 637   gst_buffer_unref (buf);
 638
 639   return ret;
 640
 641 /* ERRORS */
 642 not_negotiated:
 643   {
 644     GST_WARNING_OBJECT (jpegenc, "no input format set (no caps on buffer)");
 645     ret = GST_FLOW_NOT_NEGOTIATED;
 646     goto done;
 647   }
 648 }
 649
 650 static void
 651 gst_jpegenc_set_property (GObject * object, guint prop_id,
 652     const GValue * value, GParamSpec * pspec)
 653 {
 654   GstJpegEnc *jpegenc = GST_JPEGENC (object);
 655
 656   GST_OBJECT_LOCK (jpegenc);
 657
 658   switch (prop_id) {
 659     case PROP_QUALITY:
 660       jpegenc->quality = g_value_get_int (value);
 661       break;
 662 #ifdef ENABLE_SMOOTHING
 663     case PROP_SMOOTHING:
 664       jpegenc->smoothing = g_value_get_int (value);
 665       break;
 666 #endif
 667     case PROP_IDCT_METHOD:
 668       jpegenc->idct_method = g_value_get_enum (value);
 669       break;
 670     default:
 671       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 672       break;
 673   }
 674
 675   GST_OBJECT_UNLOCK (jpegenc);
 676 }
 677
 678 static void
 679 gst_jpegenc_get_property (GObject * object, guint prop_id, GValue * value,
 680     GParamSpec * pspec)
 681 {
 682   GstJpegEnc *jpegenc = GST_JPEGENC (object);
 683
 684   GST_OBJECT_LOCK (jpegenc);
 685
 686   switch (prop_id) {
 687     case PROP_QUALITY:
 688       g_value_set_int (value, jpegenc->quality);
 689       break;
 690 #ifdef ENABLE_SMOOTHING
 691     case PROP_SMOOTHING:
 692       g_value_set_int (value, jpegenc->smoothing);
 693       break;
 694 #endif
 695     case PROP_IDCT_METHOD:
 696       g_value_set_enum (value, jpegenc->idct_method);
 697       break;
 698     default:
 699       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 700       break;
 701   }
 702
 703   GST_OBJECT_UNLOCK (jpegenc);
 704 }
 705
 706 static GstStateChangeReturn
 707 gst_jpegenc_change_state (GstElement * element, GstStateChange transition)
 708 {
 709   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 710   GstJpegEnc *filter = GST_JPEGENC (element);
 711
 712   switch (transition) {
 713     case GST_STATE_CHANGE_NULL_TO_READY:
 714       GST_DEBUG_OBJECT (element, "setting line buffers");
 715       filter->line[0] = NULL;
 716       filter->line[1] = NULL;
 717       filter->line[2] = NULL;
 718       break;
 719     default:
 720       break;
 721   }
 722
 723   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 724   if (ret == GST_STATE_CHANGE_FAILURE)
 725     return ret;
 726
 727   switch (transition) {
 728     case GST_STATE_CHANGE_PAUSED_TO_READY:
 729       gst_jpegenc_reset (filter);
 730       break;
 731     default:
 732       break;
 733   }
 734
 735   return ret;
 736 }