The Tor Browser: media/libjpeg/jdmrgext.c@b8a032363ba2

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 /*

     2  * jdmrgext.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 (C) 2011, D. R. Commander.

     8  * For conditions of distribution and use, see the accompanying README file.

     9  *

    10  * This file contains code for merged upsampling/color conversion.

    11  */

    14 /* This file is included by jdmerge.c */

    17 /*

    18  * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.

    19  */

    21 INLINE

    22 LOCAL(void)

    23 h2v1_merged_upsample_internal (j_decompress_ptr cinfo,

    24                                JSAMPIMAGE input_buf,

    25                                JDIMENSION in_row_group_ctr,

    26                                JSAMPARRAY output_buf)

    27 {

    28   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;

    29   register int y, cred, cgreen, cblue;

    30   int cb, cr;

    31   register JSAMPROW outptr;

    32   JSAMPROW inptr0, inptr1, inptr2;

    33   JDIMENSION col;

    34   /* copy these pointers into registers if possible */

    35   register JSAMPLE * range_limit = cinfo->sample_range_limit;

    36   int * Crrtab = upsample->Cr_r_tab;

    37   int * Cbbtab = upsample->Cb_b_tab;

    38   INT32 * Crgtab = upsample->Cr_g_tab;

    39   INT32 * Cbgtab = upsample->Cb_g_tab;

    40   SHIFT_TEMPS

    42   inptr0 = input_buf[0][in_row_group_ctr];

    43   inptr1 = input_buf[1][in_row_group_ctr];

    44   inptr2 = input_buf[2][in_row_group_ctr];

    45   outptr = output_buf[0];

    46   /* Loop for each pair of output pixels */

    47   for (col = cinfo->output_width >> 1; col > 0; col--) {

    48     /* Do the chroma part of the calculation */

    49     cb = GETJSAMPLE(*inptr1++);

    50     cr = GETJSAMPLE(*inptr2++);

    51     cred = Crrtab[cr];

    52     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);

    53     cblue = Cbbtab[cb];

    54     /* Fetch 2 Y values and emit 2 pixels */

    55     y  = GETJSAMPLE(*inptr0++);

    56     outptr[RGB_RED] =   range_limit[y + cred];

    57     outptr[RGB_GREEN] = range_limit[y + cgreen];

    58     outptr[RGB_BLUE] =  range_limit[y + cblue];

    59 #ifdef RGB_ALPHA

    60     outptr[RGB_ALPHA] = 0xFF;

    61 #endif

    62     outptr += RGB_PIXELSIZE;

    63     y  = GETJSAMPLE(*inptr0++);

    64     outptr[RGB_RED] =   range_limit[y + cred];

    65     outptr[RGB_GREEN] = range_limit[y + cgreen];

    66     outptr[RGB_BLUE] =  range_limit[y + cblue];

    67 #ifdef RGB_ALPHA

    68     outptr[RGB_ALPHA] = 0xFF;

    69 #endif

    70     outptr += RGB_PIXELSIZE;

    71   }

    72   /* If image width is odd, do the last output column separately */

    73   if (cinfo->output_width & 1) {

    74     cb = GETJSAMPLE(*inptr1);

    75     cr = GETJSAMPLE(*inptr2);

    76     cred = Crrtab[cr];

    77     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);

    78     cblue = Cbbtab[cb];

    79     y  = GETJSAMPLE(*inptr0);

    80     outptr[RGB_RED] =   range_limit[y + cred];

    81     outptr[RGB_GREEN] = range_limit[y + cgreen];

    82     outptr[RGB_BLUE] =  range_limit[y + cblue];

    83 #ifdef RGB_ALPHA

    84     outptr[RGB_ALPHA] = 0xFF;

    85 #endif

    86   }

    87 }

    90 /*

    91  * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.

    92  */

    94 INLINE

    95 LOCAL(void)

    96 h2v2_merged_upsample_internal (j_decompress_ptr cinfo,

    97                                JSAMPIMAGE input_buf,

    98                                JDIMENSION in_row_group_ctr,

    99                                JSAMPARRAY output_buf)

   100 {

   101   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;

   102   register int y, cred, cgreen, cblue;

   103   int cb, cr;

   104   register JSAMPROW outptr0, outptr1;

   105   JSAMPROW inptr00, inptr01, inptr1, inptr2;

   106   JDIMENSION col;

   107   /* copy these pointers into registers if possible */

   108   register JSAMPLE * range_limit = cinfo->sample_range_limit;

   109   int * Crrtab = upsample->Cr_r_tab;

   110   int * Cbbtab = upsample->Cb_b_tab;

   111   INT32 * Crgtab = upsample->Cr_g_tab;

   112   INT32 * Cbgtab = upsample->Cb_g_tab;

   113   SHIFT_TEMPS

   115   inptr00 = input_buf[0][in_row_group_ctr*2];

   116   inptr01 = input_buf[0][in_row_group_ctr*2 + 1];

   117   inptr1 = input_buf[1][in_row_group_ctr];

   118   inptr2 = input_buf[2][in_row_group_ctr];

   119   outptr0 = output_buf[0];

   120   outptr1 = output_buf[1];

   121   /* Loop for each group of output pixels */

   122   for (col = cinfo->output_width >> 1; col > 0; col--) {

   123     /* Do the chroma part of the calculation */

   124     cb = GETJSAMPLE(*inptr1++);

   125     cr = GETJSAMPLE(*inptr2++);

   126     cred = Crrtab[cr];

   127     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);

   128     cblue = Cbbtab[cb];

   129     /* Fetch 4 Y values and emit 4 pixels */

   130     y  = GETJSAMPLE(*inptr00++);

   131     outptr0[RGB_RED] =   range_limit[y + cred];

   132     outptr0[RGB_GREEN] = range_limit[y + cgreen];

   133     outptr0[RGB_BLUE] =  range_limit[y + cblue];

   134 #ifdef RGB_ALPHA

   135     outptr0[RGB_ALPHA] = 0xFF;

   136 #endif

   137     outptr0 += RGB_PIXELSIZE;

   138     y  = GETJSAMPLE(*inptr00++);

   139     outptr0[RGB_RED] =   range_limit[y + cred];

   140     outptr0[RGB_GREEN] = range_limit[y + cgreen];

   141     outptr0[RGB_BLUE] =  range_limit[y + cblue];

   142 #ifdef RGB_ALPHA

   143     outptr0[RGB_ALPHA] = 0xFF;

   144 #endif

   145     outptr0 += RGB_PIXELSIZE;

   146     y  = GETJSAMPLE(*inptr01++);

   147     outptr1[RGB_RED] =   range_limit[y + cred];

   148     outptr1[RGB_GREEN] = range_limit[y + cgreen];

   149     outptr1[RGB_BLUE] =  range_limit[y + cblue];

   150 #ifdef RGB_ALPHA

   151     outptr1[RGB_ALPHA] = 0xFF;

   152 #endif

   153     outptr1 += RGB_PIXELSIZE;

   154     y  = GETJSAMPLE(*inptr01++);

   155     outptr1[RGB_RED] =   range_limit[y + cred];

   156     outptr1[RGB_GREEN] = range_limit[y + cgreen];

   157     outptr1[RGB_BLUE] =  range_limit[y + cblue];

   158 #ifdef RGB_ALPHA

   159     outptr1[RGB_ALPHA] = 0xFF;

   160 #endif

   161     outptr1 += RGB_PIXELSIZE;

   162   }

   163   /* If image width is odd, do the last output column separately */

   164   if (cinfo->output_width & 1) {

   165     cb = GETJSAMPLE(*inptr1);

   166     cr = GETJSAMPLE(*inptr2);

   167     cred = Crrtab[cr];

   168     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);

   169     cblue = Cbbtab[cb];

   170     y  = GETJSAMPLE(*inptr00);

   171     outptr0[RGB_RED] =   range_limit[y + cred];

   172     outptr0[RGB_GREEN] = range_limit[y + cgreen];

   173     outptr0[RGB_BLUE] =  range_limit[y + cblue];

   174 #ifdef RGB_ALPHA

   175     outptr0[RGB_ALPHA] = 0xFF;

   176 #endif

   177     y  = GETJSAMPLE(*inptr01);

   178     outptr1[RGB_RED] =   range_limit[y + cred];

   179     outptr1[RGB_GREEN] = range_limit[y + cgreen];

   180     outptr1[RGB_BLUE] =  range_limit[y + cblue];

   181 #ifdef RGB_ALPHA

   182     outptr1[RGB_ALPHA] = 0xFF;

   183 #endif

   184   }

   185 }

The Tor Browser / file revision