ext/jpeg/gstjpegenc.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  * Copyright (C) 2012 Collabora Ltd.
   4  *      Author : Edward Hervey <edward@collabora.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21 /**
  22  * SECTION:element-jpegenc
  23  *
  24  * Encodes jpeg images.
  25  *
  26  * <refsect2>
  27  * <title>Example launch line</title>
  28  * |[
  29  * gst-launch-1.0 videotestsrc num-buffers=50 ! video/x-raw, framerate='(fraction)'5/1 ! jpegenc ! avimux ! filesink location=mjpeg.avi
  30  * ]| a pipeline to mux 5 JPEG frames per second into a 10 sec. long motion jpeg
  31  * avi.
  32  * </refsect2>
  33  */
  34
  35 #ifdef HAVE_CONFIG_H
  36 #include "config.h"
  37 #endif
  38 #include <string.h>
  39
  40 #include "gstjpegenc.h"
  41 #include "gstjpeg.h"
  42 #include <gst/video/video.h>
  43 #include <gst/video/gstvideometa.h>
  44
  45 /* experimental */
  46 /* setting smoothig seems to have no effect in libjepeg
  47 #define ENABLE_SMOOTHING 1
  48 */
  49
  50 GST_DEBUG_CATEGORY_STATIC (jpegenc_debug);
  51 #define GST_CAT_DEFAULT jpegenc_debug
  52
  53 #define JPEG_DEFAULT_QUALITY 85
  54 #define JPEG_DEFAULT_SMOOTHING 0
  55 #define JPEG_DEFAULT_IDCT_METHOD        JDCT_FASTEST
  56
  57 /* JpegEnc signals and args */
  58 enum
  59 {
  60   /* FILL ME */
  61   LAST_SIGNAL
  62 };
  63
  64 enum
  65 {
  66   PROP_0,
  67   PROP_QUALITY,
  68   PROP_SMOOTHING,
  69   PROP_IDCT_METHOD
  70 };
  71
  72 static void gst_jpegenc_reset (GstJpegEnc * enc);
  73 static void gst_jpegenc_finalize (GObject * object);
  74
  75 static void gst_jpegenc_resync (GstJpegEnc * jpegenc);
  76 static void gst_jpegenc_set_property (GObject * object, guint prop_id,
  77     const GValue * value, GParamSpec * pspec);
  78 static void gst_jpegenc_get_property (GObject * object, guint prop_id,
  79     GValue * value, GParamSpec * pspec);
  80
  81 static gboolean gst_jpegenc_start (GstVideoEncoder * benc);
  82 static gboolean gst_jpegenc_stop (GstVideoEncoder * benc);
  83 static gboolean gst_jpegenc_set_format (GstVideoEncoder * encoder,
  84     GstVideoCodecState * state);
  85 static GstFlowReturn gst_jpegenc_handle_frame (GstVideoEncoder * encoder,
  86     GstVideoCodecFrame * frame);
  87 static gboolean gst_jpegenc_propose_allocation (GstVideoEncoder * encoder,
  88     GstQuery * query);
  89
  90 /* static guint gst_jpegenc_signals[LAST_SIGNAL] = { 0 }; */
  91
  92 #define gst_jpegenc_parent_class parent_class
  93 G_DEFINE_TYPE (GstJpegEnc, gst_jpegenc, GST_TYPE_VIDEO_ENCODER);
  94
  95 /* *INDENT-OFF* */
  96 static GstStaticPadTemplate gst_jpegenc_sink_pad_template =
  97 GST_STATIC_PAD_TEMPLATE ("sink",
  98     GST_PAD_SINK,
  99     GST_PAD_ALWAYS,
 100     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE
 101         ("{ I420, YV12, YUY2, UYVY, Y41B, Y42B, YVYU, Y444, "
 102          "RGB, BGR, RGBx, xRGB, BGRx, xBGR, GRAY8 }"))
 103     );
 104 /* *INDENT-ON* */
 105
 106 static GstStaticPadTemplate gst_jpegenc_src_pad_template =
 107 GST_STATIC_PAD_TEMPLATE ("src",
 108     GST_PAD_SRC,
 109     GST_PAD_ALWAYS,
 110     GST_STATIC_CAPS ("image/jpeg, "
 111         "width = (int) [ 16, 65535 ], "
 112         "height = (int) [ 16, 65535 ], " "framerate = (fraction) [ 0/1, MAX ]")
 113     );
 114
 115 static void
 116 gst_jpegenc_class_init (GstJpegEncClass * klass)
 117 {
 118   GObjectClass *gobject_class;
 119   GstElementClass *element_class;
 120   GstVideoEncoderClass *venc_class;
 121
 122   gobject_class = (GObjectClass *) klass;
 123   element_class = (GstElementClass *) klass;
 124   venc_class = (GstVideoEncoderClass *) klass;
 125
 126   parent_class = g_type_class_peek_parent (klass);
 127
 128   gobject_class->finalize = gst_jpegenc_finalize;
 129   gobject_class->set_property = gst_jpegenc_set_property;
 130   gobject_class->get_property = gst_jpegenc_get_property;
 131
 132   g_object_class_install_property (gobject_class, PROP_QUALITY,
 133       g_param_spec_int ("quality", "Quality", "Quality of encoding",
 134           0, 100, JPEG_DEFAULT_QUALITY,
 135           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 136
 137 #ifdef ENABLE_SMOOTHING
 138   /* disabled, since it doesn't seem to work */
 139   g_object_class_install_property (gobject_class, PROP_SMOOTHING,
 140       g_param_spec_int ("smoothing", "Smoothing", "Smoothing factor",
 141           0, 100, JPEG_DEFAULT_SMOOTHING,
 142           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 143 #endif
 144
 145   g_object_class_install_property (gobject_class, PROP_IDCT_METHOD,
 146       g_param_spec_enum ("idct-method", "IDCT Method",
 147           "The IDCT algorithm to use", GST_TYPE_IDCT_METHOD,
 148           JPEG_DEFAULT_IDCT_METHOD,
 149           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 150
 151   gst_element_class_add_pad_template (element_class,
 152       gst_static_pad_template_get (&gst_jpegenc_sink_pad_template));
 153   gst_element_class_add_pad_template (element_class,
 154       gst_static_pad_template_get (&gst_jpegenc_src_pad_template));
 155   gst_element_class_set_metadata (element_class, "JPEG image encoder",
 156       "Codec/Encoder/Image",
 157       "Encode images in JPEG format", "Wim Taymans <wim.taymans@tvd.be>");
 158
 159   venc_class->start = gst_jpegenc_start;
 160   venc_class->stop = gst_jpegenc_stop;
 161   venc_class->set_format = gst_jpegenc_set_format;
 162   venc_class->handle_frame = gst_jpegenc_handle_frame;
 163   venc_class->propose_allocation = gst_jpegenc_propose_allocation;
 164
 165   GST_DEBUG_CATEGORY_INIT (jpegenc_debug, "jpegenc", 0,
 166       "JPEG encoding element");
 167 }
 168
 169 static void
 170 gst_jpegenc_init_destination (j_compress_ptr cinfo)
 171 {
 172   GST_DEBUG ("gst_jpegenc_chain: init_destination");
 173 }
 174
 175 static void
 176 ensure_memory (GstJpegEnc * jpegenc)
 177 {
 178   GstMemory *new_memory;
 179   GstMapInfo map;
 180   gsize old_size, desired_size, new_size;
 181   guint8 *new_data;
 182   static GstAllocationParams params = { 0, 3, 0, 0, };
 183
 184   old_size = jpegenc->output_map.size;
 185   if (old_size == 0)
 186     desired_size = jpegenc->bufsize;
 187   else
 188     desired_size = old_size * 2;
 189
 190   /* Our output memory wasn't big enough.
 191    * Make a new memory that's twice the size, */
 192   new_memory = gst_allocator_alloc (NULL, desired_size, &params);
 193   gst_memory_map (new_memory, &map, GST_MAP_READWRITE);
 194   new_data = map.data;
 195   new_size = map.size;
 196
 197   /* copy previous data if any */
 198   if (jpegenc->output_mem) {
 199     memcpy (new_data, jpegenc->output_map.data, old_size);
 200     gst_memory_unmap (jpegenc->output_mem, &jpegenc->output_map);
 201     gst_memory_unref (jpegenc->output_mem);
 202   }
 203
 204   /* drop it into place, */
 205   jpegenc->output_mem = new_memory;
 206   jpegenc->output_map = map;
 207
 208   /* and last, update libjpeg on where to work. */
 209   jpegenc->jdest.next_output_byte = new_data + old_size;
 210   jpegenc->jdest.free_in_buffer = new_size - old_size;
 211 }
 212
 213 static boolean
 214 gst_jpegenc_flush_destination (j_compress_ptr cinfo)
 215 {
 216   GstJpegEnc *jpegenc = (GstJpegEnc *) (cinfo->client_data);
 217
 218   GST_DEBUG_OBJECT (jpegenc,
 219       "gst_jpegenc_chain: flush_destination: buffer too small");
 220
 221   ensure_memory (jpegenc);
 222
 223   return TRUE;
 224 }
 225
 226 static void
 227 gst_jpegenc_term_destination (j_compress_ptr cinfo)
 228 {
 229   GstBuffer *outbuf;
 230   GstJpegEnc *jpegenc = (GstJpegEnc *) (cinfo->client_data);
 231
 232   GST_DEBUG_OBJECT (jpegenc, "gst_jpegenc_chain: term_source");
 233
 234   gst_memory_unmap (jpegenc->output_mem, &jpegenc->output_map);
 235   /* Trim the buffer size. we will push it in the chain function */
 236   gst_memory_resize (jpegenc->output_mem, 0,
 237       jpegenc->output_map.size - jpegenc->jdest.free_in_buffer);
 238   jpegenc->output_map.data = NULL;
 239   jpegenc->output_map.size = 0;
 240
 241   outbuf = gst_buffer_new ();
 242   gst_buffer_copy_into (outbuf, jpegenc->current_frame->input_buffer,
 243       GST_BUFFER_COPY_METADATA, 0, -1);
 244   gst_buffer_append_memory (outbuf, jpegenc->output_mem);
 245   jpegenc->output_mem = NULL;
 246
 247   jpegenc->current_frame->output_buffer = outbuf;
 248
 249   gst_video_frame_unmap (&jpegenc->current_vframe);
 250
 251   GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (jpegenc->current_frame);
 252
 253   gst_video_encoder_finish_frame (GST_VIDEO_ENCODER (jpegenc),
 254       jpegenc->current_frame);
 255   jpegenc->current_frame = NULL;
 256 }
 257
 258 static void
 259 gst_jpegenc_init (GstJpegEnc * jpegenc)
 260 {
 261   /* setup jpeglib */
 262   memset (&jpegenc->cinfo, 0, sizeof (jpegenc->cinfo));
 263   memset (&jpegenc->jerr, 0, sizeof (jpegenc->jerr));
 264   jpegenc->cinfo.err = jpeg_std_error (&jpegenc->jerr);
 265   jpeg_create_compress (&jpegenc->cinfo);
 266
 267   jpegenc->jdest.init_destination = gst_jpegenc_init_destination;
 268   jpegenc->jdest.empty_output_buffer = gst_jpegenc_flush_destination;
 269   jpegenc->jdest.term_destination = gst_jpegenc_term_destination;
 270   jpegenc->cinfo.dest = &jpegenc->jdest;
 271   jpegenc->cinfo.client_data = jpegenc;
 272
 273   /* init properties */
 274   jpegenc->quality = JPEG_DEFAULT_QUALITY;
 275   jpegenc->smoothing = JPEG_DEFAULT_SMOOTHING;
 276   jpegenc->idct_method = JPEG_DEFAULT_IDCT_METHOD;
 277
 278   gst_jpegenc_reset (jpegenc);
 279 }
 280
 281 static void
 282 gst_jpegenc_reset (GstJpegEnc * enc)
 283 {
 284   gint i, j;
 285
 286   g_free (enc->line[0]);
 287   g_free (enc->line[1]);
 288   g_free (enc->line[2]);
 289   enc->line[0] = NULL;
 290   enc->line[1] = NULL;
 291   enc->line[2] = NULL;
 292   for (i = 0; i < 3; i++) {
 293     for (j = 0; j < 4 * DCTSIZE; j++) {
 294       g_free (enc->row[i][j]);
 295       enc->row[i][j] = NULL;
 296     }
 297   }
 298 }
 299
 300 static void
 301 gst_jpegenc_finalize (GObject * object)
 302 {
 303   GstJpegEnc *filter = GST_JPEGENC (object);
 304
 305   jpeg_destroy_compress (&filter->cinfo);
 306
 307   if (filter->input_state)
 308     gst_video_codec_state_unref (filter->input_state);
 309
 310   G_OBJECT_CLASS (parent_class)->finalize (object);
 311 }
 312
 313 static gboolean
 314 gst_jpegenc_set_format (GstVideoEncoder * encoder, GstVideoCodecState * state)
 315 {
 316   GstJpegEnc *enc = GST_JPEGENC (encoder);
 317   gint i;
 318   GstVideoInfo *info = &state->info;
 319   GstVideoCodecState *output;
 320
 321   if (enc->input_state)
 322     gst_video_codec_state_unref (enc->input_state);
 323   enc->input_state = gst_video_codec_state_ref (state);
 324
 325   /* prepare a cached image description  */
 326   enc->channels = GST_VIDEO_INFO_N_COMPONENTS (info);
 327
 328   /* ... but any alpha is disregarded in encoding */
 329   if (GST_VIDEO_INFO_IS_GRAY (info))
 330     enc->channels = 1;
 331
 332   enc->h_max_samp = 0;
 333   enc->v_max_samp = 0;
 334   for (i = 0; i < enc->channels; ++i) {
 335     enc->cwidth[i] = GST_VIDEO_INFO_COMP_WIDTH (info, i);
 336     enc->cheight[i] = GST_VIDEO_INFO_COMP_HEIGHT (info, i);
 337     enc->inc[i] = GST_VIDEO_INFO_COMP_PSTRIDE (info, i);
 338     enc->h_samp[i] =
 339         GST_ROUND_UP_4 (GST_VIDEO_INFO_WIDTH (info)) / enc->cwidth[i];
 340     enc->h_max_samp = MAX (enc->h_max_samp, enc->h_samp[i]);
 341     enc->v_samp[i] =
 342         GST_ROUND_UP_4 (GST_VIDEO_INFO_HEIGHT (info)) / enc->cheight[i];
 343     enc->v_max_samp = MAX (enc->v_max_samp, enc->v_samp[i]);
 344   }
 345   /* samp should only be 1, 2 or 4 */
 346   g_assert (enc->h_max_samp <= 4);
 347   g_assert (enc->v_max_samp <= 4);
 348
 349   /* now invert */
 350   /* maximum is invariant, as one of the components should have samp 1 */
 351   for (i = 0; i < enc->channels; ++i) {
 352     GST_DEBUG ("%d %d", enc->h_samp[i], enc->h_max_samp);
 353     enc->h_samp[i] = enc->h_max_samp / enc->h_samp[i];
 354     enc->v_samp[i] = enc->v_max_samp / enc->v_samp[i];
 355   }
 356   enc->planar = (enc->inc[0] == 1 && enc->inc[1] == 1 && enc->inc[2] == 1);
 357
 358   output =
 359       gst_video_encoder_set_output_state (encoder,
 360       gst_caps_new_empty_simple ("image/jpeg"), state);
 361   gst_video_codec_state_unref (output);
 362
 363   gst_jpegenc_resync (enc);
 364
 365   return TRUE;
 366 }
 367
 368 static void
 369 gst_jpegenc_resync (GstJpegEnc * jpegenc)
 370 {
 371   GstVideoInfo *info;
 372   gint width, height;
 373   gint i, j;
 374
 375   GST_DEBUG_OBJECT (jpegenc, "resync");
 376
 377   if (!jpegenc->input_state)
 378     return;
 379
 380   info = &jpegenc->input_state->info;
 381
 382   jpegenc->cinfo.image_width = width = GST_VIDEO_INFO_WIDTH (info);
 383   jpegenc->cinfo.image_height = height = GST_VIDEO_INFO_HEIGHT (info);
 384   jpegenc->cinfo.input_components = jpegenc->channels;
 385
 386   GST_DEBUG_OBJECT (jpegenc, "width %d, height %d", width, height);
 387   GST_DEBUG_OBJECT (jpegenc, "format %d", GST_VIDEO_INFO_FORMAT (info));
 388
 389   if (GST_VIDEO_INFO_IS_RGB (info)) {
 390     GST_DEBUG_OBJECT (jpegenc, "RGB");
 391     jpegenc->cinfo.in_color_space = JCS_RGB;
 392   } else if (GST_VIDEO_INFO_IS_GRAY (info)) {
 393     GST_DEBUG_OBJECT (jpegenc, "gray");
 394     jpegenc->cinfo.in_color_space = JCS_GRAYSCALE;
 395   } else {
 396     GST_DEBUG_OBJECT (jpegenc, "YUV");
 397     jpegenc->cinfo.in_color_space = JCS_YCbCr;
 398   }
 399
 400   /* input buffer size as max output */
 401   jpegenc->bufsize = GST_VIDEO_INFO_SIZE (info);
 402   jpeg_set_defaults (&jpegenc->cinfo);
 403   jpegenc->cinfo.raw_data_in = TRUE;
 404   /* duh, libjpeg maps RGB to YUV ... and don't expect some conversion */
 405   if (jpegenc->cinfo.in_color_space == JCS_RGB)
 406     jpeg_set_colorspace (&jpegenc->cinfo, JCS_RGB);
 407
 408   GST_DEBUG_OBJECT (jpegenc, "h_max_samp=%d, v_max_samp=%d",
 409       jpegenc->h_max_samp, jpegenc->v_max_samp);
 410   /* image dimension info */
 411   for (i = 0; i < jpegenc->channels; i++) {
 412     GST_DEBUG_OBJECT (jpegenc, "comp %i: h_samp=%d, v_samp=%d", i,
 413         jpegenc->h_samp[i], jpegenc->v_samp[i]);
 414     jpegenc->cinfo.comp_info[i].h_samp_factor = jpegenc->h_samp[i];
 415     jpegenc->cinfo.comp_info[i].v_samp_factor = jpegenc->v_samp[i];
 416     g_free (jpegenc->line[i]);
 417     jpegenc->line[i] = g_new (guchar *, jpegenc->v_max_samp * DCTSIZE);
 418     if (!jpegenc->planar) {
 419       for (j = 0; j < jpegenc->v_max_samp * DCTSIZE; j++) {
 420         g_free (jpegenc->row[i][j]);
 421         jpegenc->row[i][j] = g_malloc (width);
 422         jpegenc->line[i][j] = jpegenc->row[i][j];
 423       }
 424     }
 425   }
 426
 427   /* guard against a potential error in gst_jpegenc_term_destination
 428      which occurs iff bufsize % 4 < free_space_remaining */
 429   jpegenc->bufsize = GST_ROUND_UP_4 (jpegenc->bufsize);
 430
 431   jpeg_suppress_tables (&jpegenc->cinfo, TRUE);
 432
 433   GST_DEBUG_OBJECT (jpegenc, "resync done");
 434 }
 435
 436 static GstFlowReturn
 437 gst_jpegenc_handle_frame (GstVideoEncoder * encoder, GstVideoCodecFrame * frame)
 438 {
 439   GstJpegEnc *jpegenc;
 440   guint height;
 441   guchar *base[3], *end[3];
 442   guint stride[3];
 443   gint i, j, k;
 444   static GstAllocationParams params = { 0, 0, 0, 3, };
 445
 446   jpegenc = GST_JPEGENC (encoder);
 447
 448   GST_LOG_OBJECT (jpegenc, "got new frame");
 449
 450   if (!gst_video_frame_map (&jpegenc->current_vframe,
 451           &jpegenc->input_state->info, frame->input_buffer, GST_MAP_READ))
 452     goto invalid_frame;
 453
 454   jpegenc->current_frame = frame;
 455
 456   height = GST_VIDEO_INFO_HEIGHT (&jpegenc->input_state->info);
 457
 458   for (i = 0; i < jpegenc->channels; i++) {
 459     base[i] = GST_VIDEO_FRAME_COMP_DATA (&jpegenc->current_vframe, i);
 460     stride[i] = GST_VIDEO_FRAME_COMP_STRIDE (&jpegenc->current_vframe, i);
 461     end[i] =
 462         base[i] + GST_VIDEO_FRAME_COMP_HEIGHT (&jpegenc->current_vframe,
 463         i) * stride[i];
 464   }
 465
 466   jpegenc->output_mem = gst_allocator_alloc (NULL, jpegenc->bufsize, &params);
 467   gst_memory_map (jpegenc->output_mem, &jpegenc->output_map, GST_MAP_READWRITE);
 468
 469   jpegenc->jdest.next_output_byte = jpegenc->output_map.data;
 470   jpegenc->jdest.free_in_buffer = jpegenc->output_map.size;
 471
 472   /* prepare for raw input */
 473 #if JPEG_LIB_VERSION >= 70
 474   jpegenc->cinfo.do_fancy_downsampling = FALSE;
 475 #endif
 476   jpegenc->cinfo.smoothing_factor = jpegenc->smoothing;
 477   jpegenc->cinfo.dct_method = jpegenc->idct_method;
 478   jpeg_set_quality (&jpegenc->cinfo, jpegenc->quality, TRUE);
 479   jpeg_start_compress (&jpegenc->cinfo, TRUE);
 480
 481   GST_LOG_OBJECT (jpegenc, "compressing");
 482
 483   if (jpegenc->planar) {
 484     for (i = 0; i < height; i += jpegenc->v_max_samp * DCTSIZE) {
 485       for (k = 0; k < jpegenc->channels; k++) {
 486         for (j = 0; j < jpegenc->v_samp[k] * DCTSIZE; j++) {
 487           jpegenc->line[k][j] = base[k];
 488           if (base[k] + stride[k] < end[k])
 489             base[k] += stride[k];
 490         }
 491       }
 492       jpeg_write_raw_data (&jpegenc->cinfo, jpegenc->line,
 493           jpegenc->v_max_samp * DCTSIZE);
 494     }
 495   } else {
 496     for (i = 0; i < height; i += jpegenc->v_max_samp * DCTSIZE) {
 497       for (k = 0; k < jpegenc->channels; k++) {
 498         for (j = 0; j < jpegenc->v_samp[k] * DCTSIZE; j++) {
 499           guchar *src, *dst;
 500           gint l;
 501
 502           /* ouch, copy line */
 503           src = base[k];
 504           dst = jpegenc->line[k][j];
 505           for (l = jpegenc->cwidth[k]; l > 0; l--) {
 506             *dst = *src;
 507             src += jpegenc->inc[k];
 508             dst++;
 509           }
 510           if (base[k] + stride[k] < end[k])
 511             base[k] += stride[k];
 512         }
 513       }
 514       jpeg_write_raw_data (&jpegenc->cinfo, jpegenc->line,
 515           jpegenc->v_max_samp * DCTSIZE);
 516     }
 517   }
 518
 519   /* This will ensure that gst_jpegenc_term_destination is called */
 520   jpeg_finish_compress (&jpegenc->cinfo);
 521   GST_LOG_OBJECT (jpegenc, "compressing done");
 522
 523   return GST_FLOW_OK;
 524
 525 invalid_frame:
 526   {
 527     GST_WARNING_OBJECT (jpegenc, "invalid frame received");
 528     gst_video_encoder_finish_frame (encoder, frame);
 529     return GST_FLOW_OK;
 530   }
 531 }
 532
 533 static gboolean
 534 gst_jpegenc_propose_allocation (GstVideoEncoder * encoder, GstQuery * query)
 535 {
 536   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
 537
 538   return GST_VIDEO_ENCODER_CLASS (parent_class)->propose_allocation (encoder,
 539       query);
 540 }
 541
 542 static void
 543 gst_jpegenc_set_property (GObject * object, guint prop_id,
 544     const GValue * value, GParamSpec * pspec)
 545 {
 546   GstJpegEnc *jpegenc = GST_JPEGENC (object);
 547
 548   GST_OBJECT_LOCK (jpegenc);
 549
 550   switch (prop_id) {
 551     case PROP_QUALITY:
 552       jpegenc->quality = g_value_get_int (value);
 553       break;
 554 #ifdef ENABLE_SMOOTHING
 555     case PROP_SMOOTHING:
 556       jpegenc->smoothing = g_value_get_int (value);
 557       break;
 558 #endif
 559     case PROP_IDCT_METHOD:
 560       jpegenc->idct_method = g_value_get_enum (value);
 561       break;
 562     default:
 563       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 564       break;
 565   }
 566
 567   GST_OBJECT_UNLOCK (jpegenc);
 568 }
 569
 570 static void
 571 gst_jpegenc_get_property (GObject * object, guint prop_id, GValue * value,
 572     GParamSpec * pspec)
 573 {
 574   GstJpegEnc *jpegenc = GST_JPEGENC (object);
 575
 576   GST_OBJECT_LOCK (jpegenc);
 577
 578   switch (prop_id) {
 579     case PROP_QUALITY:
 580       g_value_set_int (value, jpegenc->quality);
 581       break;
 582 #ifdef ENABLE_SMOOTHING
 583     case PROP_SMOOTHING:
 584       g_value_set_int (value, jpegenc->smoothing);
 585       break;
 586 #endif
 587     case PROP_IDCT_METHOD:
 588       g_value_set_enum (value, jpegenc->idct_method);
 589       break;
 590     default:
 591       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 592       break;
 593   }
 594
 595   GST_OBJECT_UNLOCK (jpegenc);
 596 }
 597
 598 static gboolean
 599 gst_jpegenc_start (GstVideoEncoder * benc)
 600 {
 601   GstJpegEnc *enc = (GstJpegEnc *) benc;
 602
 603   enc->line[0] = NULL;
 604   enc->line[1] = NULL;
 605   enc->line[2] = NULL;
 606
 607   return TRUE;
 608 }
 609
 610 static gboolean
 611 gst_jpegenc_stop (GstVideoEncoder * benc)
 612 {
 613   GstJpegEnc *enc = (GstJpegEnc *) benc;
 614
 615   gst_jpegenc_reset (enc);
 616
 617   return TRUE;
 618 }