Coverage Report

Created: 2025-11-11 06:32

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libjpeg-turbo.dev/src/jccolext.c
Line
Count
Source
1
/*
2
 * jccolext.c
3
 *
4
 * This file was part of the Independent JPEG Group's software:
5
 * Copyright (C) 1991-1996, Thomas G. Lane.
6
 * libjpeg-turbo Modifications:
7
 * Copyright (C) 2009-2012, 2015, 2022, 2025, D. R. Commander.
8
 * For conditions of distribution and use, see the accompanying README.ijg
9
 * file.
10
 *
11
 * This file contains input colorspace conversion routines.
12
 */
13
14
15
/* This file is included by jccolor.c */
16
17
18
/*
19
 * Convert some rows of samples to the JPEG colorspace.
20
 *
21
 * Note that we change from the application's interleaved-pixel format
22
 * to our internal noninterleaved, one-plane-per-component format.
23
 * The input buffer is therefore three times as wide as the output buffer.
24
 *
25
 * A starting row offset is provided only for the output buffer.  The caller
26
 * can easily adjust the passed input_buf value to accommodate any row
27
 * offset required on that side.
28
 */
29
30
INLINE
31
LOCAL(void)
32
rgb_ycc_convert(j_compress_ptr cinfo, _JSAMPARRAY input_buf,
33
                _JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
34
30.6M
{
35
#if BITS_IN_JSAMPLE != 16
36
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
37
  register int r, g, b;
38
  register JLONG *ctab = cconvert->rgb_ycc_tab;
39
  register _JSAMPROW inptr;
40
  register _JSAMPROW outptr0, outptr1, outptr2;
41
  register JDIMENSION col;
42
  JDIMENSION num_cols = cinfo->image_width;
43
44
65.7M
  while (--num_rows >= 0) {
45
35.0M
    inptr = *input_buf++;
46
35.0M
    outptr0 = output_buf[0][output_row];
47
35.0M
    outptr1 = output_buf[1][output_row];
48
35.0M
    outptr2 = output_buf[2][output_row];
49
35.0M
    output_row++;
50
108M
    for (col = 0; col < num_cols; col++) {
51
72.9M
      r = RANGE_LIMIT(inptr[RGB_RED]);
52
72.9M
      g = RANGE_LIMIT(inptr[RGB_GREEN]);
53
72.9M
      b = RANGE_LIMIT(inptr[RGB_BLUE]);
54
72.9M
      inptr += RGB_PIXELSIZE;
55
      /* If the inputs are 0.._MAXJSAMPLE, the outputs of these equations
56
       * must be too; we do not need an explicit range-limiting operation.
57
       * Hence the value being shifted is never negative, and we don't
58
       * need the general RIGHT_SHIFT macro.
59
       */
60
      /* Y */
61
72.9M
      outptr0[col] = (_JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
62
72.9M
                                 ctab[b + B_Y_OFF]) >> SCALEBITS);
63
      /* Cb */
64
72.9M
      outptr1[col] = (_JSAMPLE)((ctab[r + R_CB_OFF] + ctab[g + G_CB_OFF] +
65
72.9M
                                 ctab[b + B_CB_OFF]) >> SCALEBITS);
66
      /* Cr */
67
72.9M
      outptr2[col] = (_JSAMPLE)((ctab[r + R_CR_OFF] + ctab[g + G_CR_OFF] +
68
72.9M
                                 ctab[b + B_CR_OFF]) >> SCALEBITS);
69
72.9M
    }
70
35.0M
  }
71
#else
72
0
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
73
#endif
74
30.6M
}
Unexecuted instantiation: jccolor-8.c:extrgb_ycc_convert
Unexecuted instantiation: jccolor-8.c:extrgbx_ycc_convert
Unexecuted instantiation: jccolor-8.c:extbgr_ycc_convert
Unexecuted instantiation: jccolor-8.c:extbgrx_ycc_convert
Unexecuted instantiation: jccolor-8.c:extxbgr_ycc_convert
Unexecuted instantiation: jccolor-8.c:extxrgb_ycc_convert
Unexecuted instantiation: jccolor-8.c:rgb_ycc_convert
jccolor-12.c:extrgb_ycc_convert
Line
Count
Source
34
8.76M
{
35
8.76M
#if BITS_IN_JSAMPLE != 16
36
8.76M
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
37
8.76M
  register int r, g, b;
38
8.76M
  register JLONG *ctab = cconvert->rgb_ycc_tab;
39
8.76M
  register _JSAMPROW inptr;
40
8.76M
  register _JSAMPROW outptr0, outptr1, outptr2;
41
8.76M
  register JDIMENSION col;
42
8.76M
  JDIMENSION num_cols = cinfo->image_width;
43
44
17.5M
  while (--num_rows >= 0) {
45
8.76M
    inptr = *input_buf++;
46
8.76M
    outptr0 = output_buf[0][output_row];
47
8.76M
    outptr1 = output_buf[1][output_row];
48
8.76M
    outptr2 = output_buf[2][output_row];
49
8.76M
    output_row++;
50
27.0M
    for (col = 0; col < num_cols; col++) {
51
18.2M
      r = RANGE_LIMIT(inptr[RGB_RED]);
52
18.2M
      g = RANGE_LIMIT(inptr[RGB_GREEN]);
53
18.2M
      b = RANGE_LIMIT(inptr[RGB_BLUE]);
54
18.2M
      inptr += RGB_PIXELSIZE;
55
      /* If the inputs are 0.._MAXJSAMPLE, the outputs of these equations
56
       * must be too; we do not need an explicit range-limiting operation.
57
       * Hence the value being shifted is never negative, and we don't
58
       * need the general RIGHT_SHIFT macro.
59
       */
60
      /* Y */
61
18.2M
      outptr0[col] = (_JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
62
18.2M
                                 ctab[b + B_Y_OFF]) >> SCALEBITS);
63
      /* Cb */
64
18.2M
      outptr1[col] = (_JSAMPLE)((ctab[r + R_CB_OFF] + ctab[g + G_CB_OFF] +
65
18.2M
                                 ctab[b + B_CB_OFF]) >> SCALEBITS);
66
      /* Cr */
67
18.2M
      outptr2[col] = (_JSAMPLE)((ctab[r + R_CR_OFF] + ctab[g + G_CR_OFF] +
68
18.2M
                                 ctab[b + B_CR_OFF]) >> SCALEBITS);
69
18.2M
    }
70
8.76M
  }
