jdmerge.c

   1 /*
   2  * jdmerge.c
   3  *
   4  * This file was part of the Independent JPEG Group's software:
   5  * Copyright (C) 1994-1996, Thomas G. Lane.
   6  * libjpeg-turbo Modifications:
   7  * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
   8  * Copyright (C) 2009, 2011, 2014-2015, D. R. Commander.
   9  * Copyright (C) 2013, Linaro Limited.
  10  * For conditions of distribution and use, see the accompanying README.ijg
  11  * file.
  12  *
  13  * This file contains code for merged upsampling/color conversion.
  14  *
  15  * This file combines functions from jdsample.c and jdcolor.c;
  16  * read those files first to understand what's going on.
  17  *
  18  * When the chroma components are to be upsampled by simple replication
  19  * (ie, box filtering), we can save some work in color conversion by
  20  * calculating all the output pixels corresponding to a pair of chroma
  21  * samples at one time.  In the conversion equations
  22  *      R = Y           + K1 * Cr
  23  *      G = Y + K2 * Cb + K3 * Cr
  24  *      B = Y + K4 * Cb
  25  * only the Y term varies among the group of pixels corresponding to a pair
  26  * of chroma samples, so the rest of the terms can be calculated just once.
  27  * At typical sampling ratios, this eliminates half or three-quarters of the
  28  * multiplications needed for color conversion.
  29  *
  30  * This file currently provides implementations for the following cases:
  31  *      YCbCr => RGB color conversion only.
  32  *      Sampling ratios of 2h1v or 2h2v.
  33  *      No scaling needed at upsample time.
  34  *      Corner-aligned (non-CCIR601) sampling alignment.
  35  * Other special cases could be added, but in most applications these are
  36  * the only common cases.  (For uncommon cases we fall back on the more
  37  * general code in jdsample.c and jdcolor.c.)
  38  */
  39
  40 #define JPEG_INTERNALS
  41 #include "jinclude.h"
  42 #include "jpeglib.h"
  43 #include "jsimd.h"
  44 #include "jconfigint.h"
  45
  46 #ifdef UPSAMPLE_MERGING_SUPPORTED
  47
  48
  49 /* Private subobject */
  50
  51 typedef struct {
  52   struct jpeg_upsampler pub;    /* public fields */
  53
  54   /* Pointer to routine to do actual upsampling/conversion of one row group */
  55   void (*upmethod) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  56                     JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf);
  57
  58   /* Private state for YCC->RGB conversion */
  59   int *Cr_r_tab;                /* => table for Cr to R conversion */
  60   int *Cb_b_tab;                /* => table for Cb to B conversion */
  61   JLONG *Cr_g_tab;              /* => table for Cr to G conversion */
  62   JLONG *Cb_g_tab;              /* => table for Cb to G conversion */
  63
  64   /* For 2:1 vertical sampling, we produce two output rows at a time.
  65    * We need a "spare" row buffer to hold the second output row if the
  66    * application provides just a one-row buffer; we also use the spare
  67    * to discard the dummy last row if the image height is odd.
  68    */
  69   JSAMPROW spare_row;
  70   boolean spare_full;           /* T if spare buffer is occupied */
  71
  72   JDIMENSION out_row_width;     /* samples per output row */
  73   JDIMENSION rows_to_go;        /* counts rows remaining in image */
  74 } my_upsampler;
  75
  76 typedef my_upsampler *my_upsample_ptr;
  77
  78 #define SCALEBITS       16      /* speediest right-shift on some machines */
  79 #define ONE_HALF        ((JLONG)1 << (SCALEBITS - 1))
  80 #define FIX(x)          ((JLONG)((x) * (1L << SCALEBITS) + 0.5))
  81
  82
  83 /* Include inline routines for colorspace extensions */
  84
  85 #include "jdmrgext.c"
  86 #undef RGB_RED
  87 #undef RGB_GREEN
  88 #undef RGB_BLUE
  89 #undef RGB_PIXELSIZE
  90
  91 #define RGB_RED  EXT_RGB_RED
  92 #define RGB_GREEN  EXT_RGB_GREEN
  93 #define RGB_BLUE  EXT_RGB_BLUE
  94 #define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
  95 #define h2v1_merged_upsample_internal  extrgb_h2v1_merged_upsample_internal
  96 #define h2v2_merged_upsample_internal  extrgb_h2v2_merged_upsample_internal
  97 #include "jdmrgext.c"
  98 #undef RGB_RED
  99 #undef RGB_GREEN
 100 #undef RGB_BLUE
 101 #undef RGB_PIXELSIZE
 102 #undef h2v1_merged_upsample_internal
 103 #undef h2v2_merged_upsample_internal
 104
 105 #define RGB_RED  EXT_RGBX_RED
 106 #define RGB_GREEN  EXT_RGBX_GREEN
 107 #define RGB_BLUE  EXT_RGBX_BLUE
 108 #define RGB_ALPHA  3
 109 #define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
 110 #define h2v1_merged_upsample_internal  extrgbx_h2v1_merged_upsample_internal
 111 #define h2v2_merged_upsample_internal  extrgbx_h2v2_merged_upsample_internal
 112 #include "jdmrgext.c"
 113 #undef RGB_RED
 114 #undef RGB_GREEN
 115 #undef RGB_BLUE
 116 #undef RGB_ALPHA
 117 #undef RGB_PIXELSIZE
 118 #undef h2v1_merged_upsample_internal
 119 #undef h2v2_merged_upsample_internal
 120
 121 #define RGB_RED  EXT_BGR_RED
 122 #define RGB_GREEN  EXT_BGR_GREEN
 123 #define RGB_BLUE  EXT_BGR_BLUE
 124 #define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
 125 #define h2v1_merged_upsample_internal  extbgr_h2v1_merged_upsample_internal
 126 #define h2v2_merged_upsample_internal  extbgr_h2v2_merged_upsample_internal
 127 #include "jdmrgext.c"
 128 #undef RGB_RED
 129 #undef RGB_GREEN
 130 #undef RGB_BLUE
 131 #undef RGB_PIXELSIZE
 132 #undef h2v1_merged_upsample_internal
 133 #undef h2v2_merged_upsample_internal
 134
 135 #define RGB_RED  EXT_BGRX_RED
 136 #define RGB_GREEN  EXT_BGRX_GREEN
 137 #define RGB_BLUE  EXT_BGRX_BLUE
 138 #define RGB_ALPHA  3
 139 #define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
 140 #define h2v1_merged_upsample_internal  extbgrx_h2v1_merged_upsample_internal
 141 #define h2v2_merged_upsample_internal  extbgrx_h2v2_merged_upsample_internal
 142 #include "jdmrgext.c"
 143 #undef RGB_RED
 144 #undef RGB_GREEN
 145 #undef RGB_BLUE
 146 #undef RGB_ALPHA
 147 #undef RGB_PIXELSIZE
 148 #undef h2v1_merged_upsample_internal
 149 #undef h2v2_merged_upsample_internal
 150
 151 #define RGB_RED  EXT_XBGR_RED
 152 #define RGB_GREEN  EXT_XBGR_GREEN
 153 #define RGB_BLUE  EXT_XBGR_BLUE
 154 #define RGB_ALPHA  0
 155 #define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
 156 #define h2v1_merged_upsample_internal  extxbgr_h2v1_merged_upsample_internal
 157 #define h2v2_merged_upsample_internal  extxbgr_h2v2_merged_upsample_internal
 158 #include "jdmrgext.c"
 159 #undef RGB_RED
 160 #undef RGB_GREEN
 161 #undef RGB_BLUE
 162 #undef RGB_ALPHA
 163 #undef RGB_PIXELSIZE
 164 #undef h2v1_merged_upsample_internal
 165 #undef h2v2_merged_upsample_internal
 166
 167 #define RGB_RED  EXT_XRGB_RED
 168 #define RGB_GREEN  EXT_XRGB_GREEN
 169 #define RGB_BLUE  EXT_XRGB_BLUE
 170 #define RGB_ALPHA  0
 171 #define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
 172 #define h2v1_merged_upsample_internal  extxrgb_h2v1_merged_upsample_internal
 173 #define h2v2_merged_upsample_internal  extxrgb_h2v2_merged_upsample_internal
 174 #include "jdmrgext.c"
 175 #undef RGB_RED
 176 #undef RGB_GREEN
 177 #undef RGB_BLUE
 178 #undef RGB_ALPHA
 179 #undef RGB_PIXELSIZE
 180 #undef h2v1_merged_upsample_internal
 181 #undef h2v2_merged_upsample_internal
 182
 183
 184 /*
 185  * Initialize tables for YCC->RGB colorspace conversion.
 186  * This is taken directly from jdcolor.c; see that file for more info.
 187  */
 188
 189 LOCAL(void)
 190 build_ycc_rgb_table(j_decompress_ptr cinfo)
 191 {
 192   my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
 193   int i;
 194   JLONG x;
 195   SHIFT_TEMPS
 196
 197   upsample->Cr_r_tab = (int *)
 198     (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 199                                 (MAXJSAMPLE + 1) * sizeof(int));
 200   upsample->Cb_b_tab = (int *)
 201     (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 202                                 (MAXJSAMPLE + 1) * sizeof(int));
 203   upsample->Cr_g_tab = (JLONG *)
 204     (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 205                                 (MAXJSAMPLE + 1) * sizeof(JLONG));
 206   upsample->Cb_g_tab = (JLONG *)
 207     (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 208                                 (MAXJSAMPLE + 1) * sizeof(JLONG));
 209
 210   for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
 211     /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
 212     /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
 213     /* Cr=>R value is nearest int to 1.40200 * x */
 214     upsample->Cr_r_tab[i] = (int)
 215                     RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
 216     /* Cb=>B value is nearest int to 1.77200 * x */
 217     upsample->Cb_b_tab[i] = (int)
 218                     RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
 219     /* Cr=>G value is scaled-up -0.71414 * x */
 220     upsample->Cr_g_tab[i] = (-FIX(0.71414)) * x;
 221     /* Cb=>G value is scaled-up -0.34414 * x */
 222     /* We also add in ONE_HALF so that need not do it in inner loop */
 223     upsample->Cb_g_tab[i] = (-FIX(0.34414)) * x + ONE_HALF;
 224   }
 225 }
 226
 227
 228 /*
 229  * Initialize for an upsampling pass.
 230  */
 231
 232 METHODDEF(void)
 233 start_pass_merged_upsample(j_decompress_ptr cinfo)
 234 {
 235   my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
 236
 237   /* Mark the spare buffer empty */
 238   upsample->spare_full = FALSE;
 239   /* Initialize total-height counter for detecting bottom of image */
 240   upsample->rows_to_go = cinfo->output_height;
 241 }
 242
 243
 244 /*
 245  * Control routine to do upsampling (and color conversion).
 246  *
 247  * The control routine just handles the row buffering considerations.
 248  */
 249
 250 METHODDEF(void)
 251 merged_2v_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 252                    JDIMENSION *in_row_group_ctr,
 253                    JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
 254                    JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
 255 /* 2:1 vertical sampling case: may need a spare row. */
 256 {
 257   my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
 258   JSAMPROW work_ptrs[2];
 259   JDIMENSION num_rows;          /* number of rows returned to caller */
 260 #if _USE_PRODUCT_TV
 261   int skip = 0;
 262 #endif
 263
 264   if (upsample->spare_full) {
 265     /* If we have a spare row saved from a previous cycle, just return it. */
 266     JDIMENSION size = upsample->out_row_width;
 267     if (cinfo->out_color_space == JCS_RGB565)
 268       size = cinfo->output_width * 2;
 269 #if _USE_PRODUCT_TV
 270     jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0, 1,
 271                       upsample->out_row_width);
 272 #else
 273     jcopy_sample_rows(&upsample->spare_row, 0, output_buf + *out_row_ctr, 0, 1,
 274                       size);
 275 #endif
 276     num_rows = 1;
 277     upsample->spare_full = FALSE;
 278   } else {
 279 #if _USE_PRODUCT_TV
 280     int _region_y = (int)cinfo->region_y;
 281     _region_y = (_region_y>>1)<<1;
 282     if ((cinfo->region_w > 0) && (cinfo->region_h > 0)) {
 283       if (((int)cinfo->output_scanline < _region_y) ||
 284         ((int)cinfo->output_scanline >= (_region_y + (int)cinfo->region_h)))
 285         skip = 1;
 286     }
 287 #endif
 288     /* Figure number of rows to return to caller. */
 289     num_rows = 2;
 290     /* Not more than the distance to the end of the image. */
 291     if (num_rows > upsample->rows_to_go)
 292       num_rows = upsample->rows_to_go;
 293     /* And not more than what the client can accept: */
 294     out_rows_avail -= *out_row_ctr;
 295     if (num_rows > out_rows_avail)
 296       num_rows = out_rows_avail;
 297     /* Create output pointer array for upsampler. */
 298     work_ptrs[0] = output_buf[*out_row_ctr];
 299     if (num_rows > 1) {
 300       work_ptrs[1] = output_buf[*out_row_ctr + 1];
 301     } else {
 302       work_ptrs[1] = upsample->spare_row;
 303       upsample->spare_full = TRUE;
 304     }
 305     /* Now do the upsampling. */
 306 #if _USE_PRODUCT_TV
 307   if (!skip)
 308     (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs);
 309 #else
 310     (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs);
 311 #endif
 312   }
 313
 314   /* Adjust counts */
 315   *out_row_ctr += num_rows;
 316   upsample->rows_to_go -= num_rows;
 317   /* When the buffer is emptied, declare this input row group consumed */
 318   if (!upsample->spare_full)
 319     (*in_row_group_ctr)++;
 320 }
 321
 322
 323 METHODDEF(void)
 324 merged_1v_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 325                    JDIMENSION *in_row_group_ctr,
 326                    JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
 327                    JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
 328 /* 1:1 vertical sampling case: much easier, never need a spare row. */
 329 {
 330   my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
 331
 332   /* Just do the upsampling. */
 333   (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
 334                          output_buf + *out_row_ctr);
 335   /* Adjust counts */
 336   (*out_row_ctr)++;
 337   (*in_row_group_ctr)++;
 338 }
 339
 340
 341 /*
 342  * These are the routines invoked by the control routines to do
 343  * the actual upsampling/conversion.  One row group is processed per call.
 344  *
 345  * Note: since we may be writing directly into application-supplied buffers,
 346  * we have to be honest about the output width; we can't assume the buffer
 347  * has been rounded up to an even width.
 348  */
 349
 350
 351 /*
 352  * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
 353  */
 354
 355 METHODDEF(void)
 356 h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 357                      JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
 358 {
 359   switch (cinfo->out_color_space) {
 360   case JCS_EXT_RGB:
 361     extrgb_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 362                                          output_buf);
 363     break;
 364   case JCS_EXT_RGBX:
 365   case JCS_EXT_RGBA:
 366     extrgbx_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 367                                           output_buf);
 368     break;
 369   case JCS_EXT_BGR:
 370     extbgr_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 371                                          output_buf);
 372     break;
 373   case JCS_EXT_BGRX:
 374   case JCS_EXT_BGRA:
 375     extbgrx_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 376                                           output_buf);
 377     break;
 378   case JCS_EXT_XBGR:
 379   case JCS_EXT_ABGR:
 380     extxbgr_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 381                                           output_buf);
 382     break;
 383   case JCS_EXT_XRGB:
 384   case JCS_EXT_ARGB:
 385     extxrgb_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 386                                           output_buf);
 387     break;
 388   default:
 389     h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 390                                   output_buf);
 391     break;
 392   }
 393 }
 394
 395
 396 /*
 397  * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
 398  */
 399
 400 METHODDEF(void)
 401 h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 402                      JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
 403 {
 404   switch (cinfo->out_color_space) {
 405   case JCS_EXT_RGB:
 406     extrgb_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 407                                          output_buf);
 408     break;
 409   case JCS_EXT_RGBX:
 410   case JCS_EXT_RGBA:
 411     extrgbx_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 412                                           output_buf);
 413     break;
 414   case JCS_EXT_BGR:
 415     extbgr_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 416                                          output_buf);
 417     break;
 418   case JCS_EXT_BGRX:
 419   case JCS_EXT_BGRA:
 420     extbgrx_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 421                                           output_buf);
 422     break;
 423   case JCS_EXT_XBGR:
 424   case JCS_EXT_ABGR:
 425     extxbgr_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 426                                           output_buf);
 427     break;
 428   case JCS_EXT_XRGB:
 429   case JCS_EXT_ARGB:
 430     extxrgb_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 431                                           output_buf);
 432     break;
 433   default:
 434     h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
 435                                   output_buf);
 436     break;
 437   }
 438 }
 439
 440
 441 /*
 442  * RGB565 conversion
 443  */
 444
 445 #define PACK_SHORT_565_LE(r, g, b)  ((((r) << 8) & 0xF800) | \
 446                                      (((g) << 3) & 0x7E0) | ((b) >> 3))
 447 #define PACK_SHORT_565_BE(r, g, b)  (((r) & 0xF8) | ((g) >> 5) | \
 448                                      (((g) << 11) & 0xE000) | \
 449                                      (((b) << 5) & 0x1F00))
 450
 451 #define PACK_TWO_PIXELS_LE(l, r)    ((r << 16) | l)
 452 #define PACK_TWO_PIXELS_BE(l, r)    ((l << 16) | r)
 453
 454 #define PACK_NEED_ALIGNMENT(ptr)    (((size_t)(ptr)) & 3)
 455
 456 #define WRITE_TWO_PIXELS_LE(addr, pixels) { \
 457   ((INT16 *)(addr))[0] = (INT16)(pixels); \
 458   ((INT16 *)(addr))[1] = (INT16)((pixels) >> 16); \
 459 }
 460 #define WRITE_TWO_PIXELS_BE(addr, pixels) { \
 461   ((INT16 *)(addr))[1] = (INT16)(pixels); \
 462   ((INT16 *)(addr))[0] = (INT16)((pixels) >> 16); \
 463 }
 464
 465 #define DITHER_565_R(r, dither)  ((r) + ((dither) & 0xFF))
 466 #define DITHER_565_G(g, dither)  ((g) + (((dither) & 0xFF) >> 1))
 467 #define DITHER_565_B(b, dither)  ((b) + ((dither) & 0xFF))
 468
 469
 470 /* Declarations for ordered dithering
 471  *
 472  * We use a 4x4 ordered dither array packed into 32 bits.  This array is
 473  * sufficient for dithering RGB888 to RGB565.
 474  */
 475
 476 #define DITHER_MASK       0x3
 477 #define DITHER_ROTATE(x)  ((((x) & 0xFF) << 24) | (((x) >> 8) & 0x00FFFFFF))
 478 static const JLONG dither_matrix[4] = {
 479   0x0008020A,
 480   0x0C040E06,
 481   0x030B0109,
 482   0x0F070D05
 483 };
 484
 485
 486 /* Include inline routines for RGB565 conversion */
 487
 488 #define PACK_SHORT_565  PACK_SHORT_565_LE
 489 #define PACK_TWO_PIXELS  PACK_TWO_PIXELS_LE
 490 #define WRITE_TWO_PIXELS  WRITE_TWO_PIXELS_LE
 491 #define h2v1_merged_upsample_565_internal  h2v1_merged_upsample_565_le
 492 #define h2v1_merged_upsample_565D_internal  h2v1_merged_upsample_565D_le
 493 #define h2v2_merged_upsample_565_internal  h2v2_merged_upsample_565_le
 494 #define h2v2_merged_upsample_565D_internal  h2v2_merged_upsample_565D_le
 495 #include "jdmrg565.c"
 496 #undef PACK_SHORT_565
 497 #undef PACK_TWO_PIXELS
 498 #undef WRITE_TWO_PIXELS
 499 #undef h2v1_merged_upsample_565_internal
 500 #undef h2v1_merged_upsample_565D_internal
 501 #undef h2v2_merged_upsample_565_internal
 502 #undef h2v2_merged_upsample_565D_internal
 503
 504 #define PACK_SHORT_565  PACK_SHORT_565_BE
 505 #define PACK_TWO_PIXELS  PACK_TWO_PIXELS_BE
 506 #define WRITE_TWO_PIXELS  WRITE_TWO_PIXELS_BE
 507 #define h2v1_merged_upsample_565_internal  h2v1_merged_upsample_565_be
 508 #define h2v1_merged_upsample_565D_internal  h2v1_merged_upsample_565D_be
 509 #define h2v2_merged_upsample_565_internal  h2v2_merged_upsample_565_be
 510 #define h2v2_merged_upsample_565D_internal  h2v2_merged_upsample_565D_be
 511 #include "jdmrg565.c"
 512 #undef PACK_SHORT_565
 513 #undef PACK_TWO_PIXELS
 514 #undef WRITE_TWO_PIXELS
 515 #undef h2v1_merged_upsample_565_internal
 516 #undef h2v1_merged_upsample_565D_internal
 517 #undef h2v2_merged_upsample_565_internal
 518 #undef h2v2_merged_upsample_565D_internal
 519
 520
 521 static INLINE boolean is_big_endian(void)
 522 {
 523   int test_value = 1;
 524   if (*(char *)&test_value != 1)
 525     return TRUE;
 526   return FALSE;
 527 }
 528
 529
 530 METHODDEF(void)
 531 h2v1_merged_upsample_565(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 532                          JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
 533 {
 534   if (is_big_endian())
 535     h2v1_merged_upsample_565_be(cinfo, input_buf, in_row_group_ctr,
 536                                 output_buf);
 537   else
 538     h2v1_merged_upsample_565_le(cinfo, input_buf, in_row_group_ctr,
 539                                 output_buf);
 540 }
 541
 542
 543 METHODDEF(void)
 544 h2v1_merged_upsample_565D(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 545                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
 546 {
 547   if (is_big_endian())
 548     h2v1_merged_upsample_565D_be(cinfo, input_buf, in_row_group_ctr,
 549                                  output_buf);
 550   else
 551     h2v1_merged_upsample_565D_le(cinfo, input_buf, in_row_group_ctr,
 552                                  output_buf);
 553 }
 554
 555
 556 METHODDEF(void)
 557 h2v2_merged_upsample_565(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 558                          JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
 559 {
 560   if (is_big_endian())
 561     h2v2_merged_upsample_565_be(cinfo, input_buf, in_row_group_ctr,
 562                                 output_buf);
 563   else
 564     h2v2_merged_upsample_565_le(cinfo, input_buf, in_row_group_ctr,
 565                                 output_buf);
 566 }
 567
 568
 569 METHODDEF(void)
 570 h2v2_merged_upsample_565D(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 571                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
 572 {
 573   if (is_big_endian())
 574     h2v2_merged_upsample_565D_be(cinfo, input_buf, in_row_group_ctr,
 575                                  output_buf);
 576   else
 577     h2v2_merged_upsample_565D_le(cinfo, input_buf, in_row_group_ctr,
 578                                  output_buf);
 579 }
 580
 581
 582 /*
 583  * Module initialization routine for merged upsampling/color conversion.
 584  *
 585  * NB: this is called under the conditions determined by use_merged_upsample()
 586  * in jdmaster.c.  That routine MUST correspond to the actual capabilities
 587  * of this module; no safety checks are made here.
 588  */
 589
 590 GLOBAL(void)
 591 jinit_merged_upsampler(j_decompress_ptr cinfo)
 592 {
 593   my_upsample_ptr upsample;
 594
 595   upsample = (my_upsample_ptr)
 596     (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 597                                 sizeof(my_upsampler));
 598   cinfo->upsample = (struct jpeg_upsampler *)upsample;
 599   upsample->pub.start_pass = start_pass_merged_upsample;
 600   upsample->pub.need_context_rows = FALSE;
 601
 602   upsample->out_row_width = cinfo->output_width * cinfo->out_color_components;
 603
 604   if (cinfo->max_v_samp_factor == 2) {
 605     upsample->pub.upsample = merged_2v_upsample;
 606     if (jsimd_can_h2v2_merged_upsample())
 607       upsample->upmethod = jsimd_h2v2_merged_upsample;
 608     else
 609       upsample->upmethod = h2v2_merged_upsample;
 610     if (cinfo->out_color_space == JCS_RGB565) {
 611       if (cinfo->dither_mode != JDITHER_NONE) {
 612         upsample->upmethod = h2v2_merged_upsample_565D;
 613       } else {
 614         upsample->upmethod = h2v2_merged_upsample_565;
 615       }
 616     }
 617     /* Allocate a spare row buffer */
 618     upsample->spare_row = (JSAMPROW)
 619       (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 620                 (size_t)(upsample->out_row_width * sizeof(JSAMPLE)));
 621   } else {
 622     upsample->pub.upsample = merged_1v_upsample;
 623     if (jsimd_can_h2v1_merged_upsample())
 624       upsample->upmethod = jsimd_h2v1_merged_upsample;
 625     else
 626       upsample->upmethod = h2v1_merged_upsample;
 627     if (cinfo->out_color_space == JCS_RGB565) {
 628       if (cinfo->dither_mode != JDITHER_NONE) {
 629         upsample->upmethod = h2v1_merged_upsample_565D;
 630       } else {
 631         upsample->upmethod = h2v1_merged_upsample_565;
 632       }
 633     }
 634     /* No spare row needed */
 635     upsample->spare_row = NULL;
 636   }
 637
 638   build_ycc_rgb_table(cinfo);
 639 }
 640
 641 #endif /* UPSAMPLE_MERGING_SUPPORTED */