ext/jpeg/gstjpegdec.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
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24 #include <string.h>
  25
  26 /*#define DEBUG_ENABLED*/
  27 #include "gstjpegdec.h"
  28 #include <gst/video/video.h>
  29
  30 /* elementfactory information */
  31 GstElementDetails gst_jpegdec_details = {
  32   "JPEG image decoder",
  33   "Codec/Decoder/Image",
  34   "Decode images from JPEG format",
  35   "Wim Taymans <wim.taymans@tvd.be>",
  36 };
  37
  38 /* JpegDec signals and args */
  39 enum
  40 {
  41   /* FILL ME */
  42   LAST_SIGNAL
  43 };
  44
  45 enum
  46 {
  47   ARG_0,
  48   /* FILL ME */
  49 };
  50
  51 static void gst_jpegdec_base_init (gpointer g_class);
  52 static void gst_jpegdec_class_init (GstJpegDec * klass);
  53 static void gst_jpegdec_init (GstJpegDec * jpegdec);
  54
  55 static void gst_jpegdec_chain (GstPad * pad, GstData * _data);
  56 static GstPadLinkReturn gst_jpegdec_link (GstPad * pad, const GstCaps * caps);
  57
  58 static GstElementClass *parent_class = NULL;
  59
  60 /*static guint gst_jpegdec_signals[LAST_SIGNAL] = { 0 }; */
  61
  62 GType
  63 gst_jpegdec_get_type (void)
  64 {
  65   static GType jpegdec_type = 0;
  66
  67   if (!jpegdec_type) {
  68     static const GTypeInfo jpegdec_info = {
  69       sizeof (GstJpegDec),
  70       gst_jpegdec_base_init,
  71       NULL,
  72       (GClassInitFunc) gst_jpegdec_class_init,
  73       NULL,
  74       NULL,
  75       sizeof (GstJpegDec),
  76       0,
  77       (GInstanceInitFunc) gst_jpegdec_init,
  78     };
  79     jpegdec_type =
  80         g_type_register_static (GST_TYPE_ELEMENT, "GstJpegDec", &jpegdec_info,
  81         0);
  82   }
  83   return jpegdec_type;
  84 }
  85
  86 static GstStaticPadTemplate gst_jpegdec_src_pad_template =
  87 GST_STATIC_PAD_TEMPLATE ("src",
  88     GST_PAD_SRC,
  89     GST_PAD_ALWAYS,
  90     GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("I420"))
  91     );
  92
  93 static GstStaticPadTemplate gst_jpegdec_sink_pad_template =
  94 GST_STATIC_PAD_TEMPLATE ("sink",
  95     GST_PAD_SINK,
  96     GST_PAD_ALWAYS,
  97     GST_STATIC_CAPS ("image/jpeg, "
  98         "width = (int) [ 16, 4096 ], "
  99         "height = (int) [ 16, 4096 ], " "framerate = (double) [ 1, MAX ]")
 100     );
 101
 102 static void
 103 gst_jpegdec_base_init (gpointer g_class)
 104 {
 105   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 106
 107   gst_element_class_add_pad_template (element_class,
 108       gst_static_pad_template_get (&gst_jpegdec_src_pad_template));
 109   gst_element_class_add_pad_template (element_class,
 110       gst_static_pad_template_get (&gst_jpegdec_sink_pad_template));
 111   gst_element_class_set_details (element_class, &gst_jpegdec_details);
 112 }
 113
 114 static void
 115 gst_jpegdec_class_init (GstJpegDec * klass)
 116 {
 117   GstElementClass *gstelement_class;
 118
 119   gstelement_class = (GstElementClass *) klass;
 120
 121   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 122 }
 123
 124 static void
 125 gst_jpegdec_init_source (j_decompress_ptr cinfo)
 126 {
 127   GST_DEBUG ("gst_jpegdec_chain: init_source");
 128 }
 129
 130 static gboolean
 131 gst_jpegdec_fill_input_buffer (j_decompress_ptr cinfo)
 132 {
 133   GST_DEBUG ("gst_jpegdec_chain: fill_input_buffer");
 134   return TRUE;
 135 }
 136
 137 static void
 138 gst_jpegdec_skip_input_data (j_decompress_ptr cinfo, glong num_bytes)
 139 {
 140   GST_DEBUG ("gst_jpegdec_chain: skip_input_data");
 141 }
 142
 143 static gboolean
 144 gst_jpegdec_resync_to_restart (j_decompress_ptr cinfo, gint desired)
 145 {
 146   GST_DEBUG ("gst_jpegdec_chain: resync_to_start");
 147   return TRUE;
 148 }
 149
 150 static void
 151 gst_jpegdec_term_source (j_decompress_ptr cinfo)
 152 {
 153   GST_DEBUG ("gst_jpegdec_chain: term_source");
 154 }
 155
 156 static void
 157 gst_jpegdec_init (GstJpegDec * jpegdec)
 158 {
 159   GST_DEBUG ("gst_jpegdec_init: initializing");
 160   /* create the sink and src pads */
 161
 162   jpegdec->sinkpad =
 163       gst_pad_new_from_template (gst_static_pad_template_get
 164       (&gst_jpegdec_sink_pad_template), "sink");
 165   gst_element_add_pad (GST_ELEMENT (jpegdec), jpegdec->sinkpad);
 166   gst_pad_set_chain_function (jpegdec->sinkpad, gst_jpegdec_chain);
 167   gst_pad_set_link_function (jpegdec->sinkpad, gst_jpegdec_link);
 168
 169   jpegdec->srcpad =
 170       gst_pad_new_from_template (gst_static_pad_template_get
 171       (&gst_jpegdec_src_pad_template), "src");
 172   gst_pad_use_explicit_caps (jpegdec->srcpad);
 173   gst_element_add_pad (GST_ELEMENT (jpegdec), jpegdec->srcpad);
 174
 175   /* initialize the jpegdec decoder state */
 176   jpegdec->next_time = 0;
 177
 178   /* reset the initial video state */
 179   jpegdec->format = -1;
 180   jpegdec->width = -1;
 181   jpegdec->height = -1;
 182
 183   jpegdec->line[0] = NULL;
 184   jpegdec->line[1] = NULL;
 185   jpegdec->line[2] = NULL;
 186
 187   /* setup jpeglib */
 188   memset (&jpegdec->cinfo, 0, sizeof (jpegdec->cinfo));
 189   memset (&jpegdec->jerr, 0, sizeof (jpegdec->jerr));
 190   jpegdec->cinfo.err = jpeg_std_error (&jpegdec->jerr);
 191   jpeg_create_decompress (&jpegdec->cinfo);
 192
 193   jpegdec->jsrc.init_source = gst_jpegdec_init_source;
 194   jpegdec->jsrc.fill_input_buffer = gst_jpegdec_fill_input_buffer;
 195   jpegdec->jsrc.skip_input_data = gst_jpegdec_skip_input_data;
 196   jpegdec->jsrc.resync_to_restart = gst_jpegdec_resync_to_restart;
 197   jpegdec->jsrc.term_source = gst_jpegdec_term_source;
 198   jpegdec->cinfo.src = &jpegdec->jsrc;
 199
 200 }
 201
 202 static GstPadLinkReturn
 203 gst_jpegdec_link (GstPad * pad, const GstCaps * caps)
 204 {
 205   GstJpegDec *jpegdec = GST_JPEGDEC (gst_pad_get_parent (pad));
 206   GstStructure *structure;
 207   GstCaps *srccaps;
 208
 209   structure = gst_caps_get_structure (caps, 0);
 210
 211   gst_structure_get_double (structure, "framerate", &jpegdec->fps);
 212   gst_structure_get_int (structure, "width", &jpegdec->width);
 213   gst_structure_get_int (structure, "height", &jpegdec->height);
 214
 215   srccaps = gst_caps_new_simple ("video/x-raw-yuv",
 216       "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
 217       "width", G_TYPE_INT, jpegdec->width,
 218       "height", G_TYPE_INT, jpegdec->height,
 219       "framerate", G_TYPE_DOUBLE, jpegdec->fps, NULL);
 220
 221   /* at this point, we're pretty sure that this will be the output
 222    * format, so we'll set it. */
 223   gst_pad_set_explicit_caps (jpegdec->srcpad, srccaps);
 224
 225   return GST_PAD_LINK_OK;
 226 }
 227
 228 /* shamelessly ripped from jpegutils.c in mjpegtools */
 229 static void
 230 add_huff_table (j_decompress_ptr dinfo,
 231     JHUFF_TBL ** htblptr, const UINT8 * bits, const UINT8 * val)
 232 /* Define a Huffman table */
 233 {
 234   int nsymbols, len;
 235
 236   if (*htblptr == NULL)
 237     *htblptr = jpeg_alloc_huff_table ((j_common_ptr) dinfo);
 238
 239   /* Copy the number-of-symbols-of-each-code-length counts */
 240   memcpy ((*htblptr)->bits, bits, sizeof ((*htblptr)->bits));
 241
 242   /* Validate the counts.  We do this here mainly so we can copy the right
 243    * number of symbols from the val[] array, without risking marching off
 244    * the end of memory.  jchuff.c will do a more thorough test later.
 245    */
 246   nsymbols = 0;
 247   for (len = 1; len <= 16; len++)
 248     nsymbols += bits[len];
 249   if (nsymbols < 1 || nsymbols > 256)
 250     g_error ("jpegutils.c:  add_huff_table failed badly. ");
 251
 252   memcpy ((*htblptr)->huffval, val, nsymbols * sizeof (UINT8));
 253 }
 254
 255
 256
 257 static void
 258 std_huff_tables (j_decompress_ptr dinfo)
 259 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
 260 /* IMPORTANT: these are only valid for 8-bit data precision! */
 261 {
 262   static const UINT8 bits_dc_luminance[17] =
 263       { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
 264   static const UINT8 val_dc_luminance[] =
 265       { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 266
 267   static const UINT8 bits_dc_chrominance[17] =
 268       { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
 269   static const UINT8 val_dc_chrominance[] =
 270       { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 271
 272   static const UINT8 bits_ac_luminance[17] =
 273       { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
 274   static const UINT8 val_ac_luminance[] =
 275       { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
 276     0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
 277     0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
 278     0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
 279     0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
 280     0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
 281     0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 282     0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
 283     0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
 284     0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 285     0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 286     0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 287     0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
 288     0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 289     0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
 290     0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 291     0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 292     0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 293     0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 294     0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 295     0xf9, 0xfa
 296   };
 297
 298   static const UINT8 bits_ac_chrominance[17] =
 299       { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 300   static const UINT8 val_ac_chrominance[] =
 301       { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
 302     0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 303     0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
 304     0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
 305     0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
 306     0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
 307     0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 308     0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
 309     0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
 310     0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 311     0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
 312     0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 313     0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
 314     0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
 315     0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
 316     0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
 317     0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 318     0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
 319     0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 320     0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 321     0xf9, 0xfa
 322   };
 323
 324   add_huff_table (dinfo, &dinfo->dc_huff_tbl_ptrs[0],
 325       bits_dc_luminance, val_dc_luminance);
 326   add_huff_table (dinfo, &dinfo->ac_huff_tbl_ptrs[0],
 327       bits_ac_luminance, val_ac_luminance);
 328   add_huff_table (dinfo, &dinfo->dc_huff_tbl_ptrs[1],
 329       bits_dc_chrominance, val_dc_chrominance);
 330   add_huff_table (dinfo, &dinfo->ac_huff_tbl_ptrs[1],
 331       bits_ac_chrominance, val_ac_chrominance);
 332 }
 333
 334
 335
 336 static void
 337 guarantee_huff_tables (j_decompress_ptr dinfo)
 338 {
 339   if ((dinfo->dc_huff_tbl_ptrs[0] == NULL) &&
 340       (dinfo->dc_huff_tbl_ptrs[1] == NULL) &&
 341       (dinfo->ac_huff_tbl_ptrs[0] == NULL) &&
 342       (dinfo->ac_huff_tbl_ptrs[1] == NULL)) {
 343     GST_DEBUG ("Generating standard Huffman tables for this frame.");
 344     std_huff_tables (dinfo);
 345   }
 346 }
 347
 348 static void
 349 gst_jpegdec_chain (GstPad * pad, GstData * _data)
 350 {
 351   GstBuffer *buf = GST_BUFFER (_data);
 352   GstJpegDec *jpegdec;
 353   guchar *data, *outdata;
 354   gulong size, outsize;
 355   GstBuffer *outbuf;
 356
 357   /*GstMeta *meta; */
 358   gint width, height, width2;
 359   guchar *base[3];
 360   gint i, j, k;
 361   gint r_h, r_v;
 362
 363   g_return_if_fail (pad != NULL);
 364   g_return_if_fail (GST_IS_PAD (pad));
 365   g_return_if_fail (buf != NULL);
 366   /*g_return_if_fail(GST_IS_BUFFER(buf)); */
 367
 368   jpegdec = GST_JPEGDEC (GST_OBJECT_PARENT (pad));
 369
 370   if (!GST_PAD_IS_LINKED (jpegdec->srcpad)) {
 371     gst_buffer_unref (buf);
 372     return;
 373   }
 374
 375   data = (guchar *) GST_BUFFER_DATA (buf);
 376   size = GST_BUFFER_SIZE (buf);
 377   GST_DEBUG ("gst_jpegdec_chain: got buffer of %ld bytes in '%s'", size,
 378       GST_OBJECT_NAME (jpegdec));
 379
 380   jpegdec->jsrc.next_input_byte = data;
 381   jpegdec->jsrc.bytes_in_buffer = size;
 382
 383
 384   GST_DEBUG ("gst_jpegdec_chain: reading header %08lx", *(gulong *) data);
 385   jpeg_read_header (&jpegdec->cinfo, TRUE);
 386
 387   r_h = jpegdec->cinfo.cur_comp_info[0]->h_samp_factor;
 388   r_v = jpegdec->cinfo.cur_comp_info[0]->v_samp_factor;
 389
 390   /*g_print ("%d %d\n", r_h, r_v); */
 391   /*g_print ("%d %d\n", jpegdec->cinfo.cur_comp_info[1]->h_samp_factor, jpegdec->cinfo.cur_comp_info[1]->v_samp_factor); */
 392   /*g_print ("%d %d\n", jpegdec->cinfo.cur_comp_info[2]->h_samp_factor, jpegdec->cinfo.cur_comp_info[2]->v_samp_factor); */
 393
 394   jpegdec->cinfo.do_fancy_upsampling = FALSE;
 395   jpegdec->cinfo.do_block_smoothing = FALSE;
 396   jpegdec->cinfo.out_color_space = JCS_YCbCr;
 397   jpegdec->cinfo.dct_method = JDCT_IFAST;
 398   jpegdec->cinfo.raw_data_out = TRUE;
 399   GST_DEBUG ("gst_jpegdec_chain: starting decompress");
 400   guarantee_huff_tables (&jpegdec->cinfo);
 401   jpeg_start_decompress (&jpegdec->cinfo);
 402   width = jpegdec->cinfo.output_width;
 403   height = jpegdec->cinfo.output_height;
 404   GST_DEBUG ("gst_jpegdec_chain: width %d, height %d", width, height);
 405
 406   outbuf = gst_buffer_new ();
 407   outsize = GST_BUFFER_SIZE (outbuf) = width * height + width * height / 2;
 408   outdata = GST_BUFFER_DATA (outbuf) = g_malloc (outsize);
 409   GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
 410
 411   if (jpegdec->height != height || jpegdec->line[0] == NULL) {
 412     GstCaps *caps;
 413
 414     jpegdec->line[0] = g_realloc (jpegdec->line[0], height * sizeof (char *));
 415     jpegdec->line[1] = g_realloc (jpegdec->line[1], height * sizeof (char *));
 416     jpegdec->line[2] = g_realloc (jpegdec->line[2], height * sizeof (char *));
 417     jpegdec->height = height;
 418
 419     caps = gst_caps_new_simple ("video/x-raw-yuv",
 420         "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
 421         "width", G_TYPE_INT, width,
 422         "height", G_TYPE_INT, height,
 423         "framerate", G_TYPE_DOUBLE, jpegdec->fps, NULL);
 424     gst_pad_set_explicit_caps (jpegdec->srcpad, caps);
 425     gst_caps_free (caps);
 426   }
 427
 428   /* mind the swap, jpeglib outputs blue chroma first */
 429   base[0] = outdata;
 430   base[1] = base[0] + width * height;
 431   base[2] = base[1] + width * height / 4;
 432
 433   width2 = width >> 1;
 434
 435   GST_DEBUG ("gst_jpegdec_chain: decompressing %u",
 436       jpegdec->cinfo.rec_outbuf_height);
 437   for (i = 0; i < height; i += r_v * DCTSIZE) {
 438     for (j = 0, k = 0; j < (r_v * DCTSIZE); j += r_v, k++) {
 439       jpegdec->line[0][j] = base[0];
 440       base[0] += width;
 441       if (r_v == 2) {
 442         jpegdec->line[0][j + 1] = base[0];
 443         base[0] += width;
 444       }
 445       jpegdec->line[1][k] = base[1];
 446       jpegdec->line[2][k] = base[2];
 447       if (r_v == 2 || k & 1) {
 448         base[1] += width2;
 449         base[2] += width2;
 450       }
 451     }
 452     /*g_print ("%d\n", jpegdec->cinfo.output_scanline); */
 453     jpeg_read_raw_data (&jpegdec->cinfo, jpegdec->line, r_v * DCTSIZE);
 454   }
 455
 456   GST_DEBUG ("gst_jpegdec_chain: decompressing finished");
 457   jpeg_finish_decompress (&jpegdec->cinfo);
 458
 459   GST_DEBUG ("gst_jpegdec_chain: sending buffer");
 460   gst_pad_push (jpegdec->srcpad, GST_DATA (outbuf));
 461
 462   gst_buffer_unref (buf);
 463 }