71
#else
72
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
73
#endif
74
8.76M
}
jccolor-12.c:extrgbx_ycc_convert
Line
Count
Source
34
4.38M
{
35
4.38M
#if BITS_IN_JSAMPLE != 16
36
4.38M
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
37
4.38M
  register int r, g, b;
38
4.38M
  register JLONG *ctab = cconvert->rgb_ycc_tab;
39
4.38M
  register _JSAMPROW inptr;
40
4.38M
  register _JSAMPROW outptr0, outptr1, outptr2;
41
4.38M
  register JDIMENSION col;
42
4.38M
  JDIMENSION num_cols = cinfo->image_width;
43
44
13.1M
  while (--num_rows >= 0) {
45
8.76M
    inptr = *input_buf++;
46
8.76M
    outptr0 = output_buf[0][output_row];
47
8.76M
    outptr1 = output_buf[1][output_row];
48
8.76M
    outptr2 = output_buf[2][output_row];
49
8.76M
    output_row++;
50
27.0M
    for (col = 0; col < num_cols; col++) {
51
18.2M
      r = RANGE_LIMIT(inptr[RGB_RED]);
52
18.2M
      g = RANGE_LIMIT(inptr[RGB_GREEN]);
53
18.2M
      b = RANGE_LIMIT(inptr[RGB_BLUE]);
54
18.2M
      inptr += RGB_PIXELSIZE;
55
      /* If the inputs are 0.._MAXJSAMPLE, the outputs of these equations
56
       * must be too; we do not need an explicit range-limiting operation.
57
       * Hence the value being shifted is never negative, and we don't
58
       * need the general RIGHT_SHIFT macro.
59
       */
60
      /* Y */
61
18.2M
      outptr0[col] = (_JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
62
18.2M
                                 ctab[b + B_Y_OFF]) >> SCALEBITS);
63
      /* Cb */
64
18.2M
      outptr1[col] = (_JSAMPLE)((ctab[r + R_CB_OFF] + ctab[g + G_CB_OFF] +
65
18.2M
                                 ctab[b + B_CB_OFF]) >> SCALEBITS);
66
      /* Cr */
67
18.2M
      outptr2[col] = (_JSAMPLE)((ctab[r + R_CR_OFF] + ctab[g + G_CR_OFF] +
68
18.2M
                                 ctab[b + B_CR_OFF]) >> SCALEBITS);
69
18.2M
    }
70
8.76M
  }
