modules/codec/jpeg.c

   1 /*****************************************************************************
   2  * jpeg.c: jpeg decoder module making use of libjpeg.
   3  *****************************************************************************
   4  * Copyright (C) 2013-2014,2016 VLC authors and VideoLAN
   5  *
   6  * Authors: Maxim Bublis <b@codemonkey.ru>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include "config.h"
  25 #endif
  26
  27 #include <vlc_common.h>
  28 #include <vlc_plugin.h>
  29 #include <vlc_codec.h>
  30 #include <vlc_charset.h>
  31
  32 #include <jpeglib.h>
  33 #include <setjmp.h>
  34
  35 /* JPEG_SYS_COMMON_MEMBERS:
  36  * members common to encoder and decoder descriptors
  37  */
  38 #define JPEG_SYS_COMMON_MEMBERS                             \
  39 /**@{*/                                                     \
  40     /* libjpeg error handler manager */                     \
  41     struct jpeg_error_mgr err;                              \
  42                                                             \
  43     /* setjmp buffer for internal libjpeg error handling */ \
  44     jmp_buf setjmp_buffer;                                  \
  45                                                             \
  46     vlc_object_t *p_obj;                                    \
  47                                                             \
  48 /**@}*/                                                     \
  49
  50 #define ENC_CFG_PREFIX "sout-jpeg-"
  51 #define ENC_QUALITY_TEXT N_("Quality level")
  52 #define ENC_QUALITY_LONGTEXT N_("Quality level " \
  53     "for encoding (this can enlarge or reduce output image size).")
  54
  55
  56 /*
  57  * jpeg common descriptor
  58  */
  59 struct jpeg_sys_t
  60 {
  61     JPEG_SYS_COMMON_MEMBERS
  62 };
  63
  64 typedef struct jpeg_sys_t jpeg_sys_t;
  65
  66 /*
  67  * jpeg decoder descriptor
  68  */
  69 struct decoder_sys_t
  70 {
  71     JPEG_SYS_COMMON_MEMBERS
  72
  73     struct jpeg_decompress_struct p_jpeg;
  74 };
  75
  76 static int  OpenDecoder(vlc_object_t *);
  77 static void CloseDecoder(vlc_object_t *);
  78
  79 static int DecodeBlock(decoder_t *, block_t *);
  80
  81 /*
  82  * jpeg encoder descriptor
  83  */
  84 struct encoder_sys_t
  85 {
  86     JPEG_SYS_COMMON_MEMBERS
  87
  88     struct jpeg_compress_struct p_jpeg;
  89
  90     int i_blocksize;
  91     int i_quality;
  92 };
  93
  94 static const char * const ppsz_enc_options[] = {
  95     "quality",
  96     NULL
  97 };
  98
  99 static int  OpenEncoder(vlc_object_t *);
 100 static void CloseEncoder(vlc_object_t *);
 101
 102 static block_t *EncodeBlock(encoder_t *, picture_t *);
 103
 104 /*
 105  * Module descriptor
 106  */
 107 vlc_module_begin()
 108     set_category(CAT_INPUT)
 109     set_subcategory(SUBCAT_INPUT_VCODEC)
 110     /* decoder main module */
 111     set_description(N_("JPEG image decoder"))
 112     set_capability("video decoder", 1000)
 113     set_callbacks(OpenDecoder, CloseDecoder)
 114     add_shortcut("jpeg")
 115
 116     /* encoder submodule */
 117     add_submodule()
 118     add_shortcut("jpeg")
 119     set_section(N_("Encoding"), NULL)
 120     set_description(N_("JPEG image encoder"))
 121     set_capability("encoder", 1000)
 122     set_callbacks(OpenEncoder, CloseEncoder)
 123     add_integer_with_range(ENC_CFG_PREFIX "quality", 95, 0, 100,
 124                            ENC_QUALITY_TEXT, ENC_QUALITY_LONGTEXT, true)
 125 vlc_module_end()
 126
 127
 128 /*
 129  * Exit error handler for libjpeg
 130  */
 131 static void user_error_exit(j_common_ptr p_jpeg)
 132 {
 133     jpeg_sys_t *p_sys = (jpeg_sys_t *)p_jpeg->err;
 134     p_sys->err.output_message(p_jpeg);
 135     longjmp(p_sys->setjmp_buffer, 1);
 136 }
 137
 138 /*
 139  * Emit message error handler for libjpeg
 140  */
 141 static void user_error_message(j_common_ptr p_jpeg)
 142 {
 143     char error_msg[JMSG_LENGTH_MAX];
 144
 145     jpeg_sys_t *p_sys = (jpeg_sys_t *)p_jpeg->err;
 146     p_sys->err.format_message(p_jpeg, error_msg);
 147     msg_Err(p_sys->p_obj, "%s", error_msg);
 148 }
 149
 150 /*
 151  * Probe the decoder and return score
 152  */
 153 static int OpenDecoder(vlc_object_t *p_this)
 154 {
 155     decoder_t *p_dec = (decoder_t *)p_this;
 156
 157     if (p_dec->fmt_in.i_codec != VLC_CODEC_JPEG)
 158     {
 159         return VLC_EGENERIC;
 160     }
 161
 162     /* Allocate the memory needed to store the decoder's structure */
 163     decoder_sys_t *p_sys = malloc(sizeof(decoder_sys_t));
 164     if (p_sys == NULL)
 165     {
 166         return VLC_ENOMEM;
 167     }
 168
 169     p_dec->p_sys = p_sys;
 170
 171     p_sys->p_obj = p_this;
 172
 173     p_sys->p_jpeg.err = jpeg_std_error(&p_sys->err);
 174     p_sys->err.error_exit = user_error_exit;
 175     p_sys->err.output_message = user_error_message;
 176
 177     /* Set callbacks */
 178     p_dec->pf_decode = DecodeBlock;
 179
 180     p_dec->fmt_out.i_codec = VLC_CODEC_RGB24;
 181
 182     return VLC_SUCCESS;
 183 }
 184
 185 /*
 186  * The following two functions are used to return 16 and 32 bit values from
 187  * the EXIF tag structure. That structure is borrowed from TIFF files and may be
 188  * in big endian or little endian format. The boolean b_bigEndian parameter
 189  * is TRUE if the EXIF data is in big endian format, and FALSE for little endian
 190  * Case Little Endian EXIF tag / Little Endian machine
 191  *   - just memcpy the tag structure into the value to return
 192  * Case Little Endian EXIF tag / Big Endian machine
 193  *    - memcpy the tag structure into value, and bswap it
 194  * Case Little Endian EXIF tag / Big Endian machine
 195  *   - memcpy the tag structure into value, and bswap it
 196  * Case Big Endian EXIF tag / Big Endian machine
 197  *   - just memcpy the tag structure into the value to return
 198  *
 199  * While there are byte manipulation functions in vlc_common.h, none of them
 200  * address that format of the data supplied may be either big or little endian.
 201  *
 202  * The claim is made that this is the best way to do it. Can you do better?
 203 */
 204
 205 #define G_LITTLE_ENDIAN     1234
 206 #define G_BIG_ENDIAN        4321
 207
 208 typedef unsigned int uint;
 209 typedef unsigned short ushort;
 210
 211 LOCAL( unsigned short )
 212 de_get16( void * ptr, uint endian ) {
 213     unsigned short val;
 214
 215     memcpy( &val, ptr, sizeof( val ) );
 216     if ( endian == G_BIG_ENDIAN )
 217     {
 218         #ifndef WORDS_BIGENDIAN
 219         val = bswap16( val );
 220         #endif
 221     }
 222     else
 223     {
 224         #ifdef WORDS_BIGENDIAN
 225         val = bswap16( val );
 226         #endif
 227     }
 228     return val;
 229 }
 230
 231 LOCAL( unsigned int )
 232 de_get32( void * ptr, uint endian ) {
 233     unsigned int val;
 234
 235     memcpy( &val, ptr, sizeof( val ) );
 236     if ( endian == G_BIG_ENDIAN )
 237     {
 238         #ifndef WORDS_BIGENDIAN
 239         val = bswap32( val );
 240         #endif
 241     }
 242     else
 243     {
 244         #ifdef WORDS_BIGENDIAN
 245         val = bswap32( val );
 246         #endif
 247     }
 248     return val;
 249 }
 250
 251 static bool getRDFFloat(const char *psz_rdf, float *out, const char *psz_var)
 252 {
 253     char *p_start = strcasestr(psz_rdf, psz_var);
 254     if (p_start == NULL)
 255         return false;
 256
 257     size_t varlen = strlen(psz_var);
 258     p_start += varlen;
 259     char *p_end = NULL;
 260     /* XML style */
 261     if (p_start[0] == '>')
 262     {
 263         p_start += 1;
 264         p_end = strchr(p_start, '<');
 265     }
 266     else if (p_start[0] == '=' && p_start[1] == '"')
 267     {
 268         p_start += 2;
 269         p_end = strchr(p_start, '"');
 270     }
 271     if (unlikely(p_end == NULL || p_end == p_start + 1))
 272         return false;
 273
 274     *out = us_strtof(p_start, NULL);
 275     return true;
 276 }
 277
 278 #define EXIF_JPEG_MARKER    0xE1
 279 #define EXIF_XMP_STRING     "http://ns.adobe.com/xap/1.0/\000"
 280
 281 /* read XMP metadata for projection according to
 282  * https://developers.google.com/streetview/spherical-metadata */
 283 static void jpeg_GetProjection(j_decompress_ptr cinfo, video_format_t *fmt)
 284 {
 285     jpeg_saved_marker_ptr xmp_marker = NULL;
 286     jpeg_saved_marker_ptr cmarker = cinfo->marker_list;
 287
 288     while (cmarker)
 289     {
 290         if (cmarker->marker == EXIF_JPEG_MARKER)
 291         {
 292             if(cmarker->data_length >= 32 &&
 293                !memcmp(cmarker->data, EXIF_XMP_STRING, 29))
 294             {
 295                 xmp_marker = cmarker;
 296                 break;
 297             }
 298         }
 299         cmarker = cmarker->next;
 300     }
 301
 302     if (xmp_marker == NULL)
 303         return;
 304     char *psz_rdf = malloc(xmp_marker->data_length - 29 + 1);
 305     if (unlikely(psz_rdf == NULL))
 306         return;
 307     memcpy(psz_rdf, xmp_marker->data + 29, xmp_marker->data_length - 29);
 308     psz_rdf[xmp_marker->data_length - 29] = '\0';
 309
 310     /* Try to find the string "GSpherical:Spherical" because the v1
 311         spherical video spec says the tag must be there. */
 312     if (strcasestr(psz_rdf, "ProjectionType=\"equirectangular\"") ||
 313         strcasestr(psz_rdf, "ProjectionType>equirectangular"))
 314         fmt->projection_mode = PROJECTION_MODE_EQUIRECTANGULAR;
 315
 316     /* pose handling */
 317     float value;
 318     if (getRDFFloat(psz_rdf, &value, "PoseHeadingDegrees"))
 319         fmt->pose.yaw = value;
 320
 321     if (getRDFFloat(psz_rdf, &value, "PosePitchDegrees"))
 322         fmt->pose.pitch = value;
 323
 324     if (getRDFFloat(psz_rdf, &value, "PoseRollDegrees"))
 325         fmt->pose.roll = value;
 326
 327     /* initial view */
 328     if (getRDFFloat(psz_rdf, &value, "InitialViewHeadingDegrees"))
 329         fmt->pose.yaw = value;
 330
 331     if (getRDFFloat(psz_rdf, &value, "InitialViewPitchDegrees"))
 332         fmt->pose.pitch = value;
 333
 334     if (getRDFFloat(psz_rdf, &value, "InitialViewRollDegrees"))
 335         fmt->pose.roll = value;
 336
 337     if (getRDFFloat(psz_rdf, &value, "InitialHorizontalFOVDegrees"))
 338         fmt->pose.fov = value;
 339
 340     free(psz_rdf);
 341 }
 342
 343 /*
 344  * Look through the meta data in the libjpeg decompress structure to determine
 345  * if an EXIF Orientation tag is present. If so return its value (1-8),
 346  * otherwise return 0
 347  *
 348  * This function is based on the function get_orientation in io-jpeg.c, part of
 349  * the GdkPixbuf library, licensed under LGPLv2+.
 350  *   Copyright (C) 1999 Michael Zucchi, The Free Software Foundation
 351 */
 352 LOCAL( int )
 353 jpeg_GetOrientation( j_decompress_ptr cinfo )
 354 {
 355
 356     uint i;                    /* index into working buffer */
 357     ushort tag_type;           /* endianed tag type extracted from tiff header */
 358     uint ret;                  /* Return value */
 359     uint offset;               /* de-endianed offset in various situations */
 360     uint tags;                 /* number of tags in current ifd */
 361     uint type;                 /* de-endianed type of tag */
 362     uint count;                /* de-endianed count of elements in a tag */
 363     uint tiff = 0;             /* offset to active tiff header */
 364     uint endian = 0;           /* detected endian of data */
 365
 366     jpeg_saved_marker_ptr exif_marker;      /* Location of the Exif APP1 marker */
 367     jpeg_saved_marker_ptr cmarker;          /* Location to check for Exif APP1 marker */
 368
 369     const char leth[] = { 0x49, 0x49, 0x2a, 0x00 }; /* Little endian TIFF header */
 370     const char beth[] = { 0x4d, 0x4d, 0x00, 0x2a }; /* Big endian TIFF header */
 371
 372     #define EXIF_IDENT_STRING   "Exif\000\000"
 373     #define EXIF_ORIENT_TAGID   0x112
 374
 375     /* check for Exif marker (also called the APP1 marker) */
 376     exif_marker = NULL;
 377     cmarker = cinfo->marker_list;
 378
 379     while ( cmarker )
 380     {
 381         if ( cmarker->data_length >= 32 &&
 382              cmarker->marker == EXIF_JPEG_MARKER )
 383         {
 384             /* The Exif APP1 marker should contain a unique
 385                identification string ("Exif\0\0"). Check for it. */
 386             if ( !memcmp( cmarker->data, EXIF_IDENT_STRING, 6 ) )
 387             {
 388                 exif_marker = cmarker;
 389             }
 390         }
 391         cmarker = cmarker->next;
 392     }
 393
 394     /* Did we find the Exif APP1 marker? */
 395     if ( exif_marker == NULL )
 396         return 0;
 397
 398     /* Check for TIFF header and catch endianess */
 399     i = 0;
 400
 401     /* Just skip data until TIFF header - it should be within 16 bytes from marker start.
 402        Normal structure relative to APP1 marker -
 403             0x0000: APP1 marker entry = 2 bytes
 404             0x0002: APP1 length entry = 2 bytes
 405             0x0004: Exif Identifier entry = 6 bytes
 406             0x000A: Start of TIFF header (Byte order entry) - 4 bytes
 407                     - This is what we look for, to determine endianess.
 408             0x000E: 0th IFD offset pointer - 4 bytes
 409
 410             exif_marker->data points to the first data after the APP1 marker
 411             and length entries, which is the exif identification string.
 412             The TIFF header should thus normally be found at i=6, below,
 413             and the pointer to IFD0 will be at 6+4 = 10.
 414     */
 415
 416     while ( i < 16 )
 417     {
 418         /* Little endian TIFF header */
 419         if ( memcmp( &exif_marker->data[i], leth, 4 ) == 0 )
 420         {
 421             endian = G_LITTLE_ENDIAN;
 422         }
 423         /* Big endian TIFF header */
 424         else
 425         if ( memcmp( &exif_marker->data[i], beth, 4 ) == 0 )
 426         {
 427             endian = G_BIG_ENDIAN;
 428         }
 429         /* Keep looking through buffer */
 430         else
 431         {
 432             i++;
 433             continue;
 434         }
 435         /* We have found either big or little endian TIFF header */
 436         tiff = i;
 437         break;
 438     }
 439
 440     /* So did we find a TIFF header or did we just hit end of buffer? */
 441     if ( tiff == 0 )
 442         return 0;
 443
 444     /* Read out the offset pointer to IFD0 */
 445     offset = de_get32( &exif_marker->data[i] + 4, endian );
 446     i = i + offset;
 447
 448     /* Check that we still are within the buffer and can read the tag count */
 449
 450     if ( i > exif_marker->data_length - 2 )
 451         return 0;
 452
 453     /* Find out how many tags we have in IFD0. As per the TIFF spec, the first
 454        two bytes of the IFD contain a count of the number of tags. */
 455     tags = de_get16( &exif_marker->data[i], endian );
 456     i = i + 2;
 457
 458     /* Check that we still have enough data for all tags to check. The tags
 459        are listed in consecutive 12-byte blocks. The tag ID, type, size, and
 460        a pointer to the actual value, are packed into these 12 byte entries. */
 461     if ( tags * 12U > exif_marker->data_length - i )
 462         return 0;
 463
 464     /* Check through IFD0 for tags of interest */
 465     while ( tags-- )
 466     {
 467         tag_type = de_get16( &exif_marker->data[i], endian );
 468         /* Is this the orientation tag? */
 469         if ( tag_type == EXIF_ORIENT_TAGID )
 470         {
 471             type = de_get16( &exif_marker->data[i + 2], endian );
 472             count = de_get32( &exif_marker->data[i + 4], endian );
 473
 474             /* Check that type and count fields are OK. The orientation field
 475                will consist of a single (count=1) 2-byte integer (type=3). */
 476             if ( type != 3 || count != 1 )
 477                 return 0;
 478
 479             /* Return the orientation value. Within the 12-byte block, the
 480                pointer to the actual data is at offset 8. */
 481             ret = de_get16( &exif_marker->data[i + 8], endian );
 482             return ( ret <= 8 ) ? ret : 0;
 483         }
 484         /* move the pointer to the next 12-byte tag field. */
 485         i = i + 12;
 486     }
 487
 488     return 0;     /* No EXIF Orientation tag found */
 489 }
 490
 491 /*
 492  * This function must be fed with a complete compressed frame.
 493  */
 494 static int DecodeBlock(decoder_t *p_dec, block_t *p_block)
 495 {
 496     decoder_sys_t *p_sys = p_dec->p_sys;
 497     picture_t *p_pic = 0;
 498
 499     JSAMPARRAY p_row_pointers = NULL;
 500
 501     if (!p_block) /* No Drain */
 502         return VLCDEC_SUCCESS;
 503
 504     if (p_block->i_flags & BLOCK_FLAG_CORRUPTED )
 505     {
 506         block_Release(p_block);
 507         return VLCDEC_SUCCESS;
 508     }
 509
 510     /* libjpeg longjmp's there in case of error */
 511     if (setjmp(p_sys->setjmp_buffer))
 512     {
 513         goto error;
 514     }
 515
 516     jpeg_create_decompress(&p_sys->p_jpeg);
 517     jpeg_mem_src(&p_sys->p_jpeg, p_block->p_buffer, p_block->i_buffer);
 518     jpeg_save_markers( &p_sys->p_jpeg, EXIF_JPEG_MARKER, 0xffff );
 519     jpeg_read_header(&p_sys->p_jpeg, TRUE);
 520
 521     p_sys->p_jpeg.out_color_space = JCS_RGB;
 522
 523     jpeg_start_decompress(&p_sys->p_jpeg);
 524
 525     /* Set output properties */
 526     p_dec->fmt_out.video.i_visible_width  = p_dec->fmt_out.video.i_width  = p_sys->p_jpeg.output_width;
 527     p_dec->fmt_out.video.i_visible_height = p_dec->fmt_out.video.i_height = p_sys->p_jpeg.output_height;
 528     p_dec->fmt_out.video.i_sar_num = 1;
 529     p_dec->fmt_out.video.i_sar_den = 1;
 530
 531     int i_otag; /* Orientation tag has valid range of 1-8. 1 is normal orientation, 0 = unspecified = normal */
 532     i_otag = jpeg_GetOrientation( &p_sys->p_jpeg );
 533     if ( i_otag > 1 )
 534     {
 535         msg_Dbg( p_dec, "Jpeg orientation is %d", i_otag );
 536         p_dec->fmt_out.video.orientation = ORIENT_FROM_EXIF( i_otag );
 537     }
 538     jpeg_GetProjection(&p_sys->p_jpeg, &p_dec->fmt_out.video);
 539
 540     /* Get a new picture */
 541     if (decoder_UpdateVideoFormat(p_dec))
 542     {
 543         goto error;
 544     }
 545     p_pic = decoder_NewPicture(p_dec);
 546     if (!p_pic)
 547     {
 548         goto error;
 549     }
 550
 551     /* Decode picture */
 552     p_row_pointers = vlc_alloc(p_sys->p_jpeg.output_height, sizeof(JSAMPROW));
 553     if (!p_row_pointers)
 554     {
 555         goto error;
 556     }
 557     for (unsigned i = 0; i < p_sys->p_jpeg.output_height; i++) {
 558         p_row_pointers[i] = p_pic->p->p_pixels + p_pic->p->i_pitch * i;
 559     }
 560
 561     while (p_sys->p_jpeg.output_scanline < p_sys->p_jpeg.output_height)
 562     {
 563         jpeg_read_scanlines(&p_sys->p_jpeg,
 564                 p_row_pointers + p_sys->p_jpeg.output_scanline,
 565                 p_sys->p_jpeg.output_height - p_sys->p_jpeg.output_scanline);
 566     }
 567
 568     jpeg_finish_decompress(&p_sys->p_jpeg);
 569     jpeg_destroy_decompress(&p_sys->p_jpeg);
 570     free(p_row_pointers);
 571
 572     p_pic->date = p_block->i_pts > VLC_TS_INVALID ? p_block->i_pts : p_block->i_dts;
 573
 574     block_Release(p_block);
 575     decoder_QueueVideo( p_dec, p_pic );
 576     return VLCDEC_SUCCESS;
 577
 578 error:
 579
 580     jpeg_destroy_decompress(&p_sys->p_jpeg);
 581     free(p_row_pointers);
 582
 583     block_Release(p_block);
 584     return VLCDEC_SUCCESS;
 585 }
 586
 587 /*
 588  * jpeg decoder destruction
 589  */
 590 static void CloseDecoder(vlc_object_t *p_this)
 591 {
 592     decoder_t *p_dec = (decoder_t *)p_this;
 593     decoder_sys_t *p_sys = p_dec->p_sys;
 594
 595     free(p_sys);
 596 }
 597
 598 /*
 599  * Probe the encoder and return score
 600  */
 601 static int OpenEncoder(vlc_object_t *p_this)
 602 {
 603     encoder_t *p_enc = (encoder_t *)p_this;
 604
 605     config_ChainParse(p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg);
 606
 607     if (p_enc->fmt_out.i_codec != VLC_CODEC_JPEG)
 608     {
 609         return VLC_EGENERIC;
 610     }
 611
 612     /* Allocate the memory needed to store encoder's structure */
 613     encoder_sys_t *p_sys = malloc(sizeof(encoder_sys_t));
 614     if (p_sys == NULL)
 615     {
 616         return VLC_ENOMEM;
 617     }
 618
 619     p_enc->p_sys = p_sys;
 620
 621     p_sys->p_obj = p_this;
 622
 623     p_sys->p_jpeg.err = jpeg_std_error(&p_sys->err);
 624     p_sys->err.error_exit = user_error_exit;
 625     p_sys->err.output_message = user_error_message;
 626
 627     p_sys->i_quality = var_GetInteger(p_enc, ENC_CFG_PREFIX "quality");
 628     p_sys->i_blocksize = 3 * p_enc->fmt_in.video.i_visible_width * p_enc->fmt_in.video.i_visible_height;
 629
 630     p_enc->fmt_in.i_codec = VLC_CODEC_J420;
 631     p_enc->pf_encode_video = EncodeBlock;
 632
 633     return VLC_SUCCESS;
 634 }
 635
 636 /*
 637  * EncodeBlock
 638  */
 639 static block_t *EncodeBlock(encoder_t *p_enc, picture_t *p_pic)
 640 {
 641     encoder_sys_t *p_sys = p_enc->p_sys;
 642
 643     if (unlikely(!p_pic))
 644     {
 645         return NULL;
 646     }
 647     block_t *p_block = block_Alloc(p_sys->i_blocksize);
 648     if (p_block == NULL)
 649     {
 650         return NULL;
 651     }
 652
 653     JSAMPIMAGE p_row_pointers = NULL;
 654     unsigned long size = p_block->i_buffer;
 655
 656     /* libjpeg longjmp's there in case of error */
 657     if (setjmp(p_sys->setjmp_buffer))
 658     {
 659         goto error;
 660     }
 661
 662     jpeg_create_compress(&p_sys->p_jpeg);
 663     jpeg_mem_dest(&p_sys->p_jpeg, &p_block->p_buffer, &size);
 664
 665     p_sys->p_jpeg.image_width = p_enc->fmt_in.video.i_visible_width;
 666     p_sys->p_jpeg.image_height = p_enc->fmt_in.video.i_visible_height;
 667     p_sys->p_jpeg.input_components = 3;
 668     p_sys->p_jpeg.in_color_space = JCS_YCbCr;
 669
 670     jpeg_set_defaults(&p_sys->p_jpeg);
 671     jpeg_set_colorspace(&p_sys->p_jpeg, JCS_YCbCr);
 672
 673     p_sys->p_jpeg.raw_data_in = TRUE;
 674 #if JPEG_LIB_VERSION >= 70
 675     p_sys->p_jpeg.do_fancy_downsampling = FALSE;
 676 #endif
 677
 678     jpeg_set_quality(&p_sys->p_jpeg, p_sys->i_quality, TRUE);
 679
 680     jpeg_start_compress(&p_sys->p_jpeg, TRUE);
 681
 682     /* Encode picture */
 683     p_row_pointers = vlc_alloc(p_pic->i_planes, sizeof(JSAMPARRAY));
 684     if (p_row_pointers == NULL)
 685     {
 686         goto error;
 687     }
 688
 689     for (int i = 0; i < p_pic->i_planes; i++)
 690     {
 691         p_row_pointers[i] = vlc_alloc(p_sys->p_jpeg.comp_info[i].v_samp_factor, sizeof(JSAMPROW) * DCTSIZE);
 692     }
 693
 694     while (p_sys->p_jpeg.next_scanline < p_sys->p_jpeg.image_height)
 695     {
 696         for (int i = 0; i < p_pic->i_planes; i++)
 697         {
 698             int i_offset = p_sys->p_jpeg.next_scanline * p_sys->p_jpeg.comp_info[i].v_samp_factor / p_sys->p_jpeg.max_v_samp_factor;
 699
 700             for (int j = 0; j < p_sys->p_jpeg.comp_info[i].v_samp_factor * DCTSIZE; j++)
 701             {
 702                 p_row_pointers[i][j] = p_pic->p[i].p_pixels + p_pic->p[i].i_pitch * (i_offset + j);
 703             }
 704         }
 705         jpeg_write_raw_data(&p_sys->p_jpeg, p_row_pointers, p_sys->p_jpeg.max_v_samp_factor * DCTSIZE);
 706     }
 707
 708     jpeg_finish_compress(&p_sys->p_jpeg);
 709     jpeg_destroy_compress(&p_sys->p_jpeg);
 710
 711     for (int i = 0; i < p_pic->i_planes; i++)
 712     {
 713         free(p_row_pointers[i]);
 714     }
 715     free(p_row_pointers);
 716
 717     p_block->i_buffer = size;
 718     p_block->i_dts = p_block->i_pts = p_pic->date;
 719
 720     return p_block;
 721
 722 error:
 723     jpeg_destroy_compress(&p_sys->p_jpeg);
 724
 725     if (p_row_pointers != NULL)
 726     {
 727         for (int i = 0; i < p_pic->i_planes; i++)
 728         {
 729             free(p_row_pointers[i]);
 730         }
 731     }
 732     free(p_row_pointers);
 733
 734     block_Release(p_block);
 735
 736     return NULL;
 737 }
 738
 739 /*
 740  * jpeg encoder destruction
 741  */
 742 static void CloseEncoder(vlc_object_t *p_this)
 743 {
 744     encoder_t *p_enc = (encoder_t *)p_this;
 745     encoder_sys_t *p_sys = p_enc->p_sys;
 746
 747     free(p_sys);
 748 }