ext/jpeg/gstjpegdec.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  * Copyright (C) <2009> Tim-Philipp Müller <tim centricular net>
   4  * Copyright (C) 2012 Collabora Ltd.
   5  *      Author : Edward Hervey <edward@collabora.com>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 /**
  24  * SECTION:element-jpegdec
  25  *
  26  * Decodes jpeg images.
  27  *
  28  * <refsect2>
  29  * <title>Example launch line</title>
  30  * |[
  31  * gst-launch-1.0 -v filesrc location=mjpeg.avi ! avidemux !  queue ! jpegdec ! videoconvert ! videoscale ! autovideosink
  32  * ]| The above pipeline decode the mjpeg stream and renders it to the screen.
  33  * </refsect2>
  34  */
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39 #include <string.h>
  40
  41 #include "gstjpegdec.h"
  42 #include "gstjpeg.h"
  43 #include <gst/video/video.h>
  44 #include <gst/video/gstvideometa.h>
  45 #include <gst/video/gstvideopool.h>
  46 #include "gst/gst-i18n-plugin.h"
  47 #include <jerror.h>
  48
  49 #define MIN_WIDTH  1
  50 #define MAX_WIDTH  65535
  51 #define MIN_HEIGHT 1
  52 #define MAX_HEIGHT 65535
  53
  54 #define CINFO_GET_JPEGDEC(cinfo_ptr) \
  55         (((struct GstJpegDecSourceMgr*)((cinfo_ptr)->src))->dec)
  56
  57 #define JPEG_DEFAULT_IDCT_METHOD        JDCT_FASTEST
  58 #define JPEG_DEFAULT_MAX_ERRORS         0
  59
  60 enum
  61 {
  62   PROP_0,
  63   PROP_IDCT_METHOD,
  64   PROP_MAX_ERRORS
  65 };
  66
  67 /* *INDENT-OFF* */
  68 static GstStaticPadTemplate gst_jpeg_dec_src_pad_template =
  69 GST_STATIC_PAD_TEMPLATE ("src",
  70     GST_PAD_SRC,
  71     GST_PAD_ALWAYS,
  72     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE
  73         ("{ I420, RGB, BGR, RGBx, xRGB, BGRx, xBGR, GRAY8 }"))
  74     );
  75 /* *INDENT-ON* */
  76
  77 /* FIXME: sof-marker is for IJG libjpeg 8, should be different for 6.2 */
  78 /* FIXME: add back "sof-marker = (int) { 0, 1, 2, 5, 6, 7, 9, 10, 13, 14 }"
  79  * once we have a parser and/or demuxer set caps properly */
  80 static GstStaticPadTemplate gst_jpeg_dec_sink_pad_template =
  81 GST_STATIC_PAD_TEMPLATE ("sink",
  82     GST_PAD_SINK,
  83     GST_PAD_ALWAYS,
  84     GST_STATIC_CAPS ("image/jpeg")
  85     );
  86
  87 GST_DEBUG_CATEGORY_STATIC (jpeg_dec_debug);
  88 #define GST_CAT_DEFAULT jpeg_dec_debug
  89 GST_DEBUG_CATEGORY_STATIC (GST_CAT_PERFORMANCE);
  90
  91 static void gst_jpeg_dec_set_property (GObject * object, guint prop_id,
  92     const GValue * value, GParamSpec * pspec);
  93 static void gst_jpeg_dec_get_property (GObject * object, guint prop_id,
  94     GValue * value, GParamSpec * pspec);
  95
  96 static gboolean gst_jpeg_dec_set_format (GstVideoDecoder * dec,
  97     GstVideoCodecState * state);
  98 static gboolean gst_jpeg_dec_start (GstVideoDecoder * bdec);
  99 static gboolean gst_jpeg_dec_stop (GstVideoDecoder * bdec);
 100 static gboolean gst_jpeg_dec_flush (GstVideoDecoder * bdec);
 101 static GstFlowReturn gst_jpeg_dec_parse (GstVideoDecoder * bdec,
 102     GstVideoCodecFrame * frame, GstAdapter * adapter, gboolean at_eos);
 103 static GstFlowReturn gst_jpeg_dec_handle_frame (GstVideoDecoder * bdec,
 104     GstVideoCodecFrame * frame);
 105 static gboolean gst_jpeg_dec_decide_allocation (GstVideoDecoder * bdec,
 106     GstQuery * query);
 107
 108 #define gst_jpeg_dec_parent_class parent_class
 109 G_DEFINE_TYPE (GstJpegDec, gst_jpeg_dec, GST_TYPE_VIDEO_DECODER);
 110
 111 static void
 112 gst_jpeg_dec_finalize (GObject * object)
 113 {
 114   GstJpegDec *dec = GST_JPEG_DEC (object);
 115
 116   jpeg_destroy_decompress (&dec->cinfo);
 117   if (dec->input_state)
 118     gst_video_codec_state_unref (dec->input_state);
 119
 120   G_OBJECT_CLASS (parent_class)->finalize (object);
 121 }
 122
 123 static void
 124 gst_jpeg_dec_class_init (GstJpegDecClass * klass)
 125 {
 126   GObjectClass *gobject_class;
 127   GstElementClass *element_class;
 128   GstVideoDecoderClass *vdec_class;
 129
 130   gobject_class = (GObjectClass *) klass;
 131   element_class = (GstElementClass *) klass;
 132   vdec_class = (GstVideoDecoderClass *) klass;
 133
 134   parent_class = g_type_class_peek_parent (klass);
 135
 136   gobject_class->finalize = gst_jpeg_dec_finalize;
 137   gobject_class->set_property = gst_jpeg_dec_set_property;
 138   gobject_class->get_property = gst_jpeg_dec_get_property;
 139
 140   g_object_class_install_property (gobject_class, PROP_IDCT_METHOD,
 141       g_param_spec_enum ("idct-method", "IDCT Method",
 142           "The IDCT algorithm to use", GST_TYPE_IDCT_METHOD,
 143           JPEG_DEFAULT_IDCT_METHOD,
 144           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 145
 146   /**
 147    * GstJpegDec:max-errors:
 148    *
 149    * Error out after receiving N consecutive decoding errors
 150    * (-1 = never error out, 0 = automatic, 1 = fail on first error, etc.)
 151    *
 152    * Deprecated: 1.3.1: Property wasn't used internally
 153    */
 154   g_object_class_install_property (gobject_class, PROP_MAX_ERRORS,
 155       g_param_spec_int ("max-errors", "Maximum Consecutive Decoding Errors",
 156           "(Deprecated) Error out after receiving N consecutive decoding errors"
 157           " (-1 = never fail, 0 = automatic, 1 = fail on first error)",
 158           -1, G_MAXINT, JPEG_DEFAULT_MAX_ERRORS,
 159           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 160
 161   gst_element_class_add_pad_template (element_class,
 162       gst_static_pad_template_get (&gst_jpeg_dec_src_pad_template));
 163   gst_element_class_add_pad_template (element_class,
 164       gst_static_pad_template_get (&gst_jpeg_dec_sink_pad_template));
 165   gst_element_class_set_static_metadata (element_class, "JPEG image decoder",
 166       "Codec/Decoder/Image",
 167       "Decode images from JPEG format", "Wim Taymans <wim@fluendo.com>");
 168
 169   vdec_class->start = gst_jpeg_dec_start;
 170   vdec_class->stop = gst_jpeg_dec_stop;
 171   vdec_class->flush = gst_jpeg_dec_flush;
 172   vdec_class->parse = gst_jpeg_dec_parse;
 173   vdec_class->set_format = gst_jpeg_dec_set_format;
 174   vdec_class->handle_frame = gst_jpeg_dec_handle_frame;
 175   vdec_class->decide_allocation = gst_jpeg_dec_decide_allocation;
 176
 177   GST_DEBUG_CATEGORY_INIT (jpeg_dec_debug, "jpegdec", 0, "JPEG decoder");
 178   GST_DEBUG_CATEGORY_GET (GST_CAT_PERFORMANCE, "GST_PERFORMANCE");
 179 }
 180
 181 static boolean
 182 gst_jpeg_dec_fill_input_buffer (j_decompress_ptr cinfo)
 183 {
 184   GstJpegDec *dec;
 185
 186   dec = CINFO_GET_JPEGDEC (cinfo);
 187   g_return_val_if_fail (dec != NULL, FALSE);
 188   g_return_val_if_fail (dec->current_frame != NULL, FALSE);
 189   g_return_val_if_fail (dec->current_frame_map.data != NULL, FALSE);
 190
 191   cinfo->src->next_input_byte = dec->current_frame_map.data;
 192   cinfo->src->bytes_in_buffer = dec->current_frame_map.size;
 193
 194   return TRUE;
 195 }
 196
 197 static void
 198 gst_jpeg_dec_init_source (j_decompress_ptr cinfo)
 199 {
 200   GST_LOG_OBJECT (CINFO_GET_JPEGDEC (cinfo), "init_source");
 201 }
 202
 203
 204 static void
 205 gst_jpeg_dec_skip_input_data (j_decompress_ptr cinfo, glong num_bytes)
 206 {
 207   GstJpegDec *dec = CINFO_GET_JPEGDEC (cinfo);
 208
 209   GST_DEBUG_OBJECT (dec, "skip %ld bytes", num_bytes);
 210
 211   if (num_bytes > 0 && cinfo->src->bytes_in_buffer >= num_bytes) {
 212     cinfo->src->next_input_byte += (size_t) num_bytes;
 213     cinfo->src->bytes_in_buffer -= (size_t) num_bytes;
 214   }
 215 }
 216
 217 static boolean
 218 gst_jpeg_dec_resync_to_restart (j_decompress_ptr cinfo, gint desired)
 219 {
 220   GST_LOG_OBJECT (CINFO_GET_JPEGDEC (cinfo), "resync_to_start");
 221   return TRUE;
 222 }
 223
 224 static void
 225 gst_jpeg_dec_term_source (j_decompress_ptr cinfo)
 226 {
 227   GST_LOG_OBJECT (CINFO_GET_JPEGDEC (cinfo), "term_source");
 228   return;
 229 }
 230
 231 METHODDEF (void)
 232     gst_jpeg_dec_my_output_message (j_common_ptr cinfo)
 233 {
 234   return;                       /* do nothing */
 235 }
 236
 237 METHODDEF (void)
 238     gst_jpeg_dec_my_emit_message (j_common_ptr cinfo, int msg_level)
 239 {
 240   /* GST_LOG_OBJECT (CINFO_GET_JPEGDEC (&cinfo), "msg_level=%d", msg_level); */
 241   return;
 242 }
 243
 244 METHODDEF (void)
 245     gst_jpeg_dec_my_error_exit (j_common_ptr cinfo)
 246 {
 247   struct GstJpegDecErrorMgr *err_mgr = (struct GstJpegDecErrorMgr *) cinfo->err;
 248
 249   (*cinfo->err->output_message) (cinfo);
 250   longjmp (err_mgr->setjmp_buffer, 1);
 251 }
 252
 253 static void
 254 gst_jpeg_dec_init (GstJpegDec * dec)
 255 {
 256   GST_DEBUG ("initializing");
 257
 258   /* setup jpeglib */
 259   memset (&dec->cinfo, 0, sizeof (dec->cinfo));
 260   memset (&dec->jerr, 0, sizeof (dec->jerr));
 261   dec->cinfo.err = jpeg_std_error (&dec->jerr.pub);
 262   dec->jerr.pub.output_message = gst_jpeg_dec_my_output_message;
 263   dec->jerr.pub.emit_message = gst_jpeg_dec_my_emit_message;
 264   dec->jerr.pub.error_exit = gst_jpeg_dec_my_error_exit;
 265
 266   jpeg_create_decompress (&dec->cinfo);
 267
 268   dec->cinfo.src = (struct jpeg_source_mgr *) &dec->jsrc;
 269   dec->cinfo.src->init_source = gst_jpeg_dec_init_source;
 270   dec->cinfo.src->fill_input_buffer = gst_jpeg_dec_fill_input_buffer;
 271   dec->cinfo.src->skip_input_data = gst_jpeg_dec_skip_input_data;
 272   dec->cinfo.src->resync_to_restart = gst_jpeg_dec_resync_to_restart;
 273   dec->cinfo.src->term_source = gst_jpeg_dec_term_source;
 274   dec->jsrc.dec = dec;
 275
 276   /* init properties */
 277   dec->idct_method = JPEG_DEFAULT_IDCT_METHOD;
 278   dec->max_errors = JPEG_DEFAULT_MAX_ERRORS;
 279 }
 280
 281 static inline gboolean
 282 gst_jpeg_dec_parse_tag_has_entropy_segment (guint8 tag)
 283 {
 284   if (tag == 0xda || (tag >= 0xd0 && tag <= 0xd7))
 285     return TRUE;
 286   return FALSE;
 287 }
 288
 289 static GstFlowReturn
 290 gst_jpeg_dec_parse (GstVideoDecoder * bdec, GstVideoCodecFrame * frame,
 291     GstAdapter * adapter, gboolean at_eos)
 292 {
 293   guint size;
 294   gint toadd = 0;
 295   gboolean resync;
 296   gint offset = 0, noffset;
 297   GstJpegDec *dec = (GstJpegDec *) bdec;
 298
 299   GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
 300
 301   /* FIXME : The overhead of using scan_uint32 is massive */
 302
 303   size = gst_adapter_available (adapter);
 304   GST_DEBUG ("Parsing jpeg image data (%u bytes)", size);
 305
 306   if (at_eos) {
 307     GST_DEBUG ("Flushing all data out");
 308     toadd = size;
 309
 310     /* If we have leftover data, throw it away */
 311     if (!dec->saw_header)
 312       goto drop_frame;
 313     goto have_full_frame;
 314   }
 315
 316   if (size < 8)
 317     goto need_more_data;
 318
 319   if (!dec->saw_header) {
 320     gint ret;
 321     /* we expect at least 4 bytes, first of which start marker */
 322     ret =
 323         gst_adapter_masked_scan_uint32 (adapter, 0xffff0000, 0xffd80000, 0,
 324         size - 4);
 325
 326     GST_DEBUG ("ret:%d", ret);
 327     if (ret < 0)
 328       goto need_more_data;
 329
 330     if (ret) {
 331       gst_adapter_flush (adapter, ret);
 332       size -= ret;
 333     }
 334     dec->saw_header = TRUE;
 335   }
 336
 337   while (1) {
 338     guint frame_len;
 339     guint32 value;
 340
 341     GST_DEBUG ("offset:%d, size:%d", offset, size);
 342
 343     noffset =
 344         gst_adapter_masked_scan_uint32_peek (adapter, 0x0000ff00, 0x0000ff00,
 345         offset, size - offset, &value);
 346
 347     /* lost sync if 0xff marker not where expected */
 348     if ((resync = (noffset != offset))) {
 349       GST_DEBUG ("Lost sync at 0x%08x, resyncing", offset + 2);
 350     }
 351     /* may have marker, but could have been resyncng */
 352     resync = resync || dec->parse_resync;
 353     /* Skip over extra 0xff */
 354     while ((noffset >= 0) && ((value & 0xff) == 0xff)) {
 355       noffset++;
 356       noffset =
 357           gst_adapter_masked_scan_uint32_peek (adapter, 0x0000ff00, 0x0000ff00,
 358           noffset, size - noffset, &value);
 359     }
 360     /* enough bytes left for marker? (we need 0xNN after the 0xff) */
 361     if (noffset < 0) {
 362       GST_DEBUG ("at end of input and no EOI marker found, need more data");
 363       goto need_more_data;
 364     }
 365
 366     /* now lock on the marker we found */
 367     offset = noffset;
 368     value = value & 0xff;
 369     if (value == 0xd9) {
 370       GST_DEBUG ("0x%08x: EOI marker", offset + 2);
 371       /* clear parse state */
 372       dec->saw_header = FALSE;
 373       dec->parse_resync = FALSE;
 374       toadd = offset + 4;
 375       goto have_full_frame;
 376     }
 377     if (value == 0xd8) {
 378       /* Skip this frame if we found another SOI marker */
 379       GST_DEBUG ("0x%08x: SOI marker before EOI, skipping", offset + 2);
 380       dec->parse_resync = FALSE;
 381       size = offset + 2;
 382       goto drop_frame;
 383     }
 384
 385
 386     if (value >= 0xd0 && value <= 0xd7)
 387       frame_len = 0;
 388     else {
 389       /* peek tag and subsequent length */
 390       if (offset + 2 + 4 > size)
 391         goto need_more_data;
 392       else
 393         gst_adapter_masked_scan_uint32_peek (adapter, 0x0, 0x0, offset + 2, 4,
 394             &frame_len);
 395       frame_len = frame_len & 0xffff;
 396     }
 397     GST_DEBUG ("0x%08x: tag %02x, frame_len=%u", offset + 2, value, frame_len);
 398     /* the frame length includes the 2 bytes for the length; here we want at
 399      * least 2 more bytes at the end for an end marker */
 400     if (offset + 2 + 2 + frame_len + 2 > size) {
 401       goto need_more_data;
 402     }
 403
 404     if (gst_jpeg_dec_parse_tag_has_entropy_segment (value)) {
 405       guint eseglen = dec->parse_entropy_len;
 406
 407       GST_DEBUG ("0x%08x: finding entropy segment length (eseglen:%d)",
 408           offset + 2, eseglen);
 409       if (size < offset + 2 + frame_len + eseglen)
 410         goto need_more_data;
 411       noffset = offset + 2 + frame_len + dec->parse_entropy_len;
 412       while (1) {
 413         GST_DEBUG ("noffset:%d, size:%d, size - noffset:%d",
 414             noffset, size, size - noffset);
 415         noffset = gst_adapter_masked_scan_uint32_peek (adapter, 0x0000ff00,
 416             0x0000ff00, noffset, size - noffset, &value);
 417         if (noffset < 0) {
 418           /* need more data */
 419           dec->parse_entropy_len = size - offset - 4 - frame_len - 2;
 420           goto need_more_data;
 421         }
 422         if ((value & 0xff) != 0x00) {
 423           eseglen = noffset - offset - frame_len - 2;
 424           break;
 425         }
 426         noffset++;
 427       }
 428       dec->parse_entropy_len = 0;
 429       frame_len += eseglen;
 430       GST_DEBUG ("entropy segment length=%u => frame_len=%u", eseglen,
 431           frame_len);
 432     }
 433     if (resync) {
 434       /* check if we will still be in sync if we interpret
 435        * this as a sync point and skip this frame */
 436       noffset = offset + frame_len + 2;
 437       noffset = gst_adapter_masked_scan_uint32 (adapter, 0x0000ff00, 0x0000ff00,
 438           noffset, 4);
 439       if (noffset < 0) {
 440         /* ignore and continue resyncing until we hit the end
 441          * of our data or find a sync point that looks okay */
 442         offset++;
 443         continue;
 444       }
 445       GST_DEBUG ("found sync at 0x%x", offset + 2);
 446     }
 447
 448     /* Add current data to output buffer */
 449     toadd += frame_len + 2;
 450     offset += frame_len + 2;
 451   }
 452
 453 need_more_data:
 454   if (toadd)
 455     gst_video_decoder_add_to_frame (bdec, toadd);
 456   return GST_VIDEO_DECODER_FLOW_NEED_DATA;
 457
 458 have_full_frame:
 459   if (toadd)
 460     gst_video_decoder_add_to_frame (bdec, toadd);
 461   GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
 462   return gst_video_decoder_have_frame (bdec);
 463
 464 drop_frame:
 465   gst_adapter_flush (adapter, size);
 466   return GST_FLOW_OK;
 467 }
 468
 469
 470 /* shamelessly ripped from jpegutils.c in mjpegtools */
 471 static void
 472 add_huff_table (j_decompress_ptr dinfo,
 473     JHUFF_TBL ** htblptr, const UINT8 * bits, const UINT8 * val)
 474 /* Define a Huffman table */
 475 {
 476   int nsymbols, len;
 477
 478   if (*htblptr == NULL)
 479     *htblptr = jpeg_alloc_huff_table ((j_common_ptr) dinfo);
 480
 481   g_assert (*htblptr);
 482
 483   /* Copy the number-of-symbols-of-each-code-length counts */
 484   memcpy ((*htblptr)->bits, bits, sizeof ((*htblptr)->bits));
 485
 486   /* Validate the counts.  We do this here mainly so we can copy the right
 487    * number of symbols from the val[] array, without risking marching off
 488    * the end of memory.  jchuff.c will do a more thorough test later.
 489    */
 490   nsymbols = 0;
 491   for (len = 1; len <= 16; len++)
 492     nsymbols += bits[len];
 493   if (nsymbols < 1 || nsymbols > 256)
 494     g_error ("jpegutils.c:  add_huff_table failed badly. ");
 495
 496   memcpy ((*htblptr)->huffval, val, nsymbols * sizeof (UINT8));
 497 }
 498
 499
 500
 501 static void
 502 std_huff_tables (j_decompress_ptr dinfo)
 503 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
 504 /* IMPORTANT: these are only valid for 8-bit data precision! */
 505 {
 506   static const UINT8 bits_dc_luminance[17] =
 507       { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
 508   static const UINT8 val_dc_luminance[] =
 509       { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 510
 511   static const UINT8 bits_dc_chrominance[17] =
 512       { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
 513   static const UINT8 val_dc_chrominance[] =
 514       { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 515
 516   static const UINT8 bits_ac_luminance[17] =
 517       { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
 518   static const UINT8 val_ac_luminance[] =
 519       { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
 520     0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
 521     0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
 522     0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
 523     0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
 524     0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
 525     0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 526     0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
 527     0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
 528     0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 529     0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 530     0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 531     0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
 532     0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 533     0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
 534     0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 535     0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 536     0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 537     0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 538     0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 539     0xf9, 0xfa
 540   };
 541
 542   static const UINT8 bits_ac_chrominance[17] =
 543       { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 544   static const UINT8 val_ac_chrominance[] =
 545       { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
 546     0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 547     0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
 548     0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
 549     0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
 550     0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
 551     0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 552     0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
 553     0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
 554     0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 555     0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
 556     0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 557     0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
 558     0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
 559     0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
 560     0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
 561     0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 562     0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
 563     0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 564     0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 565     0xf9, 0xfa
 566   };
 567
 568   add_huff_table (dinfo, &dinfo->dc_huff_tbl_ptrs[0],
 569       bits_dc_luminance, val_dc_luminance);
 570   add_huff_table (dinfo, &dinfo->ac_huff_tbl_ptrs[0],
 571       bits_ac_luminance, val_ac_luminance);
 572   add_huff_table (dinfo, &dinfo->dc_huff_tbl_ptrs[1],
 573       bits_dc_chrominance, val_dc_chrominance);
 574   add_huff_table (dinfo, &dinfo->ac_huff_tbl_ptrs[1],
 575       bits_ac_chrominance, val_ac_chrominance);
 576 }
 577
 578
 579
 580 static void
 581 guarantee_huff_tables (j_decompress_ptr dinfo)
 582 {
 583   if ((dinfo->dc_huff_tbl_ptrs[0] == NULL) &&
 584       (dinfo->dc_huff_tbl_ptrs[1] == NULL) &&
 585       (dinfo->ac_huff_tbl_ptrs[0] == NULL) &&
 586       (dinfo->ac_huff_tbl_ptrs[1] == NULL)) {
 587     GST_DEBUG ("Generating standard Huffman tables for this frame.");
 588     std_huff_tables (dinfo);
 589   }
 590 }
 591
 592 static gboolean
 593 gst_jpeg_dec_set_format (GstVideoDecoder * dec, GstVideoCodecState * state)
 594 {
 595   GstJpegDec *jpeg = GST_JPEG_DEC (dec);
 596
 597   if (dec->input_segment.format == GST_FORMAT_TIME)
 598     gst_video_decoder_set_packetized (dec, TRUE);
 599   else
 600     gst_video_decoder_set_packetized (dec, FALSE);
 601
 602   if (jpeg->input_state)
 603     gst_video_codec_state_unref (jpeg->input_state);
 604   jpeg->input_state = gst_video_codec_state_ref (state);
 605
 606   return TRUE;
 607 }
 608
 609
 610 /* yuk */
 611 static void
 612 hresamplecpy1 (guint8 * dest, const guint8 * src, guint len)
 613 {
 614   gint i;
 615
 616   for (i = 0; i < len; ++i) {
 617     /* equivalent to: dest[i] = src[i << 1] */
 618     *dest = *src;
 619     ++dest;
 620     ++src;
 621     ++src;
 622   }
 623 }
 624
 625 static void
 626 gst_jpeg_dec_free_buffers (GstJpegDec * dec)
 627 {
 628   gint i;
 629
 630   for (i = 0; i < 16; i++) {
 631     g_free (dec->idr_y[i]);
 632     g_free (dec->idr_u[i]);
 633     g_free (dec->idr_v[i]);
 634     dec->idr_y[i] = NULL;
 635     dec->idr_u[i] = NULL;
 636     dec->idr_v[i] = NULL;
 637   }
 638
 639   dec->idr_width_allocated = 0;
 640 }
 641
 642 static inline gboolean
 643 gst_jpeg_dec_ensure_buffers (GstJpegDec * dec, guint maxrowbytes)
 644 {
 645   gint i;
 646
 647   if (G_LIKELY (dec->idr_width_allocated == maxrowbytes))
 648     return TRUE;
 649
 650   /* FIXME: maybe just alloc one or three blocks altogether? */
 651   for (i = 0; i < 16; i++) {
 652     dec->idr_y[i] = g_try_realloc (dec->idr_y[i], maxrowbytes);
 653     dec->idr_u[i] = g_try_realloc (dec->idr_u[i], maxrowbytes);
 654     dec->idr_v[i] = g_try_realloc (dec->idr_v[i], maxrowbytes);
 655
 656     if (G_UNLIKELY (!dec->idr_y[i] || !dec->idr_u[i] || !dec->idr_v[i])) {
 657       GST_WARNING_OBJECT (dec, "out of memory, i=%d, bytes=%u", i, maxrowbytes);
 658       return FALSE;
 659     }
 660   }
 661
 662   dec->idr_width_allocated = maxrowbytes;
 663   GST_LOG_OBJECT (dec, "allocated temp memory, %u bytes/row", maxrowbytes);
 664   return TRUE;
 665 }
 666
 667 static void
 668 gst_jpeg_dec_decode_grayscale (GstJpegDec * dec, GstVideoFrame * frame)
 669 {
 670   guchar *rows[16];
 671   guchar **scanarray[1] = { rows };
 672   gint i, j, k;
 673   gint lines;
 674   guint8 *base[1];
 675   gint width, height;
 676   gint pstride, rstride;
 677
 678   GST_DEBUG_OBJECT (dec, "indirect decoding of grayscale");
 679
 680   width = GST_VIDEO_FRAME_WIDTH (frame);
 681   height = GST_VIDEO_FRAME_HEIGHT (frame);
 682
 683   if (G_UNLIKELY (!gst_jpeg_dec_ensure_buffers (dec, GST_ROUND_UP_32 (width))))
 684     return;
 685
 686   base[0] = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
 687   pstride = GST_VIDEO_FRAME_COMP_PSTRIDE (frame, 0);
 688   rstride = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
 689
 690   memcpy (rows, dec->idr_y, 16 * sizeof (gpointer));
 691
 692   i = 0;
 693   while (i < height) {
 694     lines = jpeg_read_raw_data (&dec->cinfo, scanarray, DCTSIZE);
 695     if (G_LIKELY (lines > 0)) {
 696       for (j = 0; (j < DCTSIZE) && (i < height); j++, i++) {
 697         gint p;
 698
 699         p = 0;
 700         for (k = 0; k < width; k++) {
 701           base[0][p] = rows[j][k];
 702           p += pstride;
 703         }
 704         base[0] += rstride;
 705       }
 706     } else {
 707       GST_INFO_OBJECT (dec, "jpeg_read_raw_data() returned 0");
 708     }
 709   }
 710 }
 711
 712 static void
 713 gst_jpeg_dec_decode_rgb (GstJpegDec * dec, GstVideoFrame * frame)
 714 {
 715   guchar *r_rows[16], *g_rows[16], *b_rows[16];
 716   guchar **scanarray[3] = { r_rows, g_rows, b_rows };
 717   gint i, j, k;
 718   gint lines;
 719   guint8 *base[3];
 720   guint pstride, rstride;
 721   gint width, height;
 722
 723   GST_DEBUG_OBJECT (dec, "indirect decoding of RGB");
 724
 725   width = GST_VIDEO_FRAME_WIDTH (frame);
 726   height = GST_VIDEO_FRAME_HEIGHT (frame);
 727
 728   if (G_UNLIKELY (!gst_jpeg_dec_ensure_buffers (dec, GST_ROUND_UP_32 (width))))
 729     return;
 730
 731   for (i = 0; i < 3; i++)
 732     base[i] = GST_VIDEO_FRAME_COMP_DATA (frame, i);
 733
 734   pstride = GST_VIDEO_FRAME_COMP_PSTRIDE (frame, 0);
 735   rstride = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
 736
 737   memcpy (r_rows, dec->idr_y, 16 * sizeof (gpointer));
 738   memcpy (g_rows, dec->idr_u, 16 * sizeof (gpointer));
 739   memcpy (b_rows, dec->idr_v, 16 * sizeof (gpointer));
 740
 741   i = 0;
 742   while (i < height) {
 743     lines = jpeg_read_raw_data (&dec->cinfo, scanarray, DCTSIZE);
 744     if (G_LIKELY (lines > 0)) {
 745       for (j = 0; (j < DCTSIZE) && (i < height); j++, i++) {
 746         gint p;
 747
 748         p = 0;
 749         for (k = 0; k < width; k++) {
 750           base[0][p] = r_rows[j][k];
 751           base[1][p] = g_rows[j][k];
 752           base[2][p] = b_rows[j][k];
 753           p += pstride;
 754         }
 755         base[0] += rstride;
 756         base[1] += rstride;
 757         base[2] += rstride;
 758       }
 759     } else {
 760       GST_INFO_OBJECT (dec, "jpeg_read_raw_data() returned 0");
 761     }
 762   }
 763 }
 764
 765 static void
 766 gst_jpeg_dec_decode_indirect (GstJpegDec * dec, GstVideoFrame * frame, gint r_v,
 767     gint r_h, gint comp)
 768 {
 769   guchar *y_rows[16], *u_rows[16], *v_rows[16];
 770   guchar **scanarray[3] = { y_rows, u_rows, v_rows };
 771   gint i, j, k;
 772   gint lines;
 773   guchar *base[3], *last[3];
 774   gint stride[3];
 775   gint width, height;
 776
 777   GST_DEBUG_OBJECT (dec,
 778       "unadvantageous width or r_h, taking slow route involving memcpy");
 779
 780   width = GST_VIDEO_FRAME_WIDTH (frame);
 781   height = GST_VIDEO_FRAME_HEIGHT (frame);
 782
 783   if (G_UNLIKELY (!gst_jpeg_dec_ensure_buffers (dec, GST_ROUND_UP_32 (width))))
 784     return;
 785
 786   for (i = 0; i < 3; i++) {
 787     base[i] = GST_VIDEO_FRAME_COMP_DATA (frame, i);
 788     stride[i] = GST_VIDEO_FRAME_COMP_STRIDE (frame, i);
 789     /* make sure we don't make jpeglib write beyond our buffer,
 790      * which might happen if (height % (r_v*DCTSIZE)) != 0 */
 791     last[i] = base[i] + (GST_VIDEO_FRAME_COMP_STRIDE (frame, i) *
 792         (GST_VIDEO_FRAME_COMP_HEIGHT (frame, i) - 1));
 793   }
 794
 795   memcpy (y_rows, dec->idr_y, 16 * sizeof (gpointer));
 796   memcpy (u_rows, dec->idr_u, 16 * sizeof (gpointer));
 797   memcpy (v_rows, dec->idr_v, 16 * sizeof (gpointer));
 798
 799   /* fill chroma components for grayscale */
 800   if (comp == 1) {
 801     GST_DEBUG_OBJECT (dec, "grayscale, filling chroma");
 802     for (i = 0; i < 16; i++) {
 803       memset (u_rows[i], GST_ROUND_UP_32 (width), 0x80);
 804       memset (v_rows[i], GST_ROUND_UP_32 (width), 0x80);
 805     }
 806   }
 807
 808   for (i = 0; i < height; i += r_v * DCTSIZE) {
 809     lines = jpeg_read_raw_data (&dec->cinfo, scanarray, r_v * DCTSIZE);
 810     if (G_LIKELY (lines > 0)) {
 811       for (j = 0, k = 0; j < (r_v * DCTSIZE); j += r_v, k++) {
 812         if (G_LIKELY (base[0] <= last[0])) {
 813           memcpy (base[0], y_rows[j], stride[0]);
 814           base[0] += stride[0];
 815         }
 816         if (r_v == 2) {
 817           if (G_LIKELY (base[0] <= last[0])) {
 818             memcpy (base[0], y_rows[j + 1], stride[0]);
 819             base[0] += stride[0];
 820           }
 821         }
 822         if (G_LIKELY (base[1] <= last[1] && base[2] <= last[2])) {
 823           if (r_h == 2) {
 824             memcpy (base[1], u_rows[k], stride[1]);
 825             memcpy (base[2], v_rows[k], stride[2]);
 826           } else if (r_h == 1) {
 827             hresamplecpy1 (base[1], u_rows[k], stride[1]);
 828             hresamplecpy1 (base[2], v_rows[k], stride[2]);
 829           } else {
 830             /* FIXME: implement (at least we avoid crashing by doing nothing) */
 831           }
 832         }
 833
 834         if (r_v == 2 || (k & 1) != 0) {
 835           base[1] += stride[1];
 836           base[2] += stride[2];
 837         }
 838       }
 839     } else {
 840       GST_INFO_OBJECT (dec, "jpeg_read_raw_data() returned 0");
 841     }
 842   }
 843 }
 844
 845 static GstFlowReturn
 846 gst_jpeg_dec_decode_direct (GstJpegDec * dec, GstVideoFrame * frame)
 847 {
 848   guchar **line[3];             /* the jpeg line buffer         */
 849   guchar *y[4 * DCTSIZE] = { NULL, };   /* alloc enough for the lines   */
 850   guchar *u[4 * DCTSIZE] = { NULL, };   /* r_v will be <4               */
 851   guchar *v[4 * DCTSIZE] = { NULL, };
 852   gint i, j;
 853   gint lines, v_samp[3];
 854   guchar *base[3], *last[3];
 855   gint stride[3];
 856   guint height;
 857
 858   line[0] = y;
 859   line[1] = u;
 860   line[2] = v;
 861
 862   v_samp[0] = dec->cinfo.comp_info[0].v_samp_factor;
 863   v_samp[1] = dec->cinfo.comp_info[1].v_samp_factor;
 864   v_samp[2] = dec->cinfo.comp_info[2].v_samp_factor;
 865
 866   if (G_UNLIKELY (v_samp[0] > 2 || v_samp[1] > 2 || v_samp[2] > 2))
 867     goto format_not_supported;
 868
 869   height = GST_VIDEO_FRAME_HEIGHT (frame);
 870
 871   for (i = 0; i < 3; i++) {
 872     base[i] = GST_VIDEO_FRAME_COMP_DATA (frame, i);
 873     stride[i] = GST_VIDEO_FRAME_COMP_STRIDE (frame, i);
 874     /* make sure we don't make jpeglib write beyond our buffer,
 875      * which might happen if (height % (r_v*DCTSIZE)) != 0 */
 876     last[i] = base[i] + (GST_VIDEO_FRAME_COMP_STRIDE (frame, i) *
 877         (GST_VIDEO_FRAME_COMP_HEIGHT (frame, i) - 1));
 878   }
 879
 880   /* let jpeglib decode directly into our final buffer */
 881   GST_DEBUG_OBJECT (dec, "decoding directly into output buffer");
 882
 883   for (i = 0; i < height; i += v_samp[0] * DCTSIZE) {
 884     for (j = 0; j < (v_samp[0] * DCTSIZE); ++j) {
 885       /* Y */
 886       line[0][j] = base[0] + (i + j) * stride[0];
 887       if (G_UNLIKELY (line[0][j] > last[0]))
 888         line[0][j] = last[0];
 889       /* U */
 890       if (v_samp[1] == v_samp[0]) {
 891         line[1][j] = base[1] + ((i + j) / 2) * stride[1];
 892       } else if (j < (v_samp[1] * DCTSIZE)) {
 893         line[1][j] = base[1] + ((i / 2) + j) * stride[1];
 894       }
 895       if (G_UNLIKELY (line[1][j] > last[1]))
 896         line[1][j] = last[1];
 897       /* V */
 898       if (v_samp[2] == v_samp[0]) {
 899         line[2][j] = base[2] + ((i + j) / 2) * stride[2];
 900       } else if (j < (v_samp[2] * DCTSIZE)) {
 901         line[2][j] = base[2] + ((i / 2) + j) * stride[2];
 902       }
 903       if (G_UNLIKELY (line[2][j] > last[2]))
 904         line[2][j] = last[2];
 905     }
 906
 907     lines = jpeg_read_raw_data (&dec->cinfo, line, v_samp[0] * DCTSIZE);
 908     if (G_UNLIKELY (!lines)) {
 909       GST_INFO_OBJECT (dec, "jpeg_read_raw_data() returned 0");
 910     }
 911   }
 912   return GST_FLOW_OK;
 913
 914 format_not_supported:
 915   {
 916     gboolean ret = GST_FLOW_OK;
 917
 918     GST_VIDEO_DECODER_ERROR (dec, 1, STREAM, DECODE,
 919         (_("Failed to decode JPEG image")),
 920         ("Unsupported subsampling schema: v_samp factors: %u %u %u", v_samp[0],
 921             v_samp[1], v_samp[2]), ret);
 922
 923     return ret;
 924   }
 925 }
 926
 927 static void
 928 gst_jpeg_dec_negotiate (GstJpegDec * dec, gint width, gint height, gint clrspc)
 929 {
 930   GstVideoCodecState *outstate;
 931   GstVideoInfo *info;
 932   GstVideoFormat format;
 933
 934   switch (clrspc) {
 935     case JCS_RGB:
 936       format = GST_VIDEO_FORMAT_RGB;
 937       break;
 938     case JCS_GRAYSCALE:
 939       format = GST_VIDEO_FORMAT_GRAY8;
 940       break;
 941     default:
 942       format = GST_VIDEO_FORMAT_I420;
 943       break;
 944   }
 945
 946   /* Compare to currently configured output state */
 947   outstate = gst_video_decoder_get_output_state (GST_VIDEO_DECODER (dec));
 948   if (outstate) {
 949     info = &outstate->info;
 950
 951     if (width == GST_VIDEO_INFO_WIDTH (info) &&
 952         height == GST_VIDEO_INFO_HEIGHT (info) &&
 953         format == GST_VIDEO_INFO_FORMAT (info)) {
 954       gst_video_codec_state_unref (outstate);
 955       return;
 956     }
 957     gst_video_codec_state_unref (outstate);
 958   }
 959
 960   outstate =
 961       gst_video_decoder_set_output_state (GST_VIDEO_DECODER (dec), format,
 962       width, height, dec->input_state);
 963
 964   switch (clrspc) {
 965     case JCS_RGB:
 966     case JCS_GRAYSCALE:
 967       break;
 968     default:
 969       outstate->info.colorimetry.range = GST_VIDEO_COLOR_RANGE_0_255;
 970       outstate->info.colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_BT601;
 971       outstate->info.colorimetry.transfer = GST_VIDEO_TRANSFER_UNKNOWN;
 972       outstate->info.colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_UNKNOWN;
 973       break;
 974   }
 975
 976   gst_video_codec_state_unref (outstate);
 977
 978   gst_video_decoder_negotiate (GST_VIDEO_DECODER (dec));
 979
 980   GST_DEBUG_OBJECT (dec, "max_v_samp_factor=%d", dec->cinfo.max_v_samp_factor);
 981   GST_DEBUG_OBJECT (dec, "max_h_samp_factor=%d", dec->cinfo.max_h_samp_factor);
 982 }
 983
 984 static GstFlowReturn
 985 gst_jpeg_dec_handle_frame (GstVideoDecoder * bdec, GstVideoCodecFrame * frame)
 986 {
 987   GstFlowReturn ret = GST_FLOW_OK;
 988   GstJpegDec *dec = (GstJpegDec *) bdec;
 989   GstVideoFrame vframe;
 990   gint width, height;
 991   gint r_h, r_v;
 992   guint code, hdr_ok;
 993   gboolean need_unmap = TRUE;
 994   GstVideoCodecState *state = NULL;
 995
 996   dec->current_frame = frame;
 997   gst_buffer_map (frame->input_buffer, &dec->current_frame_map, GST_MAP_READ);
 998   gst_jpeg_dec_fill_input_buffer (&dec->cinfo);
 999
1000   if (setjmp (dec->jerr.setjmp_buffer)) {
1001     code = dec->jerr.pub.msg_code;
1002
1003     if (code == JERR_INPUT_EOF) {
1004       GST_DEBUG ("jpeg input EOF error, we probably need more data");
1005       goto need_more_data;
1006     }
1007     goto decode_error;
1008   }
1009
1010   /* read header */
1011   hdr_ok = jpeg_read_header (&dec->cinfo, TRUE);
1012   if (G_UNLIKELY (hdr_ok != JPEG_HEADER_OK)) {
1013     GST_WARNING_OBJECT (dec, "reading the header failed, %d", hdr_ok);
1014   }
1015
1016   GST_LOG_OBJECT (dec, "num_components=%d", dec->cinfo.num_components);
1017   GST_LOG_OBJECT (dec, "jpeg_color_space=%d", dec->cinfo.jpeg_color_space);
1018
1019   if (!dec->cinfo.num_components || !dec->cinfo.comp_info)
1020     goto components_not_supported;
1021
1022   r_h = dec->cinfo.comp_info[0].h_samp_factor;
1023   r_v = dec->cinfo.comp_info[0].v_samp_factor;
1024
1025   GST_LOG_OBJECT (dec, "r_h = %d, r_v = %d", r_h, r_v);
1026
1027   if (dec->cinfo.num_components > 3)
1028     goto components_not_supported;
1029
1030   /* verify color space expectation to avoid going *boom* or bogus output */
1031   if (dec->cinfo.jpeg_color_space != JCS_YCbCr &&
1032       dec->cinfo.jpeg_color_space != JCS_GRAYSCALE &&
1033       dec->cinfo.jpeg_color_space != JCS_RGB)
1034     goto unsupported_colorspace;
1035
1036 #ifndef GST_DISABLE_GST_DEBUG
1037   {
1038     gint i;
1039
1040     for (i = 0; i < dec->cinfo.num_components; ++i) {
1041       GST_LOG_OBJECT (dec, "[%d] h_samp_factor=%d, v_samp_factor=%d, cid=%d",
1042           i, dec->cinfo.comp_info[i].h_samp_factor,
1043           dec->cinfo.comp_info[i].v_samp_factor,
1044           dec->cinfo.comp_info[i].component_id);
1045     }
1046   }
1047 #endif
1048
1049   /* prepare for raw output */
1050   dec->cinfo.do_fancy_upsampling = FALSE;
1051   dec->cinfo.do_block_smoothing = FALSE;
1052   dec->cinfo.out_color_space = dec->cinfo.jpeg_color_space;
1053   dec->cinfo.dct_method = dec->idct_method;
1054   dec->cinfo.raw_data_out = TRUE;
1055
1056   GST_LOG_OBJECT (dec, "starting decompress");
1057   guarantee_huff_tables (&dec->cinfo);
1058   if (!jpeg_start_decompress (&dec->cinfo)) {
1059     GST_WARNING_OBJECT (dec, "failed to start decompression cycle");
1060   }
1061
1062   /* sanity checks to get safe and reasonable output */
1063   switch (dec->cinfo.jpeg_color_space) {
1064     case JCS_GRAYSCALE:
1065       if (dec->cinfo.num_components != 1)
1066         goto invalid_yuvrgbgrayscale;
1067       break;
1068     case JCS_RGB:
1069       if (dec->cinfo.num_components != 3 || dec->cinfo.max_v_samp_factor > 1 ||
1070           dec->cinfo.max_h_samp_factor > 1)
1071         goto invalid_yuvrgbgrayscale;
1072       break;
1073     case JCS_YCbCr:
1074       if (dec->cinfo.num_components != 3 ||
1075           r_v > 2 || r_v < dec->cinfo.comp_info[0].v_samp_factor ||
1076           r_v < dec->cinfo.comp_info[1].v_samp_factor ||
1077           r_h < dec->cinfo.comp_info[0].h_samp_factor ||
1078           r_h < dec->cinfo.comp_info[1].h_samp_factor)
1079         goto invalid_yuvrgbgrayscale;
1080       break;
1081     default:
1082       g_assert_not_reached ();
1083       break;
1084   }
1085
1086   width = dec->cinfo.output_width;
1087   height = dec->cinfo.output_height;
1088
1089   if (G_UNLIKELY (width < MIN_WIDTH || width > MAX_WIDTH ||
1090           height < MIN_HEIGHT || height > MAX_HEIGHT))
1091     goto wrong_size;
1092
1093   gst_jpeg_dec_negotiate (dec, width, height, dec->cinfo.jpeg_color_space);
1094
1095   state = gst_video_decoder_get_output_state (bdec);
1096   ret = gst_video_decoder_allocate_output_frame (bdec, frame);
1097   if (G_UNLIKELY (ret != GST_FLOW_OK))
1098     goto alloc_failed;
1099
1100   if (!gst_video_frame_map (&vframe, &state->info, frame->output_buffer,
1101           GST_MAP_READWRITE))
1102     goto alloc_failed;
1103
1104   GST_LOG_OBJECT (dec, "width %d, height %d", width, height);
1105
1106   if (dec->cinfo.jpeg_color_space == JCS_RGB) {
1107     gst_jpeg_dec_decode_rgb (dec, &vframe);
1108   } else if (dec->cinfo.jpeg_color_space == JCS_GRAYSCALE) {
1109     gst_jpeg_dec_decode_grayscale (dec, &vframe);
1110   } else {
1111     GST_LOG_OBJECT (dec, "decompressing (reqired scanline buffer height = %u)",
1112         dec->cinfo.rec_outbuf_height);
1113
1114     /* For some widths jpeglib requires more horizontal padding than I420
1115      * provides. In those cases we need to decode into separate buffers and then
1116      * copy over the data into our final picture buffer, otherwise jpeglib might
1117      * write over the end of a line into the beginning of the next line,
1118      * resulting in blocky artifacts on the left side of the picture. */
1119     if (G_UNLIKELY (width % (dec->cinfo.max_h_samp_factor * DCTSIZE) != 0
1120             || dec->cinfo.comp_info[0].h_samp_factor != 2
1121             || dec->cinfo.comp_info[1].h_samp_factor != 1
1122             || dec->cinfo.comp_info[2].h_samp_factor != 1)) {
1123       GST_CAT_LOG_OBJECT (GST_CAT_PERFORMANCE, dec,
1124           "indirect decoding using extra buffer copy");
1125       gst_jpeg_dec_decode_indirect (dec, &vframe, r_v, r_h,
1126           dec->cinfo.num_components);
1127     } else {
1128       ret = gst_jpeg_dec_decode_direct (dec, &vframe);
1129
1130       if (G_UNLIKELY (ret != GST_FLOW_OK))
1131         goto decode_direct_failed;
1132     }
1133   }
1134
1135   gst_video_frame_unmap (&vframe);
1136
1137   GST_LOG_OBJECT (dec, "decompressing finished");
1138   jpeg_finish_decompress (&dec->cinfo);
1139
1140   gst_buffer_unmap (frame->input_buffer, &dec->current_frame_map);
1141   ret = gst_video_decoder_finish_frame (bdec, frame);
1142   need_unmap = FALSE;
1143
1144 done:
1145
1146 exit:
1147
1148   if (need_unmap)
1149     gst_buffer_unmap (frame->input_buffer, &dec->current_frame_map);
1150
1151   if (state)
1152     gst_video_codec_state_unref (state);
1153
1154   return ret;
1155
1156   /* special cases */
1157 need_more_data:
1158   {
1159     GST_LOG_OBJECT (dec, "we need more data");
1160     ret = GST_FLOW_OK;
1161     goto exit;
1162   }
1163   /* ERRORS */
1164 wrong_size:
1165   {
1166     GST_VIDEO_DECODER_ERROR (dec, 1, STREAM, DECODE,
1167         (_("Failed to decode JPEG image")),
1168         ("Picture is too small or too big (%ux%u)", width, height), ret);
1169     ret = GST_FLOW_ERROR;
1170     goto done;
1171   }
1172 decode_error:
1173   {
1174     gchar err_msg[JMSG_LENGTH_MAX];
1175
1176     dec->jerr.pub.format_message ((j_common_ptr) (&dec->cinfo), err_msg);
1177
1178     GST_VIDEO_DECODER_ERROR (dec, 1, STREAM, DECODE,
1179         (_("Failed to decode JPEG image")), ("Decode error #%u: %s", code,
1180             err_msg), ret);
1181
1182     gst_buffer_unmap (frame->input_buffer, &dec->current_frame_map);
1183     gst_video_decoder_drop_frame (bdec, frame);
1184     need_unmap = FALSE;
1185     jpeg_abort_decompress (&dec->cinfo);
1186
1187     goto done;
1188   }
1189 decode_direct_failed:
1190   {
1191     /* already posted an error message */
1192     jpeg_abort_decompress (&dec->cinfo);
1193     goto done;
1194   }
1195 alloc_failed:
1196   {
1197     const gchar *reason;
1198
1199     reason = gst_flow_get_name (ret);
1200
1201     GST_DEBUG_OBJECT (dec, "failed to alloc buffer, reason %s", reason);
1202     /* Reset for next time */
1203     jpeg_abort_decompress (&dec->cinfo);
1204     if (ret != GST_FLOW_EOS && ret != GST_FLOW_FLUSHING &&
1205         ret != GST_FLOW_NOT_LINKED) {
1206       GST_VIDEO_DECODER_ERROR (dec, 1, STREAM, DECODE,
1207           (_("Failed to decode JPEG image")),
1208           ("Buffer allocation failed, reason: %s", reason), ret);
1209       jpeg_abort_decompress (&dec->cinfo);
1210     }
1211     goto exit;
1212   }
1213 components_not_supported:
1214   {
1215     GST_VIDEO_DECODER_ERROR (dec, 1, STREAM, DECODE,
1216         (_("Failed to decode JPEG image")),
1217         ("number of components not supported: %d (max 3)",
1218             dec->cinfo.num_components), ret);
1219     jpeg_abort_decompress (&dec->cinfo);
1220     goto done;
1221   }
1222 unsupported_colorspace:
1223   {
1224     GST_VIDEO_DECODER_ERROR (dec, 1, STREAM, DECODE,
1225         (_("Failed to decode JPEG image")),
1226         ("Picture has unknown or unsupported colourspace"), ret);
1227     jpeg_abort_decompress (&dec->cinfo);
1228     goto done;
1229   }
1230 invalid_yuvrgbgrayscale:
1231   {
1232     GST_VIDEO_DECODER_ERROR (dec, 1, STREAM, DECODE,
1233         (_("Failed to decode JPEG image")),
1234         ("Picture is corrupt or unhandled YUV/RGB/grayscale layout"), ret);
1235     jpeg_abort_decompress (&dec->cinfo);
1236     goto done;
1237   }
1238 }
1239
1240 static gboolean
1241 gst_jpeg_dec_decide_allocation (GstVideoDecoder * bdec, GstQuery * query)
1242 {
1243   GstBufferPool *pool = NULL;
1244   GstStructure *config;
1245
1246   if (!GST_VIDEO_DECODER_CLASS (parent_class)->decide_allocation (bdec, query))
1247     return FALSE;
1248
1249   if (gst_query_get_n_allocation_pools (query) > 0)
1250     gst_query_parse_nth_allocation_pool (query, 0, &pool, NULL, NULL, NULL);
1251
1252   if (pool == NULL)
1253     return FALSE;
1254
1255   config = gst_buffer_pool_get_config (pool);
1256   if (gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL)) {
1257     gst_buffer_pool_config_add_option (config,
1258         GST_BUFFER_POOL_OPTION_VIDEO_META);
1259   }
1260   gst_buffer_pool_set_config (pool, config);
1261   gst_object_unref (pool);
1262
1263   return TRUE;
1264 }
1265
1266 static gboolean
1267 gst_jpeg_dec_start (GstVideoDecoder * bdec)
1268 {
1269   GstJpegDec *dec = (GstJpegDec *) bdec;
1270
1271   dec->saw_header = FALSE;
1272   dec->parse_entropy_len = 0;
1273   dec->parse_resync = FALSE;
1274
1275   gst_video_decoder_set_packetized (bdec, FALSE);
1276
1277   return TRUE;
1278 }
1279
1280 static gboolean
1281 gst_jpeg_dec_flush (GstVideoDecoder * bdec)
1282 {
1283   GstJpegDec *dec = (GstJpegDec *) bdec;
1284
1285   jpeg_abort_decompress (&dec->cinfo);
1286   dec->parse_entropy_len = 0;
1287   dec->parse_resync = FALSE;
1288   dec->saw_header = FALSE;
1289
1290   return TRUE;
1291 }
1292
1293 static void
1294 gst_jpeg_dec_set_property (GObject * object, guint prop_id,
1295     const GValue * value, GParamSpec * pspec)
1296 {
1297   GstJpegDec *dec;
1298
1299   dec = GST_JPEG_DEC (object);
1300
1301   switch (prop_id) {
1302     case PROP_IDCT_METHOD:
1303       dec->idct_method = g_value_get_enum (value);
1304       break;
1305     case PROP_MAX_ERRORS:
1306       g_atomic_int_set (&dec->max_errors, g_value_get_int (value));
1307       break;
1308
1309     default:
1310       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1311       break;
1312   }
1313 }
1314
1315 static void
1316 gst_jpeg_dec_get_property (GObject * object, guint prop_id, GValue * value,
1317     GParamSpec * pspec)
1318 {
1319   GstJpegDec *dec;
1320
1321   dec = GST_JPEG_DEC (object);
1322
1323   switch (prop_id) {
1324     case PROP_IDCT_METHOD:
1325       g_value_set_enum (value, dec->idct_method);
1326       break;
1327     case PROP_MAX_ERRORS:
1328       g_value_set_int (value, g_atomic_int_get (&dec->max_errors));
1329       break;
1330
1331     default:
1332       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1333       break;
1334   }
1335 }
1336
1337 static gboolean
1338 gst_jpeg_dec_stop (GstVideoDecoder * bdec)
1339 {
1340   GstJpegDec *dec = (GstJpegDec *) bdec;
1341
1342   gst_jpeg_dec_free_buffers (dec);
1343
1344   return TRUE;
1345 }