71
#else
72
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
73
#endif
74
4.38M
}
jccolor-12.c:extbgr_ycc_convert
Line
Count
Source
34
8.76M
{
35
8.76M
#if BITS_IN_JSAMPLE != 16
36
8.76M
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
37
8.76M
  register int r, g, b;
38
8.76M
  register JLONG *ctab = cconvert->rgb_ycc_tab;
39
8.76M
  register _JSAMPROW inptr;
40
8.76M
  register _JSAMPROW outptr0, outptr1, outptr2;
41
8.76M
  register JDIMENSION col;
42
8.76M
  JDIMENSION num_cols = cinfo->image_width;
43
44
17.5M
  while (--num_rows >= 0) {
45
8.76M
    inptr = *input_buf++;
46
8.76M
    outptr0 = output_buf[0][output_row];
47
8.76M
    outptr1 = output_buf[1][output_row];
48
8.76M
    outptr2 = output_buf[2][output_row];
49
8.76M
    output_row++;
50
27.0M
    for (col = 0; col < num_cols; col++) {
51
18.2M
      r = RANGE_LIMIT(inptr[RGB_RED]);
52
18.2M
      g = RANGE_LIMIT(inptr[RGB_GREEN]);
53
18.2M
      b = RANGE_LIMIT(inptr[RGB_BLUE]);
54
18.2M
      inptr += RGB_PIXELSIZE;
55
      /* If the inputs are 0.._MAXJSAMPLE, the outputs of these equations
56
       * must be too; we do not need an explicit range-limiting operation.
57
       * Hence the value being shifted is never negative, and we don't
58
       * need the general RIGHT_SHIFT macro.
59
       */
60
      /* Y */
61
18.2M
      outptr0[col] = (_JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
62
18.2M
                                 ctab[b + B_Y_OFF]) >> SCALEBITS);
63
      /* Cb */
64
18.2M
      outptr1[col] = (_JSAMPLE)((ctab[r + R_CB_OFF] + ctab[g + G_CB_OFF] +
65
18.2M
                                 ctab[b + B_CB_OFF]) >> SCALEBITS);
66
      /* Cr */
67
18.2M
      outptr2[col] = (_JSAMPLE)((ctab[r + R_CR_OFF] + ctab[g + G_CR_OFF] +
68
18.2M
                                 ctab[b + B_CR_OFF]) >> SCALEBITS);
69
18.2M
    }
70
8.76M
  }
71
#else
72
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
73
#endif
74
8.76M
}
jccolor-12.c:extbgrx_ycc_convert
Line
Count
Source
34
8.76M
{
35
8.76M
#if BITS_IN_JSAMPLE != 16
36
8.76M
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
37
8.76M
  register int r, g, b;
38
8.76M
  register JLONG *ctab = cconvert->rgb_ycc_tab;
39
8.76M
  register _JSAMPROW inptr;
40
8.76M
  register _JSAMPROW outptr0, outptr1, outptr2;
41
8.76M
  register JDIMENSION col;
42
8.76M
  JDIMENSION num_cols = cinfo->image_width;
43
44
17.5M
  while (--num_rows >= 0) {
45
8.76M
    inptr = *input_buf++;
46
8.76M
    outptr0 = output_buf[0][output_row];
47
8.76M
    outptr1 = output_buf[1][output_row];
48
8.76M
    outptr2 = output_buf[2][output_row];
49
8.76M
    output_row++;
50
27.0M
    for (col = 0; col < num_cols; col++) {
51
18.2M
      r = RANGE_LIMIT(inptr[RGB_RED]);
52
18.2M
      g = RANGE_LIMIT(inptr[RGB_GREEN]);
53
18.2M
      b = RANGE_LIMIT(inptr[RGB_BLUE]);
54
18.2M
      inptr += RGB_PIXELSIZE;
55
      /* If the inputs are 0.._MAXJSAMPLE, the outputs of these equations
56
       * must be too; we do not need an explicit range-limiting operation.
57
       * Hence the value being shifted is never negative, and we don't
58
       * need the general RIGHT_SHIFT macro.
59
       */
60
      /* Y */
61
18.2M
      outptr0[col] = (_JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
62
18.2M
                                 ctab[b + B_Y_OFF]) >> SCALEBITS);
63
      /* Cb */
64
18.2M
      outptr1[col] = (_JSAMPLE)((ctab[r + R_CB_OFF] + ctab[g + G_CB_OFF] +
65
18.2M
                                 ctab[b + B_CB_OFF]) >> SCALEBITS);
66
      /* Cr */
67
18.2M
      outptr2[col] = (_JSAMPLE)((ctab[r + R_CR_OFF] + ctab[g + G_CR_OFF] +
68
18.2M
                                 ctab[b + B_CR_OFF]) >> SCALEBITS);
69
18.2M
    }
70
8.76M
  }
