/* GStreamer * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu> * Copyright (C) 2012 Collabora Ltd. * Author : Edward Hervey <edward@collabora.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., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ /** * SECTION:element-jpegenc * * Encodes jpeg images. * * <refsect2> * <title>Example launch line</title> * |[ * gst-launch-1.0 videotestsrc num-buffers=50 ! video/x-raw, framerate='(fraction)'5/1 ! jpegenc ! avimux ! filesink location=mjpeg.avi * ]| a pipeline to mux 5 JPEG frames per second into a 10 sec. long motion jpeg * avi. * </refsect2> */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include <string.h> #include "gstjpegenc.h" #include "gstjpeg.h" #include <gst/video/video.h> #include <gst/video/gstvideometa.h> #include <gst/base/base.h> /* experimental */ /* setting smoothig seems to have no effect in libjepeg #define ENABLE_SMOOTHING 1 */ GST_DEBUG_CATEGORY_STATIC (jpegenc_debug); #define GST_CAT_DEFAULT jpegenc_debug #define JPEG_DEFAULT_QUALITY 85 #define JPEG_DEFAULT_SMOOTHING 0 #define JPEG_DEFAULT_IDCT_METHOD JDCT_FASTEST /* JpegEnc signals and args */ enum { /* FILL ME */ LAST_SIGNAL }; enum { PROP_0, PROP_QUALITY, PROP_SMOOTHING, PROP_IDCT_METHOD }; static void gst_jpegenc_finalize (GObject * object); static void gst_jpegenc_resync (GstJpegEnc * jpegenc); static void gst_jpegenc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void gst_jpegenc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static gboolean gst_jpegenc_start (GstVideoEncoder * benc); static gboolean gst_jpegenc_stop (GstVideoEncoder * benc); static gboolean gst_jpegenc_set_format (GstVideoEncoder * encoder, GstVideoCodecState * state); static GstFlowReturn gst_jpegenc_handle_frame (GstVideoEncoder * encoder, GstVideoCodecFrame * frame); static gboolean gst_jpegenc_propose_allocation (GstVideoEncoder * encoder, GstQuery * query); /* static guint gst_jpegenc_signals[LAST_SIGNAL] = { 0 }; */ #define gst_jpegenc_parent_class parent_class G_DEFINE_TYPE (GstJpegEnc, gst_jpegenc, GST_TYPE_VIDEO_ENCODER); /* *INDENT-OFF* */ static GstStaticPadTemplate gst_jpegenc_sink_pad_template = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ I420, YV12, YUY2, UYVY, Y41B, Y42B, YVYU, Y444, NV21, " "NV12, RGB, BGR, RGBx, xRGB, BGRx, xBGR, GRAY8 }")) ); /* *INDENT-ON* */ static GstStaticPadTemplate gst_jpegenc_src_pad_template = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("image/jpeg, " "width = (int) [ 16, 65535 ], " "height = (int) [ 16, 65535 ], " "framerate = (fraction) [ 0/1, MAX ], " "sof-marker = (int) { 0, 1, 2, 9 }") ); static void gst_jpegenc_class_init (GstJpegEncClass * klass) { GObjectClass *gobject_class; GstElementClass *element_class; GstVideoEncoderClass *venc_class; gobject_class = (GObjectClass *) klass; element_class = (GstElementClass *) klass; venc_class = (GstVideoEncoderClass *) klass; parent_class = g_type_class_peek_parent (klass); gobject_class->finalize = gst_jpegenc_finalize; gobject_class->set_property = gst_jpegenc_set_property; gobject_class->get_property = gst_jpegenc_get_property; g_object_class_install_property (gobject_class, PROP_QUALITY, g_param_spec_int ("quality", "Quality", "Quality of encoding", 0, 100, JPEG_DEFAULT_QUALITY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); #ifdef ENABLE_SMOOTHING /* disabled, since it doesn't seem to work */ g_object_class_install_property (gobject_class, PROP_SMOOTHING, g_param_spec_int ("smoothing", "Smoothing", "Smoothing factor", 0, 100, JPEG_DEFAULT_SMOOTHING, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); #endif g_object_class_install_property (gobject_class, PROP_IDCT_METHOD, g_param_spec_enum ("idct-method", "IDCT Method", "The IDCT algorithm to use", GST_TYPE_IDCT_METHOD, JPEG_DEFAULT_IDCT_METHOD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); gst_element_class_add_static_pad_template (element_class, &gst_jpegenc_sink_pad_template); gst_element_class_add_static_pad_template (element_class, &gst_jpegenc_src_pad_template); gst_element_class_set_static_metadata (element_class, "JPEG image encoder", "Codec/Encoder/Image", "Encode images in JPEG format", "Wim Taymans <wim.taymans@tvd.be>"); venc_class->start = gst_jpegenc_start; venc_class->stop = gst_jpegenc_stop; venc_class->set_format = gst_jpegenc_set_format; venc_class->handle_frame = gst_jpegenc_handle_frame; venc_class->propose_allocation = gst_jpegenc_propose_allocation; GST_DEBUG_CATEGORY_INIT (jpegenc_debug, "jpegenc", 0, "JPEG encoding element"); } static void gst_jpegenc_init_destination (j_compress_ptr cinfo) { GST_DEBUG ("gst_jpegenc_chain: init_destination"); } static void ensure_memory (GstJpegEnc * jpegenc) { GstMemory *new_memory; GstMapInfo map; gsize old_size, desired_size, new_size; guint8 *new_data; static GstAllocationParams params = { 0, 3, 0, 0, }; old_size = jpegenc->output_map.size; if (old_size == 0) desired_size = jpegenc->bufsize; else desired_size = old_size * 2; /* Our output memory wasn't big enough. * Make a new memory that's twice the size, */ new_memory = gst_allocator_alloc (NULL, desired_size, ¶ms); gst_memory_map (new_memory, &map, GST_MAP_READWRITE); new_data = map.data; new_size = map.size; /* copy previous data if any */ if (jpegenc->output_mem) { memcpy (new_data, jpegenc->output_map.data, old_size); gst_memory_unmap (jpegenc->output_mem, &jpegenc->output_map); gst_memory_unref (jpegenc->output_mem); } /* drop it into place, */ jpegenc->output_mem = new_memory; jpegenc->output_map = map; /* and last, update libjpeg on where to work. */ jpegenc->jdest.next_output_byte = new_data + old_size; jpegenc->jdest.free_in_buffer = new_size - old_size; } static boolean gst_jpegenc_flush_destination (j_compress_ptr cinfo) { GstJpegEnc *jpegenc = (GstJpegEnc *) (cinfo->client_data); GST_DEBUG_OBJECT (jpegenc, "gst_jpegenc_chain: flush_destination: buffer too small"); ensure_memory (jpegenc); return TRUE; } static void gst_jpegenc_term_destination (j_compress_ptr cinfo) { GstBuffer *outbuf; GstJpegEnc *jpegenc = (GstJpegEnc *) (cinfo->client_data); gsize memory_size = jpegenc->output_map.size - jpegenc->jdest.free_in_buffer; GstByteReader reader = GST_BYTE_READER_INIT (jpegenc->output_map.data, memory_size); guint16 marker; gint sof_marker = -1; GST_DEBUG_OBJECT (jpegenc, "gst_jpegenc_chain: term_source"); /* Find the SOF marker */ while (gst_byte_reader_get_uint16_be (&reader, &marker)) { /* SOF marker */ if (marker >> 4 == 0x0ffc) { sof_marker = marker & 0x4; break; } } gst_memory_unmap (jpegenc->output_mem, &jpegenc->output_map); /* Trim the buffer size. we will push it in the chain function */ gst_memory_resize (jpegenc->output_mem, 0, memory_size); jpegenc->output_map.data = NULL; jpegenc->output_map.size = 0; if (jpegenc->sof_marker != sof_marker) { GstVideoCodecState *output; output = gst_video_encoder_set_output_state (GST_VIDEO_ENCODER (jpegenc), gst_caps_new_simple ("image/jpeg", "sof-marker", G_TYPE_INT, sof_marker, NULL), jpegenc->input_state); gst_video_codec_state_unref (output); jpegenc->sof_marker = sof_marker; } outbuf = gst_buffer_new (); gst_buffer_copy_into (outbuf, jpegenc->current_frame->input_buffer, GST_BUFFER_COPY_METADATA, 0, -1); gst_buffer_append_memory (outbuf, jpegenc->output_mem); jpegenc->output_mem = NULL; jpegenc->current_frame->output_buffer = outbuf; gst_video_frame_unmap (&jpegenc->current_vframe); GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (jpegenc->current_frame); jpegenc->res = gst_video_encoder_finish_frame (GST_VIDEO_ENCODER (jpegenc), jpegenc->current_frame); jpegenc->current_frame = NULL; } static void gst_jpegenc_init (GstJpegEnc * jpegenc) { GST_PAD_SET_ACCEPT_TEMPLATE (GST_VIDEO_ENCODER_SINK_PAD (jpegenc)); /* setup jpeglib */ memset (&jpegenc->cinfo, 0, sizeof (jpegenc->cinfo)); memset (&jpegenc->jerr, 0, sizeof (jpegenc->jerr)); jpegenc->cinfo.err = jpeg_std_error (&jpegenc->jerr); jpeg_create_compress (&jpegenc->cinfo); jpegenc->jdest.init_destination = gst_jpegenc_init_destination; jpegenc->jdest.empty_output_buffer = gst_jpegenc_flush_destination; jpegenc->jdest.term_destination = gst_jpegenc_term_destination; jpegenc->cinfo.dest = &jpegenc->jdest; jpegenc->cinfo.client_data = jpegenc; /* init properties */ jpegenc->quality = JPEG_DEFAULT_QUALITY; jpegenc->smoothing = JPEG_DEFAULT_SMOOTHING; jpegenc->idct_method = JPEG_DEFAULT_IDCT_METHOD; } static void gst_jpegenc_finalize (GObject * object) { GstJpegEnc *filter = GST_JPEGENC (object); jpeg_destroy_compress (&filter->cinfo); if (filter->input_state) gst_video_codec_state_unref (filter->input_state); G_OBJECT_CLASS (parent_class)->finalize (object); } static gboolean gst_jpegenc_set_format (GstVideoEncoder * encoder, GstVideoCodecState * state) { GstJpegEnc *enc = GST_JPEGENC (encoder); gint i; GstVideoInfo *info = &state->info; if (enc->input_state) gst_video_codec_state_unref (enc->input_state); enc->input_state = gst_video_codec_state_ref (state); /* prepare a cached image description */ enc->channels = GST_VIDEO_INFO_N_COMPONENTS (info); /* ... but any alpha is disregarded in encoding */ if (GST_VIDEO_INFO_IS_GRAY (info)) enc->channels = 1; enc->h_max_samp = 0; enc->v_max_samp = 0; for (i = 0; i < enc->channels; ++i) { enc->cwidth[i] = GST_VIDEO_INFO_COMP_WIDTH (info, i); enc->cheight[i] = GST_VIDEO_INFO_COMP_HEIGHT (info, i); enc->inc[i] = GST_VIDEO_INFO_COMP_PSTRIDE (info, i); enc->h_samp[i] = GST_ROUND_UP_4 (GST_VIDEO_INFO_WIDTH (info)) / enc->cwidth[i]; enc->h_max_samp = MAX (enc->h_max_samp, enc->h_samp[i]); enc->v_samp[i] = GST_ROUND_UP_4 (GST_VIDEO_INFO_HEIGHT (info)) / enc->cheight[i]; enc->v_max_samp = MAX (enc->v_max_samp, enc->v_samp[i]); } /* samp should only be 1, 2 or 4 */ g_assert (enc->h_max_samp <= 4); g_assert (enc->v_max_samp <= 4); /* now invert */ /* maximum is invariant, as one of the components should have samp 1 */ for (i = 0; i < enc->channels; ++i) { GST_DEBUG ("%d %d", enc->h_samp[i], enc->h_max_samp); enc->h_samp[i] = enc->h_max_samp / enc->h_samp[i]; enc->v_samp[i] = enc->v_max_samp / enc->v_samp[i]; } enc->planar = (enc->inc[0] == 1 && enc->inc[1] == 1 && enc->inc[2] == 1); gst_jpegenc_resync (enc); return TRUE; } static void gst_jpegenc_resync (GstJpegEnc * jpegenc) { GstVideoInfo *info; gint width, height; gint i, j; GST_DEBUG_OBJECT (jpegenc, "resync"); if (!jpegenc->input_state) return; info = &jpegenc->input_state->info; jpegenc->cinfo.image_width = width = GST_VIDEO_INFO_WIDTH (info); jpegenc->cinfo.image_height = height = GST_VIDEO_INFO_HEIGHT (info); jpegenc->cinfo.input_components = jpegenc->channels; GST_DEBUG_OBJECT (jpegenc, "width %d, height %d", width, height); GST_DEBUG_OBJECT (jpegenc, "format %d", GST_VIDEO_INFO_FORMAT (info)); if (GST_VIDEO_INFO_IS_RGB (info)) { GST_DEBUG_OBJECT (jpegenc, "RGB"); jpegenc->cinfo.in_color_space = JCS_RGB; } else if (GST_VIDEO_INFO_IS_GRAY (info)) { GST_DEBUG_OBJECT (jpegenc, "gray"); jpegenc->cinfo.in_color_space = JCS_GRAYSCALE; } else { GST_DEBUG_OBJECT (jpegenc, "YUV"); jpegenc->cinfo.in_color_space = JCS_YCbCr; } /* input buffer size as max output */ jpegenc->bufsize = GST_VIDEO_INFO_SIZE (info); jpeg_set_defaults (&jpegenc->cinfo); jpegenc->cinfo.raw_data_in = TRUE; /* duh, libjpeg maps RGB to YUV ... and don't expect some conversion */ if (jpegenc->cinfo.in_color_space == JCS_RGB) jpeg_set_colorspace (&jpegenc->cinfo, JCS_RGB); GST_DEBUG_OBJECT (jpegenc, "h_max_samp=%d, v_max_samp=%d", jpegenc->h_max_samp, jpegenc->v_max_samp); /* image dimension info */ for (i = 0; i < jpegenc->channels; i++) { GST_DEBUG_OBJECT (jpegenc, "comp %i: h_samp=%d, v_samp=%d", i, jpegenc->h_samp[i], jpegenc->v_samp[i]); jpegenc->cinfo.comp_info[i].h_samp_factor = jpegenc->h_samp[i]; jpegenc->cinfo.comp_info[i].v_samp_factor = jpegenc->v_samp[i]; g_free (jpegenc->line[i]); jpegenc->line[i] = g_new (guchar *, jpegenc->v_max_samp * DCTSIZE); if (!jpegenc->planar) { for (j = 0; j < jpegenc->v_max_samp * DCTSIZE; j++) { g_free (jpegenc->row[i][j]); jpegenc->row[i][j] = g_malloc (width); jpegenc->line[i][j] = jpegenc->row[i][j]; } } } /* guard against a potential error in gst_jpegenc_term_destination which occurs iff bufsize % 4 < free_space_remaining */ jpegenc->bufsize = GST_ROUND_UP_4 (jpegenc->bufsize); jpeg_suppress_tables (&jpegenc->cinfo, TRUE); GST_DEBUG_OBJECT (jpegenc, "resync done"); } static GstFlowReturn gst_jpegenc_handle_frame (GstVideoEncoder * encoder, GstVideoCodecFrame * frame) { GstJpegEnc *jpegenc; guint height; guchar *base[3], *end[3]; guint stride[3]; gint i, j, k; static GstAllocationParams params = { 0, 0, 0, 3, }; jpegenc = GST_JPEGENC (encoder); GST_LOG_OBJECT (jpegenc, "got new frame"); if (!gst_video_frame_map (&jpegenc->current_vframe, &jpegenc->input_state->info, frame->input_buffer, GST_MAP_READ)) goto invalid_frame; jpegenc->current_frame = frame; height = GST_VIDEO_INFO_HEIGHT (&jpegenc->input_state->info); for (i = 0; i < jpegenc->channels; i++) { base[i] = GST_VIDEO_FRAME_COMP_DATA (&jpegenc->current_vframe, i); stride[i] = GST_VIDEO_FRAME_COMP_STRIDE (&jpegenc->current_vframe, i); end[i] = base[i] + GST_VIDEO_FRAME_COMP_HEIGHT (&jpegenc->current_vframe, i) * stride[i]; } jpegenc->res = GST_FLOW_OK; jpegenc->output_mem = gst_allocator_alloc (NULL, jpegenc->bufsize, ¶ms); gst_memory_map (jpegenc->output_mem, &jpegenc->output_map, GST_MAP_READWRITE); jpegenc->jdest.next_output_byte = jpegenc->output_map.data; jpegenc->jdest.free_in_buffer = jpegenc->output_map.size; /* prepare for raw input */ #if JPEG_LIB_VERSION >= 70 jpegenc->cinfo.do_fancy_downsampling = FALSE; #endif jpegenc->cinfo.smoothing_factor = jpegenc->smoothing; jpegenc->cinfo.dct_method = jpegenc->idct_method; jpeg_set_quality (&jpegenc->cinfo, jpegenc->quality, TRUE); jpeg_start_compress (&jpegenc->cinfo, TRUE); GST_LOG_OBJECT (jpegenc, "compressing"); if (jpegenc->planar) { for (i = 0; i < height; i += jpegenc->v_max_samp * DCTSIZE) { for (k = 0; k < jpegenc->channels; k++) { for (j = 0; j < jpegenc->v_samp[k] * DCTSIZE; j++) { jpegenc->line[k][j] = base[k]; if (base[k] + stride[k] < end[k]) base[k] += stride[k]; } } jpeg_write_raw_data (&jpegenc->cinfo, jpegenc->line, jpegenc->v_max_samp * DCTSIZE); } } else { for (i = 0; i < height; i += jpegenc->v_max_samp * DCTSIZE) { for (k = 0; k < jpegenc->channels; k++) { for (j = 0; j < jpegenc->v_samp[k] * DCTSIZE; j++) { guchar *src, *dst; gint l; /* ouch, copy line */ src = base[k]; dst = jpegenc->line[k][j]; for (l = jpegenc->cwidth[k]; l > 0; l--) { *dst = *src; src += jpegenc->inc[k]; dst++; } if (base[k] + stride[k] < end[k]) base[k] += stride[k]; } } jpeg_write_raw_data (&jpegenc->cinfo, jpegenc->line, jpegenc->v_max_samp * DCTSIZE); } } /* This will ensure that gst_jpegenc_term_destination is called */ jpeg_finish_compress (&jpegenc->cinfo); GST_LOG_OBJECT (jpegenc, "compressing done"); return jpegenc->res; invalid_frame: { GST_WARNING_OBJECT (jpegenc, "invalid frame received"); return gst_video_encoder_finish_frame (encoder, frame); } } static gboolean gst_jpegenc_propose_allocation (GstVideoEncoder * encoder, GstQuery * query) { gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL); return GST_VIDEO_ENCODER_CLASS (parent_class)->propose_allocation (encoder, query); } static void gst_jpegenc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstJpegEnc *jpegenc = GST_JPEGENC (object); GST_OBJECT_LOCK (jpegenc); switch (prop_id) { case PROP_QUALITY: jpegenc->quality = g_value_get_int (value); break; #ifdef ENABLE_SMOOTHING case PROP_SMOOTHING: jpegenc->smoothing = g_value_get_int (value); break; #endif case PROP_IDCT_METHOD: jpegenc->idct_method = g_value_get_enum (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } GST_OBJECT_UNLOCK (jpegenc); } static void gst_jpegenc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstJpegEnc *jpegenc = GST_JPEGENC (object); GST_OBJECT_LOCK (jpegenc); switch (prop_id) { case PROP_QUALITY: g_value_set_int (value, jpegenc->quality); break; #ifdef ENABLE_SMOOTHING case PROP_SMOOTHING: g_value_set_int (value, jpegenc->smoothing); break; #endif case PROP_IDCT_METHOD: g_value_set_enum (value, jpegenc->idct_method); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } GST_OBJECT_UNLOCK (jpegenc); } static gboolean gst_jpegenc_start (GstVideoEncoder * benc) { GstJpegEnc *enc = (GstJpegEnc *) benc; enc->line[0] = NULL; enc->line[1] = NULL; enc->line[2] = NULL; enc->sof_marker = -1; return TRUE; } static gboolean gst_jpegenc_stop (GstVideoEncoder * benc) { GstJpegEnc *enc = (GstJpegEnc *) benc; gint i, j; g_free (enc->line[0]); g_free (enc->line[1]); g_free (enc->line[2]); enc->line[0] = NULL; enc->line[1] = NULL; enc->line[2] = NULL; for (i = 0; i < 3; i++) { for (j = 0; j < 4 * DCTSIZE; j++) { g_free (enc->row[i][j]); enc->row[i][j] = NULL; } } return TRUE; }