71
#else
72
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
73
#endif
74
8.76M
}
Unexecuted instantiation: jccolor-12.c:extxbgr_ycc_convert
Unexecuted instantiation: jccolor-12.c:extxrgb_ycc_convert
Unexecuted instantiation: jccolor-16.c:extrgb_ycc_convert
Unexecuted instantiation: jccolor-16.c:extrgbx_ycc_convert
Unexecuted instantiation: jccolor-16.c:extbgr_ycc_convert
Unexecuted instantiation: jccolor-16.c:extbgrx_ycc_convert
Unexecuted instantiation: jccolor-16.c:extxbgr_ycc_convert
Unexecuted instantiation: jccolor-16.c:extxrgb_ycc_convert
Unexecuted instantiation: jccolor-16.c:rgb_ycc_convert
75
76
77
/**************** Cases other than RGB -> YCbCr **************/
78
79
80
/*
81
 * Convert some rows of samples to the JPEG colorspace.
82
 * This version handles RGB->grayscale conversion, which is the same
83
 * as the RGB->Y portion of RGB->YCbCr.
84
 * We assume rgb_ycc_start has been called (we only use the Y tables).
85
 */
86
87
INLINE
88
LOCAL(void)
89
rgb_gray_convert(j_compress_ptr cinfo, _JSAMPARRAY input_buf,
90
                 _JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
91
8.76M
{
92
#if BITS_IN_JSAMPLE != 16
93
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
94
  register int r, g, b;
95
  register JLONG *ctab = cconvert->rgb_ycc_tab;
96
  register _JSAMPROW inptr;
97
  register _JSAMPROW outptr;
98
  register JDIMENSION col;
99
  JDIMENSION num_cols = cinfo->image_width;
100
101
17.5M
  while (--num_rows >= 0) {
102
8.76M
    inptr = *input_buf++;
103
8.76M
    outptr = output_buf[0][output_row];
104
8.76M
    output_row++;
105
27.0M
    for (col = 0; col < num_cols; col++) {
106
18.2M
      r = RANGE_LIMIT(inptr[RGB_RED]);
107
18.2M
      g = RANGE_LIMIT(inptr[RGB_GREEN]);
108
18.2M
      b = RANGE_LIMIT(inptr[RGB_BLUE]);
109
18.2M
      inptr += RGB_PIXELSIZE;
110
      /* Y */
111
18.2M
      outptr[col] = (_JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
112
18.2M
                                ctab[b + B_Y_OFF]) >> SCALEBITS);
113
18.2M
    }
114
8.76M
  }
115
#else
116
0
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
117
#endif
118
8.76M
}
Unexecuted instantiation: jccolor-8.c:extrgb_gray_convert
Unexecuted instantiation: jccolor-8.c:extrgbx_gray_convert
Unexecuted instantiation: jccolor-8.c:extbgr_gray_convert
Unexecuted instantiation: jccolor-8.c:extbgrx_gray_convert
Unexecuted instantiation: jccolor-8.c:extxbgr_gray_convert
Unexecuted instantiation: jccolor-8.c:extxrgb_gray_convert
Unexecuted instantiation: jccolor-8.c:rgb_gray_convert
Unexecuted instantiation: jccolor-12.c:extrgb_gray_convert
Unexecuted instantiation: jccolor-12.c:extrgbx_gray_convert
Unexecuted instantiation: jccolor-12.c:extbgr_gray_convert
Unexecuted instantiation: jccolor-12.c:extbgrx_gray_convert
Unexecuted instantiation: jccolor-12.c:extxbgr_gray_convert
jccolor-12.c:extxrgb_gray_convert
Line
Count
Source
91
8.76M
{
92
8.76M
#if BITS_IN_JSAMPLE != 16
93
8.76M
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
94
8.76M
  register int r, g, b;
95
8.76M
  register JLONG *ctab = cconvert->rgb_ycc_tab;
96
8.76M
  register _JSAMPROW inptr;
97
8.76M
  register _JSAMPROW outptr;
98
8.76M
  register JDIMENSION col;
99
8.76M
  JDIMENSION num_cols = cinfo->image_width;
100
101
17.5M
  while (--num_rows >= 0) {
102
8.76M
    inptr = *input_buf++;
103
8.76M
    outptr = output_buf[0][output_row];
104
8.76M
    output_row++;
105
27.0M
    for (col = 0; col < num_cols; col++) {
106
18.2M
      r = RANGE_LIMIT(inptr[RGB_RED]);
107
18.2M
      g = RANGE_LIMIT(inptr[RGB_GREEN]);
108
18.2M
      b = RANGE_LIMIT(inptr[RGB_BLUE]);
109
18.2M
      inptr += RGB_PIXELSIZE;
110
      /* Y */
111
18.2M
      outptr[col] = (_JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
112
18.2M
                                ctab[b + B_Y_OFF]) >> SCALEBITS);
113
18.2M
    }
114
8.76M
  }
115
#else
116
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
117
#endif
118
8.76M
}
Unexecuted instantiation: jccolor-16.c:extrgb_gray_convert
Unexecuted instantiation: jccolor-16.c:extrgbx_gray_convert
Unexecuted instantiation: jccolor-16.c:extbgr_gray_convert
Unexecuted instantiation: jccolor-16.c:extbgrx_gray_convert
Unexecuted instantiation: jccolor-16.c:extxbgr_gray_convert
Unexecuted instantiation: jccolor-16.c:extxrgb_gray_convert
Unexecuted instantiation: jccolor-16.c:rgb_gray_convert
119
120
121
/*
122
 * Convert some rows of samples to the JPEG colorspace.
123
 * This version handles extended RGB->plain RGB conversion
124
 */
125
126
INLINE
127
LOCAL(void)
128
rgb_rgb_convert(j_compress_ptr cinfo, _JSAMPARRAY input_buf,
129
                _JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
130
23.7M
{
131
23.7M
  register _JSAMPROW inptr;
132
23.7M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
23.7M
  register JDIMENSION col;
134
23.7M
  JDIMENSION num_cols = cinfo->image_width;
135
136
47.4M
  while (--num_rows >= 0) {
137
23.7M
    inptr = *input_buf++;
138
23.7M
    outptr0 = output_buf[0][output_row];
139
23.7M
    outptr1 = output_buf[1][output_row];
140
23.7M
    outptr2 = output_buf[2][output_row];
141
23.7M
    output_row++;
142
123M
    for (col = 0; col < num_cols; col++) {
143
100M
      outptr0[col] = inptr[RGB_RED];
144
100M
      outptr1[col] = inptr[RGB_GREEN];
145
100M
      outptr2[col] = inptr[RGB_BLUE];
146
100M
      inptr += RGB_PIXELSIZE;
147
100M
    }
148
23.7M
  }
149
23.7M
}
Unexecuted instantiation: jccolor-8.c:extrgb_rgb_convert
jccolor-8.c:extrgbx_rgb_convert
Line
Count
Source
130
1.94M
{
131
1.94M
  register _JSAMPROW inptr;
132
1.94M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
1.94M
  register JDIMENSION col;
134
1.94M
  JDIMENSION num_cols = cinfo->image_width;
135
136
3.88M
  while (--num_rows >= 0) {
137
1.94M
    inptr = *input_buf++;
138
1.94M
    outptr0 = output_buf[0][output_row];
139
1.94M
    outptr1 = output_buf[1][output_row];
140
1.94M
    outptr2 = output_buf[2][output_row];
141
1.94M
    output_row++;
142
11.3M
    for (col = 0; col < num_cols; col++) {
143
9.40M
      outptr0[col] = inptr[RGB_RED];
144
9.40M
      outptr1[col] = inptr[RGB_GREEN];
145
9.40M
      outptr2[col] = inptr[RGB_BLUE];
146
9.40M
      inptr += RGB_PIXELSIZE;
147
9.40M
    }
148
1.94M
  }
149
1.94M
}
jccolor-8.c:extbgr_rgb_convert
Line
Count
Source
130
1.94M
{
131
1.94M
  register _JSAMPROW inptr;
132
1.94M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
1.94M
  register JDIMENSION col;
134
1.94M
  JDIMENSION num_cols = cinfo->image_width;
135
136
3.88M
  while (--num_rows >= 0) {
137
1.94M
    inptr = *input_buf++;
138
1.94M
    outptr0 = output_buf[0][output_row];
139
1.94M
    outptr1 = output_buf[1][output_row];
140
1.94M
    outptr2 = output_buf[2][output_row];
141
1.94M
    output_row++;
142
11.3M
    for (col = 0; col < num_cols; col++) {
143
9.40M
      outptr0[col] = inptr[RGB_RED];
144
9.40M
      outptr1[col] = inptr[RGB_GREEN];
145
9.40M
      outptr2[col] = inptr[RGB_BLUE];
146
9.40M
      inptr += RGB_PIXELSIZE;
147
9.40M
    }
148
1.94M
  }
149
1.94M
}
jccolor-8.c:extbgrx_rgb_convert
Line
Count
Source
130
1.94M
{
131
1.94M
  register _JSAMPROW inptr;
132
1.94M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
1.94M
  register JDIMENSION col;
134
1.94M
  JDIMENSION num_cols = cinfo->image_width;
135
136
3.88M
  while (--num_rows >= 0) {
137
1.94M
    inptr = *input_buf++;
138
1.94M
    outptr0 = output_buf[0][output_row];
139
1.94M
    outptr1 = output_buf[1][output_row];
140
1.94M
    outptr2 = output_buf[2][output_row];
141
1.94M
    output_row++;
142
11.3M
    for (col = 0; col < num_cols; col++) {
143
9.40M
      outptr0[col] = inptr[RGB_RED];
144
9.40M
      outptr1[col] = inptr[RGB_GREEN];
145
9.40M
      outptr2[col] = inptr[RGB_BLUE];
146
9.40M
      inptr += RGB_PIXELSIZE;
147
9.40M
    }
148
1.94M
  }
149
1.94M
}
Unexecuted instantiation: jccolor-8.c:extxbgr_rgb_convert
jccolor-8.c:extxrgb_rgb_convert
Line
Count
Source
130
1.94M
{
131
1.94M
  register _JSAMPROW inptr;
132
1.94M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
1.94M
  register JDIMENSION col;
134
1.94M
  JDIMENSION num_cols = cinfo->image_width;
135
136
3.88M
  while (--num_rows >= 0) {
137
1.94M
    inptr = *input_buf++;
138
1.94M
    outptr0 = output_buf[0][output_row];
139
1.94M
    outptr1 = output_buf[1][output_row];
140
1.94M
    outptr2 = output_buf[2][output_row];
141
1.94M
    output_row++;
142
11.3M
    for (col = 0; col < num_cols; col++) {
143
9.40M
      outptr0[col] = inptr[RGB_RED];
144
9.40M
      outptr1[col] = inptr[RGB_GREEN];
145
9.40M
      outptr2[col] = inptr[RGB_BLUE];
146
9.40M
      inptr += RGB_PIXELSIZE;
147
9.40M
    }
148
1.94M
  }
149
1.94M
}
Unexecuted instantiation: jccolor-12.c:extrgb_rgb_convert
jccolor-12.c:extrgbx_rgb_convert
Line
Count
Source
130
1.77M
{
131
1.77M
  register _JSAMPROW inptr;
132
1.77M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
1.77M
  register JDIMENSION col;
134
1.77M
  JDIMENSION num_cols = cinfo->image_width;
135
136
3.55M
  while (--num_rows >= 0) {
137
1.77M
    inptr = *input_buf++;
138
1.77M
    outptr0 = output_buf[0][output_row];
139
1.77M
    outptr1 = output_buf[1][output_row];
140
1.77M
    outptr2 = output_buf[2][output_row];
141
1.77M
    output_row++;
142
5.89M
    for (col = 0; col < num_cols; col++) {
143
4.11M
      outptr0[col] = inptr[RGB_RED];
144
4.11M
      outptr1[col] = inptr[RGB_GREEN];
145
4.11M
      outptr2[col] = inptr[RGB_BLUE];
146
4.11M
      inptr += RGB_PIXELSIZE;
147
4.11M
    }
148
1.77M
  }
149
1.77M
}
jccolor-12.c:extbgr_rgb_convert
Line
Count
Source
130
1.77M
{
131
1.77M
  register _JSAMPROW inptr;
132
1.77M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
1.77M
  register JDIMENSION col;
134
1.77M
  JDIMENSION num_cols = cinfo->image_width;
135
136
3.55M
  while (--num_rows >= 0) {
137
1.77M
    inptr = *input_buf++;
138
1.77M
    outptr0 = output_buf[0][output_row];
139
1.77M
    outptr1 = output_buf[1][output_row];
140
1.77M
    outptr2 = output_buf[2][output_row];
141
1.77M
    output_row++;
142
5.89M
    for (col = 0; col < num_cols; col++) {
143
4.11M
      outptr0[col] = inptr[RGB_RED];
144
4.11M
      outptr1[col] = inptr[RGB_GREEN];
145
4.11M
      outptr2[col] = inptr[RGB_BLUE];
146
4.11M
      inptr += RGB_PIXELSIZE;
147
4.11M
    }
148
1.77M
  }
149
1.77M
}
jccolor-12.c:extbgrx_rgb_convert
Line
Count
Source
130
1.77M
{
131
1.77M
  register _JSAMPROW inptr;
132
1.77M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
1.77M
  register JDIMENSION col;
134
1.77M
  JDIMENSION num_cols = cinfo->image_width;
135
136
3.55M
  while (--num_rows >= 0) {
137
1.77M
    inptr = *input_buf++;
138
1.77M
    outptr0 = output_buf[0][output_row];
139
1.77M
    outptr1 = output_buf[1][output_row];
140
1.77M
    outptr2 = output_buf[2][output_row];
141
1.77M
    output_row++;
142
5.89M
    for (col = 0; col < num_cols; col++) {
143
4.11M
      outptr0[col] = inptr[RGB_RED];
144
4.11M
      outptr1[col] = inptr[RGB_GREEN];
145
4.11M
      outptr2[col] = inptr[RGB_BLUE];
146
4.11M
      inptr += RGB_PIXELSIZE;
147
4.11M
    }
148
1.77M
  }
149
1.77M
}
Unexecuted instantiation: jccolor-12.c:extxbgr_rgb_convert
jccolor-12.c:extxrgb_rgb_convert
Line
Count
Source
130
1.77M
{
131
1.77M
  register _JSAMPROW inptr;
132
1.77M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
1.77M
  register JDIMENSION col;
134
1.77M
  JDIMENSION num_cols = cinfo->image_width;
135
136
3.55M
  while (--num_rows >= 0) {
137
1.77M
    inptr = *input_buf++;
138
1.77M
    outptr0 = output_buf[0][output_row];
139
1.77M
    outptr1 = output_buf[1][output_row];
140
1.77M
    outptr2 = output_buf[2][output_row];
141
1.77M
    output_row++;
142
5.89M
    for (col = 0; col < num_cols; col++) {
143
4.11M
      outptr0[col] = inptr[RGB_RED];
144
4.11M
      outptr1[col] = inptr[RGB_GREEN];
145
4.11M
      outptr2[col] = inptr[RGB_BLUE];
146
4.11M
      inptr += RGB_PIXELSIZE;
147
4.11M
    }
148
1.77M
  }
149
1.77M
}
Unexecuted instantiation: jccolor-16.c:extrgb_rgb_convert
jccolor-16.c:extrgbx_rgb_convert
Line
Count
Source
130
2.20M
{
131
2.20M
  register _JSAMPROW inptr;
132
2.20M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
2.20M
  register JDIMENSION col;
134
2.20M
  JDIMENSION num_cols = cinfo->image_width;
135
136
4.41M
  while (--num_rows >= 0) {
137
2.20M
    inptr = *input_buf++;
138
2.20M
    outptr0 = output_buf[0][output_row];
139
2.20M
    outptr1 = output_buf[1][output_row];
140
2.20M
    outptr2 = output_buf[2][output_row];
141
2.20M
    output_row++;
142
13.7M
    for (col = 0; col < num_cols; col++) {
143
11.5M
      outptr0[col] = inptr[RGB_RED];
144
11.5M
      outptr1[col] = inptr[RGB_GREEN];
145
11.5M
      outptr2[col] = inptr[RGB_BLUE];
146
11.5M
      inptr += RGB_PIXELSIZE;
147
11.5M
    }
148
2.20M
  }
149
2.20M
}
jccolor-16.c:extbgr_rgb_convert
Line
Count
Source
130
2.20M
{
131
2.20M
  register _JSAMPROW inptr;
132
2.20M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
2.20M
  register JDIMENSION col;
134
2.20M
  JDIMENSION num_cols = cinfo->image_width;
135
136
4.41M
  while (--num_rows >= 0) {
137
2.20M
    inptr = *input_buf++;
138
2.20M
    outptr0 = output_buf[0][output_row];
139
2.20M
    outptr1 = output_buf[1][output_row];
140
2.20M
    outptr2 = output_buf[2][output_row];
141
2.20M
    output_row++;
142
13.7M
    for (col = 0; col < num_cols; col++) {
143
11.5M
      outptr0[col] = inptr[RGB_RED];
144
11.5M
      outptr1[col] = inptr[RGB_GREEN];
145
11.5M
      outptr2[col] = inptr[RGB_BLUE];
146
11.5M
      inptr += RGB_PIXELSIZE;
147
11.5M
    }
148
2.20M
  }
149
2.20M
}
jccolor-16.c:extbgrx_rgb_convert
Line
Count
Source
130
2.20M
{
131
2.20M
  register _JSAMPROW inptr;
132
2.20M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
2.20M
  register JDIMENSION col;
134
2.20M
  JDIMENSION num_cols = cinfo->image_width;
135
136
4.41M
  while (--num_rows >= 0) {
137
2.20M
    inptr = *input_buf++;
138
2.20M
    outptr0 = output_buf[0][output_row];
139
2.20M
    outptr1 = output_buf[1][output_row];
140
2.20M
    outptr2 = output_buf[2][output_row];
141
2.20M
    output_row++;
142
13.7M
    for (col = 0; col < num_cols; col++) {
143
11.5M
      outptr0[col] = inptr[RGB_RED];
144
11.5M
      outptr1[col] = inptr[RGB_GREEN];
145
11.5M
      outptr2[col] = inptr[RGB_BLUE];
146
11.5M
      inptr += RGB_PIXELSIZE;
147
11.5M
    }
148
2.20M
  }
149
2.20M
}
Unexecuted instantiation: jccolor-16.c:extxbgr_rgb_convert
jccolor-16.c:extxrgb_rgb_convert
Line
Count
Source
130
2.20M
{
131
2.20M
  register _JSAMPROW inptr;
132
2.20M
  register _JSAMPROW outptr0, outptr1, outptr2;
133
2.20M
  register JDIMENSION col;
134
2.20M
  JDIMENSION num_cols = cinfo->image_width;
135
136
4.41M
  while (--num_rows >= 0) {
137
2.20M
    inptr = *input_buf++;
138
2.20M
    outptr0 = output_buf[0][output_row];
139
2.20M
    outptr1 = output_buf[1][output_row];
140
2.20M
    outptr2 = output_buf[2][output_row];
141
2.20M
    output_row++;
142
13.7M
    for (col = 0; col < num_cols; col++) {
143
11.5M
      outptr0[col] = inptr[RGB_RED];
144
11.5M
      outptr1[col] = inptr[RGB_GREEN];
145
11.5M
      outptr2[col] = inptr[RGB_BLUE];
146
11.5M
      inptr += RGB_PIXELSIZE;
147
11.5M
    }
148
2.20M
  }
149
2.20M
}