Coverage Report

Created: 2025-07-14 06:10

/src/libjpeg-turbo.3.0.x/turbojpeg-mp.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright (C)2009-2024 D. R. Commander.  All Rights Reserved.
3
 *
4
 * Redistribution and use in source and binary forms, with or without
5
 * modification, are permitted provided that the following conditions are met:
6
 *
7
 * - Redistributions of source code must retain the above copyright notice,
8
 *   this list of conditions and the following disclaimer.
9
 * - Redistributions in binary form must reproduce the above copyright notice,
10
 *   this list of conditions and the following disclaimer in the documentation
11
 *   and/or other materials provided with the distribution.
12
 * - Neither the name of the libjpeg-turbo Project nor the names of its
13
 *   contributors may be used to endorse or promote products derived from this
14
 *   software without specific prior written permission.
15
 *
16
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
17
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
20
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26
 * POSSIBILITY OF SUCH DAMAGE.
27
 */
28
29
/* TurboJPEG API functions that must be compiled for multiple data
30
   precisions */
31
32
#if BITS_IN_JSAMPLE == 8
33
97.6M
#define _JSAMPLE  JSAMPLE
34
25.8k
#define _JSAMPROW  JSAMPROW
35
97.6M
#define _buffer  buffer
36
47.5k
#define _jinit_read_ppm  jinit_read_ppm
37
0
#define _jinit_write_ppm  jinit_write_ppm
38
0
#define _jpeg_crop_scanline  jpeg_crop_scanline
39
13.3M
#define _jpeg_read_scanlines  jpeg_read_scanlines
40
0
#define _jpeg_skip_scanlines  jpeg_skip_scanlines
41
17.9k
#define _jpeg_write_scanlines  jpeg_write_scanlines
42
#elif BITS_IN_JSAMPLE == 12
43
99.0M
#define _JSAMPLE  J12SAMPLE
44
33.9k
#define _JSAMPROW  J12SAMPROW
45
98.9M
#define _buffer  buffer12
46
39.9k
#define _jinit_read_ppm  j12init_read_ppm
47
0
#define _jinit_write_ppm  j12init_write_ppm
48
0
#define _jpeg_crop_scanline  jpeg12_crop_scanline
49
9.75M
#define _jpeg_read_scanlines  jpeg12_read_scanlines
50
0
#define _jpeg_skip_scanlines  jpeg12_skip_scanlines
51
26.6k
#define _jpeg_write_scanlines  jpeg12_write_scanlines
52
#elif BITS_IN_JSAMPLE == 16
53
14.0M
#define _JSAMPLE  J16SAMPLE
54
5.89k
#define _JSAMPROW  J16SAMPROW
55
14.0M
#define _buffer  buffer16
56
10.9k
#define _jinit_read_ppm  j16init_read_ppm
57
0
#define _jinit_write_ppm  j16init_write_ppm
58
497k
#define _jpeg_read_scanlines  jpeg16_read_scanlines
59
4.53k
#define _jpeg_write_scanlines  jpeg16_write_scanlines
60
#endif
61
62
#define _GET_NAME(name, suffix)  name##suffix
63
#define GET_NAME(name, suffix)  _GET_NAME(name, suffix)
64
182k
#define _GET_STRING(name, suffix)  #name #suffix
65
182k
#define GET_STRING(name, suffix)  _GET_STRING(name, suffix)
66
67
68
/******************************** Compressor *********************************/
69
70
/* TurboJPEG 3+ */
71
DLLEXPORT int GET_NAME(tj3Compress, BITS_IN_JSAMPLE)
72
  (tjhandle handle, const _JSAMPLE *srcBuf, int width, int pitch, int height,
73
   int pixelFormat, unsigned char **jpegBuf, size_t *jpegSize)
74
49.3k
{
75
49.3k
  static const char FUNCTION_NAME[] = GET_STRING(tj3Compress, BITS_IN_JSAMPLE);
76
49.3k
  int i, retval = 0;
77
49.3k
  boolean alloc = TRUE;
78
49.3k
  _JSAMPROW *row_pointer = NULL;
79
80
49.3k
  GET_CINSTANCE(handle)
81
49.3k
  if ((this->init & COMPRESS) == 0)
82
49.3k
    THROW("Instance has not been initialized for compression");
83
84
49.3k
  if (srcBuf == NULL || width <= 0 || pitch < 0 || height <= 0 ||
85
49.3k
      pixelFormat < 0 || pixelFormat >= TJ_NUMPF || jpegBuf == NULL ||
86
49.3k
      jpegSize == NULL)
87
49.3k
    THROW("Invalid argument");
88
89
49.3k
  if (!this->lossless && this->quality == -1)
90
49.3k
    THROW("TJPARAM_QUALITY must be specified");
91
49.3k
  if (!this->lossless && this->subsamp == TJSAMP_UNKNOWN)
92
49.3k
    THROW("TJPARAM_SUBSAMP must be specified");
93
94
49.3k
  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];
95
96
49.3k
  if ((row_pointer = (_JSAMPROW *)malloc(sizeof(_JSAMPROW) * height)) == NULL)
97
49.3k
    THROW("Memory allocation failure");
98
99
49.3k
  if (setjmp(this->jerr.setjmp_buffer)) {
100
    /* If we get here, the JPEG code has signaled an error. */
101
254
    retval = -1;  goto bailout;
102
254
  }
103
104
49.1k
  cinfo->image_width = width;
105
49.1k
  cinfo->image_height = height;
106
49.1k
  cinfo->data_precision = BITS_IN_JSAMPLE;
107
108
49.1k
  setCompDefaults(this, pixelFormat);
109
49.1k
  if (this->noRealloc) {
110
42.1k
    alloc = FALSE;
111
42.1k
    *jpegSize = tj3JPEGBufSize(width, height, this->subsamp);
112
42.1k
  }
113
49.1k
  jpeg_mem_dest_tj(cinfo, jpegBuf, jpegSize, alloc);
114
115
49.1k
  jpeg_start_compress(cinfo, TRUE);
116
170M
  for (i = 0; i < height; i++) {
117
169M
    if (this->bottomUp)
118
24.4M
      row_pointer[i] = (_JSAMPROW)&srcBuf[(height - i - 1) * (size_t)pitch];
119
145M
    else
120
145M
      row_pointer[i] = (_JSAMPROW)&srcBuf[i * (size_t)pitch];
121
169M
  }
122
98.2k
  while (cinfo->next_scanline < cinfo->image_height)
123
49.1k
    _jpeg_write_scanlines(cinfo, &row_pointer[cinfo->next_scanline],
124
49.1k
                          cinfo->image_height - cinfo->next_scanline);
125
49.1k
  jpeg_finish_compress(cinfo);
126
127
49.3k
bailout:
128
49.3k
  if (cinfo->global_state > CSTATE_START && alloc)
129
29
    (*cinfo->dest->term_destination) (cinfo);
130
49.3k
  if (cinfo->global_state > CSTATE_START || retval == -1)
131
254
    jpeg_abort_compress(cinfo);
132
49.3k
  free(row_pointer);
133
49.3k
  if (this->jerr.warning) retval = -1;
134
49.3k
  return retval;
135
49.1k
}
tj3Compress8
Line
Count
Source
74
18.0k
{
75
18.0k
  static const char FUNCTION_NAME[] = GET_STRING(tj3Compress, BITS_IN_JSAMPLE);
76
18.0k
  int i, retval = 0;
77
18.0k
  boolean alloc = TRUE;
78
18.0k
  _JSAMPROW *row_pointer = NULL;
79
80
18.0k
  GET_CINSTANCE(handle)
81
18.0k
  if ((this->init & COMPRESS) == 0)
82
18.0k
    THROW("Instance has not been initialized for compression");
83
84
18.0k
  if (srcBuf == NULL || width <= 0 || pitch < 0 || height <= 0 ||
85
18.0k
      pixelFormat < 0 || pixelFormat >= TJ_NUMPF || jpegBuf == NULL ||
86
18.0k
      jpegSize == NULL)
87
18.0k
    THROW("Invalid argument");
88
89
18.0k
  if (!this->lossless && this->quality == -1)
90
18.0k
    THROW("TJPARAM_QUALITY must be specified");
91
18.0k
  if (!this->lossless && this->subsamp == TJSAMP_UNKNOWN)
92
18.0k
    THROW("TJPARAM_SUBSAMP must be specified");
93
94
18.0k
  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];
95
96
18.0k
  if ((row_pointer = (_JSAMPROW *)malloc(sizeof(_JSAMPROW) * height)) == NULL)
97
18.0k
    THROW("Memory allocation failure");
98
99
18.0k
  if (setjmp(this->jerr.setjmp_buffer)) {
100
    /* If we get here, the JPEG code has signaled an error. */
101
117
    retval = -1;  goto bailout;
102
117
  }
103
104
17.9k
  cinfo->image_width = width;
105
17.9k
  cinfo->image_height = height;
106
17.9k
  cinfo->data_precision = BITS_IN_JSAMPLE;
107
108
17.9k
  setCompDefaults(this, pixelFormat);
109
17.9k
  if (this->noRealloc) {
110
15.4k
    alloc = FALSE;
111
15.4k
    *jpegSize = tj3JPEGBufSize(width, height, this->subsamp);
112
15.4k
  }
113
17.9k
  jpeg_mem_dest_tj(cinfo, jpegBuf, jpegSize, alloc);
114
115
17.9k
  jpeg_start_compress(cinfo, TRUE);
116
59.8M
  for (i = 0; i < height; i++) {
117
59.8M
    if (this->bottomUp)
118
8.69M
      row_pointer[i] = (_JSAMPROW)&srcBuf[(height - i - 1) * (size_t)pitch];
119
51.1M
    else
120
51.1M
      row_pointer[i] = (_JSAMPROW)&srcBuf[i * (size_t)pitch];
121
59.8M
  }
122
35.8k
  while (cinfo->next_scanline < cinfo->image_height)
123
17.9k
    _jpeg_write_scanlines(cinfo, &row_pointer[cinfo->next_scanline],
124
17.9k
                          cinfo->image_height - cinfo->next_scanline);
125
17.9k
  jpeg_finish_compress(cinfo);
126
127
18.0k
bailout:
128
18.0k
  if (cinfo->global_state > CSTATE_START && alloc)
129
0
    (*cinfo->dest->term_destination) (cinfo);
130
18.0k
  if (cinfo->global_state > CSTATE_START || retval == -1)
131
117
    jpeg_abort_compress(cinfo);
132
18.0k
  free(row_pointer);
133
18.0k
  if (this->jerr.warning) retval = -1;
134
18.0k
  return retval;
135
17.9k
}
tj3Compress12
Line
Count
Source
74
26.7k
{
75
26.7k
  static const char FUNCTION_NAME[] = GET_STRING(tj3Compress, BITS_IN_JSAMPLE);
76
26.7k
  int i, retval = 0;
77
26.7k
  boolean alloc = TRUE;
78
26.7k
  _JSAMPROW *row_pointer = NULL;
79
80
26.7k
  GET_CINSTANCE(handle)
81
26.7k
  if ((this->init & COMPRESS) == 0)
82
26.7k
    THROW("Instance has not been initialized for compression");
83
84
26.7k
  if (srcBuf == NULL || width <= 0 || pitch < 0 || height <= 0 ||
85
26.7k
      pixelFormat < 0 || pixelFormat >= TJ_NUMPF || jpegBuf == NULL ||
86
26.7k
      jpegSize == NULL)
87
26.7k
    THROW("Invalid argument");
88
89
26.7k
  if (!this->lossless && this->quality == -1)
90
26.7k
    THROW("TJPARAM_QUALITY must be specified");
91
26.7k
  if (!this->lossless && this->subsamp == TJSAMP_UNKNOWN)
92
26.7k
    THROW("TJPARAM_SUBSAMP must be specified");
93
94
26.7k
  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];
95
96
26.7k
  if ((row_pointer = (_JSAMPROW *)malloc(sizeof(_JSAMPROW) * height)) == NULL)
97
26.7k
    THROW("Memory allocation failure");
98
99
26.7k
  if (setjmp(this->jerr.setjmp_buffer)) {
100
    /* If we get here, the JPEG code has signaled an error. */
101
81
    retval = -1;  goto bailout;
102
81
  }
103
104
26.6k
  cinfo->image_width = width;
105
26.6k
  cinfo->image_height = height;
106
26.6k
  cinfo->data_precision = BITS_IN_JSAMPLE;
107
108
26.6k
  setCompDefaults(this, pixelFormat);
109
26.6k
  if (this->noRealloc) {
110
22.8k
    alloc = FALSE;
111
22.8k
    *jpegSize = tj3JPEGBufSize(width, height, this->subsamp);
112
22.8k
  }
113
26.6k
  jpeg_mem_dest_tj(cinfo, jpegBuf, jpegSize, alloc);
114
115
26.6k
  jpeg_start_compress(cinfo, TRUE);
116
96.6M
  for (i = 0; i < height; i++) {
117
96.5M
    if (this->bottomUp)
118
13.8M
      row_pointer[i] = (_JSAMPROW)&srcBuf[(height - i - 1) * (size_t)pitch];
119
82.7M
    else
120
82.7M
      row_pointer[i] = (_JSAMPROW)&srcBuf[i * (size_t)pitch];
121
96.5M
  }
122
53.3k
  while (cinfo->next_scanline < cinfo->image_height)
123
26.6k
    _jpeg_write_scanlines(cinfo, &row_pointer[cinfo->next_scanline],
124
26.6k
                          cinfo->image_height - cinfo->next_scanline);
125
26.6k
  jpeg_finish_compress(cinfo);
126
127
26.7k
bailout:
128
26.7k
  if (cinfo->global_state > CSTATE_START && alloc)
129
0
    (*cinfo->dest->term_destination) (cinfo);
130
26.7k
  if (cinfo->global_state > CSTATE_START || retval == -1)
131
81
    jpeg_abort_compress(cinfo);
132
26.7k
  free(row_pointer);
133
26.7k
  if (this->jerr.warning) retval = -1;
134
26.7k
  return retval;
135
26.6k
}
tj3Compress16
Line
Count
Source
74
4.55k
{
75
4.55k
  static const char FUNCTION_NAME[] = GET_STRING(tj3Compress, BITS_IN_JSAMPLE);
76
4.55k
  int i, retval = 0;
77
4.55k
  boolean alloc = TRUE;
78
4.55k
  _JSAMPROW *row_pointer = NULL;
79
80
4.55k
  GET_CINSTANCE(handle)
81
4.55k
  if ((this->init & COMPRESS) == 0)
82
4.55k
    THROW("Instance has not been initialized for compression");
83
84
4.55k
  if (srcBuf == NULL || width <= 0 || pitch < 0 || height <= 0 ||
85
4.55k
      pixelFormat < 0 || pixelFormat >= TJ_NUMPF || jpegBuf == NULL ||
86
4.55k
      jpegSize == NULL)
87
4.55k
    THROW("Invalid argument");
88
89
4.55k
  if (!this->lossless && this->quality == -1)
90
4.55k
    THROW("TJPARAM_QUALITY must be specified");
91
4.55k
  if (!this->lossless && this->subsamp == TJSAMP_UNKNOWN)
92
4.55k
    THROW("TJPARAM_SUBSAMP must be specified");
93
94
4.55k
  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];
95
96
4.55k
  if ((row_pointer = (_JSAMPROW *)malloc(sizeof(_JSAMPROW) * height)) == NULL)
97
4.55k
    THROW("Memory allocation failure");
98
99
4.55k
  if (setjmp(this->jerr.setjmp_buffer)) {
100
    /* If we get here, the JPEG code has signaled an error. */
101
56
    retval = -1;  goto bailout;
102
56
  }
103
104
4.50k
  cinfo->image_width = width;
105
4.50k
  cinfo->image_height = height;
106
4.50k
  cinfo->data_precision = BITS_IN_JSAMPLE;
107
108
4.50k
  setCompDefaults(this, pixelFormat);
109
4.50k
  if (this->noRealloc) {
110
3.89k
    alloc = FALSE;
111
3.89k
    *jpegSize = tj3JPEGBufSize(width, height, this->subsamp);
112
3.89k
  }
113
4.50k
  jpeg_mem_dest_tj(cinfo, jpegBuf, jpegSize, alloc);
114
115
4.50k
  jpeg_start_compress(cinfo, TRUE);
116
13.5M
  for (i = 0; i < height; i++) {
117
13.5M
    if (this->bottomUp)
118
1.93M
      row_pointer[i] = (_JSAMPROW)&srcBuf[(height - i - 1) * (size_t)pitch];
119
11.6M
    else
120
11.6M
      row_pointer[i] = (_JSAMPROW)&srcBuf[i * (size_t)pitch];
121
13.5M
  }
122
9.03k
  while (cinfo->next_scanline < cinfo->image_height)
123
4.53k
    _jpeg_write_scanlines(cinfo, &row_pointer[cinfo->next_scanline],
124
4.53k
                          cinfo->image_height - cinfo->next_scanline);
125
4.50k
  jpeg_finish_compress(cinfo);
126
127
4.55k
bailout:
128
4.55k
  if (cinfo->global_state > CSTATE_START && alloc)
129
29
    (*cinfo->dest->term_destination) (cinfo);
130
4.55k
  if (cinfo->global_state > CSTATE_START || retval == -1)
131
56
    jpeg_abort_compress(cinfo);
132
4.55k
  free(row_pointer);
133
4.55k
  if (this->jerr.warning) retval = -1;
134
4.55k
  return retval;
135
4.50k
}
136
137
138
/******************************* Decompressor ********************************/
139
140
/* TurboJPEG 3+ */
141
DLLEXPORT int GET_NAME(tj3Decompress, BITS_IN_JSAMPLE)
142
  (tjhandle handle, const unsigned char *jpegBuf, size_t jpegSize,
143
   _JSAMPLE *dstBuf, int pitch, int pixelFormat)
144
16.3k
{
145
16.3k
  static const char FUNCTION_NAME[] =
146
16.3k
    GET_STRING(tj3Decompress, BITS_IN_JSAMPLE);
147
16.3k
  _JSAMPROW *row_pointer = NULL;
148
16.3k
  int croppedHeight, i, retval = 0;
149
#if BITS_IN_JSAMPLE != 16
150
  int scaledWidth;
151
#endif
152
16.3k
  struct my_progress_mgr progress;
153
154
16.3k
  GET_DINSTANCE(handle);
155
16.3k
  if ((this->init & DECOMPRESS) == 0)
156
16.3k
    THROW("Instance has not been initialized for decompression");
157
158
16.3k
  if (jpegBuf == NULL || jpegSize <= 0 || dstBuf == NULL || pitch < 0 ||
159
16.3k
      pixelFormat < 0 || pixelFormat >= TJ_NUMPF)
160
16.3k
    THROW("Invalid argument");
161
162
16.3k
  if (this->scanLimit) {
163
16.3k
    memset(&progress, 0, sizeof(struct my_progress_mgr));
164
16.3k
    progress.pub.progress_monitor = my_progress_monitor;
165
16.3k
    progress.this = this;
166
16.3k
    dinfo->progress = &progress.pub;
167
16.3k
  } else
168
0
    dinfo->progress = NULL;
169
170
16.3k
  dinfo->mem->max_memory_to_use = (long)this->maxMemory * 1048576L;
171
172
16.3k
  if (setjmp(this->jerr.setjmp_buffer)) {
173
    /* If we get here, the JPEG code has signaled an error. */
174
4.30k
    retval = -1;  goto bailout;
175
4.30k
  }
176
177
16.3k
  if (dinfo->global_state <= DSTATE_INHEADER) {
178
16.3k
    jpeg_mem_src_tj(dinfo, jpegBuf, jpegSize);
179
16.3k
    jpeg_read_header(dinfo, TRUE);
180
16.3k
  }
181
12.0k
  setDecompParameters(this);
182
12.0k
  if (this->maxPixels &&
183
12.0k
      (unsigned long long)this->jpegWidth * this->jpegHeight >
184
0
      (unsigned long long)this->maxPixels)
185
12.0k
    THROW("Image is too large");
186
12.0k
  this->dinfo.out_color_space = pf2cs[pixelFormat];
187
#if BITS_IN_JSAMPLE != 16
188
11.1k
  scaledWidth = TJSCALED(dinfo->image_width, this->scalingFactor);
189
#endif
190
12.0k
  dinfo->do_fancy_upsampling = !this->fastUpsample;
191
12.0k
  this->dinfo.dct_method = this->fastDCT ? JDCT_FASTEST : JDCT_ISLOW;
192
193
12.0k
  dinfo->scale_num = this->scalingFactor.num;
194
12.0k
  dinfo->scale_denom = this->scalingFactor.denom;
195
196
12.0k
  jpeg_start_decompress(dinfo);
197
198
#if BITS_IN_JSAMPLE != 16
199
11.1k
  if (this->croppingRegion.x != 0 ||
200
11.1k
      (this->croppingRegion.w != 0 && this->croppingRegion.w != scaledWidth)) {
201
0
    JDIMENSION crop_x = this->croppingRegion.x;
202
0
    JDIMENSION crop_w = this->croppingRegion.w;
203
204
0
    _jpeg_crop_scanline(dinfo, &crop_x, &crop_w);
205
0
    if ((int)crop_x != this->croppingRegion.x)
206
0
      THROWI("Unexplained mismatch between specified (%d) and\n"
207
0
             "actual (%d) cropping region left boundary",
208
0
             this->croppingRegion.x, (int)crop_x);
209
0
    if ((int)crop_w != this->croppingRegion.w)
210
0
      THROWI("Unexplained mismatch between specified (%d) and\n"
211
0
             "actual (%d) cropping region width",
212
0
             this->croppingRegion.w, (int)crop_w);
213
0
  }
214
11.1k
#endif
215
216
12.0k
  if (pitch == 0) pitch = dinfo->output_width * tjPixelSize[pixelFormat];
217
218
11.1k
  croppedHeight = dinfo->output_height;
219
#if BITS_IN_JSAMPLE != 16
220
11.1k
  if (this->croppingRegion.y != 0 || this->croppingRegion.h != 0)
221
0
    croppedHeight = this->croppingRegion.h;
222
#endif
223
12.0k
  if ((row_pointer =
224
12.0k
       (_JSAMPROW *)malloc(sizeof(_JSAMPROW) * croppedHeight)) == NULL)
225
12.0k
    THROW("Memory allocation failure");
226
12.0k
  if (setjmp(this->jerr.setjmp_buffer)) {
227
    /* If we get here, the JPEG code has signaled an error. */
228
2.03k
    retval = -1;  goto bailout;
229
2.03k
  }
230
60.3M
  for (i = 0; i < (int)croppedHeight; i++) {
231
60.3M
    if (this->bottomUp)
232
53.1M
      row_pointer[i] = &dstBuf[(croppedHeight - i - 1) * (size_t)pitch];
233
7.22M
    else
234
7.22M
      row_pointer[i] = &dstBuf[i * (size_t)pitch];
235
60.3M
  }
236
237
#if BITS_IN_JSAMPLE != 16
238
11.1k
  if (this->croppingRegion.y != 0 || this->croppingRegion.h != 0) {
239
0
    if (this->croppingRegion.y != 0) {
240
0
      JDIMENSION lines = _jpeg_skip_scanlines(dinfo, this->croppingRegion.y);
241
242
0
      if ((int)lines != this->croppingRegion.y)
243
0
        THROWI("Unexplained mismatch between specified (%d) and\n"
244
               "actual (%d) cropping region upper boundary",
245
0
               this->croppingRegion.y, (int)lines);
246
0
    }
247
0
    while ((int)dinfo->output_scanline <
248
0
           this->croppingRegion.y + this->croppingRegion.h)
249
0
      _jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline -
250
0
                                               this->croppingRegion.y],
251
0
                           this->croppingRegion.y + this->croppingRegion.h -
252
0
                           dinfo->output_scanline);
253
0
    if (this->croppingRegion.y + this->croppingRegion.h !=
254
0
        (int)dinfo->output_height) {
255
0
      JDIMENSION lines = _jpeg_skip_scanlines(dinfo, dinfo->output_height -
256
                                                     this->croppingRegion.y -
257
                                                     this->croppingRegion.h);
258
259
0
      if (lines != dinfo->output_height - this->croppingRegion.y -
260
0
                   this->croppingRegion.h)
261
0
        THROWI("Unexplained mismatch between specified (%d) and\n"
262
0
               "actual (%d) cropping region lower boundary",
263
0
               this->croppingRegion.y + this->croppingRegion.h,
264
0
               (int)(dinfo->output_height - lines));
265
0
    }
266
0
  } else
267
9.75k
#endif
268
9.75k
  {
269
23.5M
    while (dinfo->output_scanline < dinfo->output_height)
270
23.5M
      _jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline],
271
23.5M
                           dinfo->output_height - dinfo->output_scanline);
272
9.75k
  }
273
9.75k
  jpeg_finish_decompress(dinfo);
274
275
16.3k
bailout:
276
16.3k
  if (dinfo->global_state > DSTATE_START) jpeg_abort_decompress(dinfo);
277
16.3k
  free(row_pointer);
278
16.3k
  if (this->jerr.warning) retval = -1;
279
16.3k
  return retval;
280
9.75k
}
tj3Decompress8
Line
Count
Source
144
7.83k
{
145
7.83k
  static const char FUNCTION_NAME[] =
146
7.83k
    GET_STRING(tj3Decompress, BITS_IN_JSAMPLE);
147
7.83k
  _JSAMPROW *row_pointer = NULL;
148
7.83k
  int croppedHeight, i, retval = 0;
149
7.83k
#if BITS_IN_JSAMPLE != 16
150
7.83k
  int scaledWidth;
151
7.83k
#endif
152
7.83k
  struct my_progress_mgr progress;
153
154
7.83k
  GET_DINSTANCE(handle);
155
7.83k
  if ((this->init & DECOMPRESS) == 0)
156
7.83k
    THROW("Instance has not been initialized for decompression");
157
158
7.83k
  if (jpegBuf == NULL || jpegSize <= 0 || dstBuf == NULL || pitch < 0 ||
159
7.83k
      pixelFormat < 0 || pixelFormat >= TJ_NUMPF)
160
7.83k
    THROW("Invalid argument");
161
162
7.83k
  if (this->scanLimit) {
163
7.83k
    memset(&progress, 0, sizeof(struct my_progress_mgr));
164
7.83k
    progress.pub.progress_monitor = my_progress_monitor;
165
7.83k
    progress.this = this;
166
7.83k
    dinfo->progress = &progress.pub;
167
7.83k
  } else
168
0
    dinfo->progress = NULL;
169
170
7.83k
  dinfo->mem->max_memory_to_use = (long)this->maxMemory * 1048576L;
171
172
7.83k
  if (setjmp(this->jerr.setjmp_buffer)) {
173
    /* If we get here, the JPEG code has signaled an error. */
174
2.25k
    retval = -1;  goto bailout;
175
2.25k
  }
176
177
7.83k
  if (dinfo->global_state <= DSTATE_INHEADER) {
178
7.83k
    jpeg_mem_src_tj(dinfo, jpegBuf, jpegSize);
179
7.83k
    jpeg_read_header(dinfo, TRUE);
180
7.83k
  }
181
5.58k
  setDecompParameters(this);
182
5.58k
  if (this->maxPixels &&
183
5.58k
      (unsigned long long)this->jpegWidth * this->jpegHeight >
184
0
      (unsigned long long)this->maxPixels)
185
5.58k
    THROW("Image is too large");
186
5.58k
  this->dinfo.out_color_space = pf2cs[pixelFormat];
187
5.58k
#if BITS_IN_JSAMPLE != 16
188
5.58k
  scaledWidth = TJSCALED(dinfo->image_width, this->scalingFactor);
189
5.58k
#endif
190
5.58k
  dinfo->do_fancy_upsampling = !this->fastUpsample;
191
5.58k
  this->dinfo.dct_method = this->fastDCT ? JDCT_FASTEST : JDCT_ISLOW;
192
193
5.58k
  dinfo->scale_num = this->scalingFactor.num;
194
5.58k
  dinfo->scale_denom = this->scalingFactor.denom;
195
196
5.58k
  jpeg_start_decompress(dinfo);
197
198
5.58k
#if BITS_IN_JSAMPLE != 16
199
5.58k
  if (this->croppingRegion.x != 0 ||
200
5.58k
      (this->croppingRegion.w != 0 && this->croppingRegion.w != scaledWidth)) {
201
0
    JDIMENSION crop_x = this->croppingRegion.x;
202
0
    JDIMENSION crop_w = this->croppingRegion.w;
203
204
0
    _jpeg_crop_scanline(dinfo, &crop_x, &crop_w);
205
0
    if ((int)crop_x != this->croppingRegion.x)
206
0
      THROWI("Unexplained mismatch between specified (%d) and\n"
207
0
             "actual (%d) cropping region left boundary",
208
0
             this->croppingRegion.x, (int)crop_x);
209
0
    if ((int)crop_w != this->croppingRegion.w)
210
0
      THROWI("Unexplained mismatch between specified (%d) and\n"
211
0
             "actual (%d) cropping region width",
212
0
             this->croppingRegion.w, (int)crop_w);
213
0
  }
214
5.58k
#endif
215
216
5.58k
  if (pitch == 0) pitch = dinfo->output_width * tjPixelSize[pixelFormat];
217
218
5.58k
  croppedHeight = dinfo->output_height;
219
5.58k
#if BITS_IN_JSAMPLE != 16
220
5.58k
  if (this->croppingRegion.y != 0 || this->croppingRegion.h != 0)
221
0
    croppedHeight = this->croppingRegion.h;
222
5.58k
#endif
223
5.58k
  if ((row_pointer =
224
5.58k
       (_JSAMPROW *)malloc(sizeof(_JSAMPROW) * croppedHeight)) == NULL)
225
5.58k
    THROW("Memory allocation failure");
226
5.58k
  if (setjmp(this->jerr.setjmp_buffer)) {
227
    /* If we get here, the JPEG code has signaled an error. */
228
863
    retval = -1;  goto bailout;
229
863
  }
230
29.5M
  for (i = 0; i < (int)croppedHeight; i++) {
231
29.5M
    if (this->bottomUp)
232
27.0M
      row_pointer[i] = &dstBuf[(croppedHeight - i - 1) * (size_t)pitch];
233
2.46M
    else
234
2.46M
      row_pointer[i] = &dstBuf[i * (size_t)pitch];
235
29.5M
  }
236
237
4.72k
#if BITS_IN_JSAMPLE != 16
238
5.58k
  if (this->croppingRegion.y != 0 || this->croppingRegion.h != 0) {
239
0
    if (this->croppingRegion.y != 0) {
240
0
      JDIMENSION lines = _jpeg_skip_scanlines(dinfo, this->croppingRegion.y);
241
242
0
      if ((int)lines != this->croppingRegion.y)
243
0
        THROWI("Unexplained mismatch between specified (%d) and\n"
244
0
               "actual (%d) cropping region upper boundary",
245
0
               this->croppingRegion.y, (int)lines);
246
0
    }
247
0
    while ((int)dinfo->output_scanline <
248
0
           this->croppingRegion.y + this->croppingRegion.h)
249
0
      _jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline -
250
0
                                               this->croppingRegion.y],
251
0
                           this->croppingRegion.y + this->croppingRegion.h -
252
0
                           dinfo->output_scanline);
253
0
    if (this->croppingRegion.y + this->croppingRegion.h !=
254
0
        (int)dinfo->output_height) {
255
0
      JDIMENSION lines = _jpeg_skip_scanlines(dinfo, dinfo->output_height -
256
0
                                                     this->croppingRegion.y -
257
0
                                                     this->croppingRegion.h);
258
259
0
      if (lines != dinfo->output_height - this->croppingRegion.y -
260
0
                   this->croppingRegion.h)
261
0
        THROWI("Unexplained mismatch between specified (%d) and\n"
262
0
               "actual (%d) cropping region lower boundary",
263
0
               this->croppingRegion.y + this->croppingRegion.h,
264
0
               (int)(dinfo->output_height - lines));
265
0
    }
266
0
  } else
267
4.72k
#endif
268
4.72k
  {
269
13.3M
    while (dinfo->output_scanline < dinfo->output_height)
270
13.3M
      _jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline],
271
13.3M
                           dinfo->output_height - dinfo->output_scanline);
272
4.72k
  }
273
4.72k
  jpeg_finish_decompress(dinfo);
274
275
7.83k
bailout:
276
7.83k
  if (dinfo->global_state > DSTATE_START) jpeg_abort_decompress(dinfo);
277
7.83k
  free(row_pointer);
278
7.83k
  if (this->jerr.warning) retval = -1;
279
7.83k
  return retval;
280
4.72k
}
tj3Decompress12
Line
Count
Source
144
7.18k
{
145
7.18k
  static const char FUNCTION_NAME[] =
146
7.18k
    GET_STRING(tj3Decompress, BITS_IN_JSAMPLE);
147
7.18k
  _JSAMPROW *row_pointer = NULL;
148
7.18k
  int croppedHeight, i, retval = 0;
149
7.18k
#if BITS_IN_JSAMPLE != 16
150
7.18k
  int scaledWidth;
151
7.18k
#endif
152
7.18k
  struct my_progress_mgr progress;
153
154
7.18k
  GET_DINSTANCE(handle);
155
7.18k
  if ((this->init & DECOMPRESS) == 0)
156
7.18k
    THROW("Instance has not been initialized for decompression");
157
158
7.18k
  if (jpegBuf == NULL || jpegSize <= 0 || dstBuf == NULL || pitch < 0 ||
159
7.18k
      pixelFormat < 0 || pixelFormat >= TJ_NUMPF)
160
7.18k
    THROW("Invalid argument");
161
162
7.18k
  if (this->scanLimit) {
163
7.18k
    memset(&progress, 0, sizeof(struct my_progress_mgr));
164
7.18k
    progress.pub.progress_monitor = my_progress_monitor;
165
7.18k
    progress.this = this;
166
7.18k
    dinfo->progress = &progress.pub;
167
7.18k
  } else
168
0
    dinfo->progress = NULL;
169
170
7.18k
  dinfo->mem->max_memory_to_use = (long)this->maxMemory * 1048576L;
171
172
7.18k
  if (setjmp(this->jerr.setjmp_buffer)) {
173
    /* If we get here, the JPEG code has signaled an error. */
174
1.64k
    retval = -1;  goto bailout;
175
1.64k
  }
176
177
7.18k
  if (dinfo->global_state <= DSTATE_INHEADER) {
178
7.18k
    jpeg_mem_src_tj(dinfo, jpegBuf, jpegSize);
179
7.18k
    jpeg_read_header(dinfo, TRUE);
180
7.18k
  }
181
5.53k
  setDecompParameters(this);
182
5.53k
  if (this->maxPixels &&
183
5.53k
      (unsigned long long)this->jpegWidth * this->jpegHeight >
184
0
      (unsigned long long)this->maxPixels)
185
5.53k
    THROW("Image is too large");
186
5.53k
  this->dinfo.out_color_space = pf2cs[pixelFormat];
187
5.53k
#if BITS_IN_JSAMPLE != 16
188
5.53k
  scaledWidth = TJSCALED(dinfo->image_width, this->scalingFactor);
189
5.53k
#endif
190
5.53k
  dinfo->do_fancy_upsampling = !this->fastUpsample;
191
5.53k
  this->dinfo.dct_method = this->fastDCT ? JDCT_FASTEST : JDCT_ISLOW;
192
193
5.53k
  dinfo->scale_num = this->scalingFactor.num;
194
5.53k
  dinfo->scale_denom = this->scalingFactor.denom;
195
196
5.53k
  jpeg_start_decompress(dinfo);
197
198
5.53k
#if BITS_IN_JSAMPLE != 16
199
5.53k
  if (this->croppingRegion.x != 0 ||
200
5.53k
      (this->croppingRegion.w != 0 && this->croppingRegion.w != scaledWidth)) {
201
0
    JDIMENSION crop_x = this->croppingRegion.x;
202
0
    JDIMENSION crop_w = this->croppingRegion.w;
203
204
0
    _jpeg_crop_scanline(dinfo, &crop_x, &crop_w);
205
0
    if ((int)crop_x != this->croppingRegion.x)
206
0
      THROWI("Unexplained mismatch between specified (%d) and\n"
207
0
             "actual (%d) cropping region left boundary",
208
0
             this->croppingRegion.x, (int)crop_x);
209
0
    if ((int)crop_w != this->croppingRegion.w)
210
0
      THROWI("Unexplained mismatch between specified (%d) and\n"
211
0
             "actual (%d) cropping region width",
212
0
             this->croppingRegion.w, (int)crop_w);
213
0
  }
214
5.53k
#endif
215
216
5.53k
  if (pitch == 0) pitch = dinfo->output_width * tjPixelSize[pixelFormat];
217
218
5.53k
  croppedHeight = dinfo->output_height;
219
5.53k
#if BITS_IN_JSAMPLE != 16
220
5.53k
  if (this->croppingRegion.y != 0 || this->croppingRegion.h != 0)
221
0
    croppedHeight = this->croppingRegion.h;
222
5.53k
#endif
223
5.53k
  if ((row_pointer =
224
5.53k
       (_JSAMPROW *)malloc(sizeof(_JSAMPROW) * croppedHeight)) == NULL)
225
5.53k
    THROW("Memory allocation failure");
226
5.53k
  if (setjmp(this->jerr.setjmp_buffer)) {
227
    /* If we get here, the JPEG code has signaled an error. */
228
499
    retval = -1;  goto bailout;
229
499
  }
230
23.8M
  for (i = 0; i < (int)croppedHeight; i++) {
231
23.8M
    if (this->bottomUp)
232
19.1M
      row_pointer[i] = &dstBuf[(croppedHeight - i - 1) * (size_t)pitch];
233
4.76M
    else
234
4.76M
      row_pointer[i] = &dstBuf[i * (size_t)pitch];
235
23.8M
  }
236
237
5.03k
#if BITS_IN_JSAMPLE != 16
238
5.53k
  if (this->croppingRegion.y != 0 || this->croppingRegion.h != 0) {
239
0
    if (this->croppingRegion.y != 0) {
240
0
      JDIMENSION lines = _jpeg_skip_scanlines(dinfo, this->croppingRegion.y);
241
242
0
      if ((int)lines != this->croppingRegion.y)
243
0
        THROWI("Unexplained mismatch between specified (%d) and\n"
244
0
               "actual (%d) cropping region upper boundary",
245
0
               this->croppingRegion.y, (int)lines);
246
0
    }
247
0
    while ((int)dinfo->output_scanline <
248
0
           this->croppingRegion.y + this->croppingRegion.h)
249
0
      _jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline -
250
0
                                               this->croppingRegion.y],
251
0
                           this->croppingRegion.y + this->croppingRegion.h -
252
0
                           dinfo->output_scanline);
253
0
    if (this->croppingRegion.y + this->croppingRegion.h !=
254
0
        (int)dinfo->output_height) {
255
0
      JDIMENSION lines = _jpeg_skip_scanlines(dinfo, dinfo->output_height -
256
0
                                                     this->croppingRegion.y -
257
0
                                                     this->croppingRegion.h);
258
259
0
      if (lines != dinfo->output_height - this->croppingRegion.y -
260
0
                   this->croppingRegion.h)
261
0
        THROWI("Unexplained mismatch between specified (%d) and\n"
262
0
               "actual (%d) cropping region lower boundary",
263
0
               this->croppingRegion.y + this->croppingRegion.h,
264
0
               (int)(dinfo->output_height - lines));
265
0
    }
266
0
  } else
267
5.03k
#endif
268
5.03k
  {
269
9.75M
    while (dinfo->output_scanline < dinfo->output_height)
270
9.75M
      _jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline],
271
9.75M
                           dinfo->output_height - dinfo->output_scanline);
272
5.03k
  }
273
5.03k
  jpeg_finish_decompress(dinfo);
274
275
7.18k
bailout:
276
7.18k
  if (dinfo->global_state > DSTATE_START) jpeg_abort_decompress(dinfo);
277
7.18k
  free(row_pointer);
278
7.18k
  if (this->jerr.warning) retval = -1;
279
7.18k
  return retval;
280
5.03k
}
tj3Decompress16
Line
Count
Source
144
1.33k
{
145
1.33k
  static const char FUNCTION_NAME[] =
146
1.33k
    GET_STRING(tj3Decompress, BITS_IN_JSAMPLE);
147
1.33k
  _JSAMPROW *row_pointer = NULL;
148
1.33k
  int croppedHeight, i, retval = 0;
149
#if BITS_IN_JSAMPLE != 16
150
  int scaledWidth;
151
#endif
152
1.33k
  struct my_progress_mgr progress;
153
154
1.33k
  GET_DINSTANCE(handle);
155
1.33k
  if ((this->init & DECOMPRESS) == 0)
156
1.33k
    THROW("Instance has not been initialized for decompression");
157
158
1.33k
  if (jpegBuf == NULL || jpegSize <= 0 || dstBuf == NULL || pitch < 0 ||
159
1.33k
      pixelFormat < 0 || pixelFormat >= TJ_NUMPF)
160
1.33k
    THROW("Invalid argument");
161
162
1.33k
  if (this->scanLimit) {
163
1.33k
    memset(&progress, 0, sizeof(struct my_progress_mgr));
164
1.33k
    progress.pub.progress_monitor = my_progress_monitor;
165
1.33k
    progress.this = this;
166
1.33k
    dinfo->progress = &progress.pub;
167
1.33k
  } else
168
0
    dinfo->progress = NULL;
169
170
1.33k
  dinfo->mem->max_memory_to_use = (long)this->maxMemory * 1048576L;
171
172
1.33k
  if (setjmp(this->jerr.setjmp_buffer)) {
173
    /* If we get here, the JPEG code has signaled an error. */
174
406
    retval = -1;  goto bailout;
175
406
  }
176
177
1.33k
  if (dinfo->global_state <= DSTATE_INHEADER) {
178
1.33k
    jpeg_mem_src_tj(dinfo, jpegBuf, jpegSize);
179
1.33k
    jpeg_read_header(dinfo, TRUE);
180
1.33k
  }
181
931
  setDecompParameters(this);
182
931
  if (this->maxPixels &&
183
931
      (unsigned long long)this->jpegWidth * this->jpegHeight >
184
0
      (unsigned long long)this->maxPixels)
185
931
    THROW("Image is too large");
186
931
  this->dinfo.out_color_space = pf2cs[pixelFormat];
187
#if BITS_IN_JSAMPLE != 16
188
  scaledWidth = TJSCALED(dinfo->image_width, this->scalingFactor);
189
#endif
190
931
  dinfo->do_fancy_upsampling = !this->fastUpsample;
191
931
  this->dinfo.dct_method = this->fastDCT ? JDCT_FASTEST : JDCT_ISLOW;
192
193
931
  dinfo->scale_num = this->scalingFactor.num;
194
931
  dinfo->scale_denom = this->scalingFactor.denom;
195
196
931
  jpeg_start_decompress(dinfo);
197
198
#if BITS_IN_JSAMPLE != 16
199
  if (this->croppingRegion.x != 0 ||
200
      (this->croppingRegion.w != 0 && this->croppingRegion.w != scaledWidth)) {
201
    JDIMENSION crop_x = this->croppingRegion.x;
202
    JDIMENSION crop_w = this->croppingRegion.w;
203
204
    _jpeg_crop_scanline(dinfo, &crop_x, &crop_w);
205
    if ((int)crop_x != this->croppingRegion.x)
206
      THROWI("Unexplained mismatch between specified (%d) and\n"
207
             "actual (%d) cropping region left boundary",
208
             this->croppingRegion.x, (int)crop_x);
209
    if ((int)crop_w != this->croppingRegion.w)
210
      THROWI("Unexplained mismatch between specified (%d) and\n"
211
             "actual (%d) cropping region width",
212
             this->croppingRegion.w, (int)crop_w);
213
  }
214
#endif
215
216
931
  if (pitch == 0) pitch = dinfo->output_width * tjPixelSize[pixelFormat];
217
218
931
  croppedHeight = dinfo->output_height;
219
#if BITS_IN_JSAMPLE != 16
220
  if (this->croppingRegion.y != 0 || this->croppingRegion.h != 0)
221
    croppedHeight = this->croppingRegion.h;
222
#endif
223
931
  if ((row_pointer =
224
931
       (_JSAMPROW *)malloc(sizeof(_JSAMPROW) * croppedHeight)) == NULL)
225
931
    THROW("Memory allocation failure");
226
931
  if (setjmp(this->jerr.setjmp_buffer)) {
227
    /* If we get here, the JPEG code has signaled an error. */
228
669
    retval = -1;  goto bailout;
229
669
  }
230
6.99M
  for (i = 0; i < (int)croppedHeight; i++) {
231
6.99M
    if (this->bottomUp)
232
6.99M
      row_pointer[i] = &dstBuf[(croppedHeight - i - 1) * (size_t)pitch];
233
824
    else
234
824
      row_pointer[i] = &dstBuf[i * (size_t)pitch];
235
6.99M
  }
236
237
#if BITS_IN_JSAMPLE != 16
238
  if (this->croppingRegion.y != 0 || this->croppingRegion.h != 0) {
239
    if (this->croppingRegion.y != 0) {
240
      JDIMENSION lines = _jpeg_skip_scanlines(dinfo, this->croppingRegion.y);
241
242
      if ((int)lines != this->croppingRegion.y)
243
        THROWI("Unexplained mismatch between specified (%d) and\n"
244
               "actual (%d) cropping region upper boundary",
245
               this->croppingRegion.y, (int)lines);
246
    }
247
    while ((int)dinfo->output_scanline <
248
           this->croppingRegion.y + this->croppingRegion.h)
249
      _jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline -
250
                                               this->croppingRegion.y],
251
                           this->croppingRegion.y + this->croppingRegion.h -
252
                           dinfo->output_scanline);
253
    if (this->croppingRegion.y + this->croppingRegion.h !=
254
        (int)dinfo->output_height) {
255
      JDIMENSION lines = _jpeg_skip_scanlines(dinfo, dinfo->output_height -
256
                                                     this->croppingRegion.y -
257
                                                     this->croppingRegion.h);
258
259
      if (lines != dinfo->output_height - this->croppingRegion.y -
260
                   this->croppingRegion.h)
261
        THROWI("Unexplained mismatch between specified (%d) and\n"
262
               "actual (%d) cropping region lower boundary",
263
               this->croppingRegion.y + this->croppingRegion.h,
264
               (int)(dinfo->output_height - lines));
265
    }
266
  } else
267
#endif
268
262
  {
269
497k
    while (dinfo->output_scanline < dinfo->output_height)
270
497k
      _jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline],
271
497k
                           dinfo->output_height - dinfo->output_scanline);
272
262
  }
273
262
  jpeg_finish_decompress(dinfo);
274
275
1.33k
bailout:
276
1.33k
  if (dinfo->global_state > DSTATE_START) jpeg_abort_decompress(dinfo);
277
1.33k
  free(row_pointer);
278
1.33k
  if (this->jerr.warning) retval = -1;
279
1.33k
  return retval;
280
262
}
281
282
283
/*************************** Packed-Pixel Image I/O **************************/
284
285
/* TurboJPEG 3+ */
286
DLLEXPORT _JSAMPLE *GET_NAME(tj3LoadImage, BITS_IN_JSAMPLE)
287
  (tjhandle handle, const char *filename, int *width, int align, int *height,
288
   int *pixelFormat)
289
117k
{
290
117k
  static const char FUNCTION_NAME[] =
291
117k
    GET_STRING(tj3LoadImage, BITS_IN_JSAMPLE);
292
293
117k
#if BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED)
294
295
117k
  int retval = 0, tempc;
296
117k
  size_t pitch;
297
117k
  tjhandle handle2 = NULL;
298
117k
  tjinstance *this2;
299
117k
  j_compress_ptr cinfo = NULL;
300
117k
  cjpeg_source_ptr src;
301
117k
  _JSAMPLE *dstBuf = NULL;
302
117k
  FILE *file = NULL;
303
117k
  boolean invert;
304
305
117k
  GET_TJINSTANCE(handle, NULL)
306
307
117k
  if (!filename || !width || align < 1 || !height || !pixelFormat ||
308
117k
      *pixelFormat < TJPF_UNKNOWN || *pixelFormat >= TJ_NUMPF)
309
117k
    THROW("Invalid argument");
310
117k
  if ((align & (align - 1)) != 0)
311
117k
    THROW("Alignment must be a power of 2");
312
313
  /* The instance handle passed to this function is used only for parameter
314
     retrieval.  Create a new temporary instance to avoid interfering with the
315
     libjpeg state of the primary instance. */
316
117k
  if ((handle2 = tj3Init(TJINIT_COMPRESS)) == NULL) return NULL;
317
117k
  this2 = (tjinstance *)handle2;
318
117k
  cinfo = &this2->cinfo;
319
320
#ifdef _MSC_VER
321
  if (fopen_s(&file, filename, "rb") || file == NULL)
322
#else
323
117k
  if ((file = fopen(filename, "rb")) == NULL)
324
0
#endif
325
117k
    THROW_UNIX("Cannot open input file");
326
327
117k
  if ((tempc = getc(file)) < 0 || ungetc(tempc, file) == EOF)
328
0
    THROW_UNIX("Could not read input file")
329
117k
  else if (tempc == EOF)
330
117k
    THROW("Input file contains no data");
331
332
117k
  if (setjmp(this2->jerr.setjmp_buffer)) {
333
    /* If we get here, the JPEG code has signaled an error. */
334
24.3k
    retval = -1;  goto bailout;
335
24.3k
  }
336
337
92.9k
  cinfo->data_precision = BITS_IN_JSAMPLE;
338
92.9k
  if (*pixelFormat == TJPF_UNKNOWN) cinfo->in_color_space = JCS_UNKNOWN;
339
92.9k
  else cinfo->in_color_space = pf2cs[*pixelFormat];
340
92.9k
  if (tempc == 'B') {
341
18.0k
    if ((src = jinit_read_bmp(cinfo, FALSE)) == NULL)
342
18.0k
      THROW("Could not initialize bitmap loader");
343
18.0k
    invert = !this->bottomUp;
344
98.4k
  } else if (tempc == 'P') {
345
98.4k
    if ((src = _jinit_read_ppm(cinfo)) == NULL)
346
98.4k
      THROW("Could not initialize PPM loader");
347
98.4k
    invert = this->bottomUp;
348
98.4k
  } else
349
18.4E
    THROW("Unsupported file type");
350
351
116k
  cinfo->mem->max_memory_to_use = (long)this->maxMemory * 1048576L;
352
353
116k
  src->input_file = file;
354
  /* Refuse to load images larger than the specified size. */
355
116k
  src->max_pixels = this->maxPixels;
356
116k
  (*src->start_input) (cinfo, src);
357
116k
  if (tempc == 'B') {
358
5.92k
    if (cinfo->X_density && cinfo->Y_density) {
359
1.44k
      this->xDensity = cinfo->X_density;
360
1.44k
      this->yDensity = cinfo->Y_density;
361
1.44k
      this->densityUnits = cinfo->density_unit;
362
1.44k
    }
363
5.92k
  }
364
116k
  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
365
366
116k
  *width = cinfo->image_width;  *height = cinfo->image_height;
367
116k
  *pixelFormat = cs2pf[cinfo->in_color_space];
368
369
116k
  pitch = PAD((*width) * tjPixelSize[*pixelFormat], align);
370
116k
  if (
371
#if ULLONG_MAX > SIZE_MAX
372
      (unsigned long long)pitch * (unsigned long long)(*height) >
373
      (unsigned long long)((size_t)-1) ||
374
#endif
375
116k
      (dstBuf = (_JSAMPLE *)malloc(pitch * (*height) *
376
116k
                                   sizeof(_JSAMPLE))) == NULL)
377
116k
    THROW("Memory allocation failure");
378
379
116k
  if (setjmp(this2->jerr.setjmp_buffer)) {
380
    /* If we get here, the JPEG code has signaled an error. */
381
31.5k
    retval = -1;  goto bailout;
382
31.5k
  }
383
384
210M
  while (cinfo->next_scanline < cinfo->image_height) {
385
210M
    int i, nlines = (*src->get_pixel_rows) (cinfo, src);
386
387
421M
    for (i = 0; i < nlines; i++) {
388
210M
      _JSAMPLE *dstptr;
389
210M
      int row;
390
391
210M
      row = cinfo->next_scanline + i;
392
210M
      if (invert) dstptr = &dstBuf[((*height) - row - 1) * pitch];
393
174M
      else dstptr = &dstBuf[row * pitch];
394
210M
      memcpy(dstptr, src->_buffer[i],
395
210M
             (*width) * tjPixelSize[*pixelFormat] * sizeof(_JSAMPLE));
396
210M
    }
397
210M
    cinfo->next_scanline += nlines;
398
210M
  }
399
400
84.9k
  (*src->finish_input) (cinfo, src);
401
402
117k
bailout:
403
117k
  tj3Destroy(handle2);
404
117k
  if (file) fclose(file);
405
117k
  if (retval < 0) { free(dstBuf);  dstBuf = NULL; }
406
117k
  return dstBuf;
407
408
#else /* BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED) */
409
410
  static const char ERROR_MSG[] =
411
    "16-bit data precision requires lossless JPEG,\n"
412
    "which was disabled at build time.";
413
  _JSAMPLE *retval = NULL;
414
415
  GET_TJINSTANCE(handle, NULL)
416
  SNPRINTF(this->errStr, JMSG_LENGTH_MAX, "%s(): %s", FUNCTION_NAME,
417
           ERROR_MSG);
418
  this->isInstanceError = TRUE;  THROWG(ERROR_MSG, NULL)
419
420
bailout:
421
  return retval;
422
423
#endif
424
84.9k
}
tj3LoadImage8
Line
Count
Source
289
65.9k
{
290
65.9k
  static const char FUNCTION_NAME[] =
291
65.9k
    GET_STRING(tj3LoadImage, BITS_IN_JSAMPLE);
292
293
65.9k
#if BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED)
294
295
65.9k
  int retval = 0, tempc;
296
65.9k
  size_t pitch;
297
65.9k
  tjhandle handle2 = NULL;
298
65.9k
  tjinstance *this2;
299
65.9k
  j_compress_ptr cinfo = NULL;
300
65.9k
  cjpeg_source_ptr src;
301
65.9k
  _JSAMPLE *dstBuf = NULL;
302
65.9k
  FILE *file = NULL;
303
65.9k
  boolean invert;
304
305
65.9k
  GET_TJINSTANCE(handle, NULL)
306
307
65.9k
  if (!filename || !width || align < 1 || !height || !pixelFormat ||
308
65.9k
      *pixelFormat < TJPF_UNKNOWN || *pixelFormat >= TJ_NUMPF)
309
65.9k
    THROW("Invalid argument");
310
65.9k
  if ((align & (align - 1)) != 0)
311
65.9k
    THROW("Alignment must be a power of 2");
312
313
  /* The instance handle passed to this function is used only for parameter
314
     retrieval.  Create a new temporary instance to avoid interfering with the
315
     libjpeg state of the primary instance. */
316
65.9k
  if ((handle2 = tj3Init(TJINIT_COMPRESS)) == NULL) return NULL;
317
65.9k
  this2 = (tjinstance *)handle2;
318
65.9k
  cinfo = &this2->cinfo;
319
320
#ifdef _MSC_VER
321
  if (fopen_s(&file, filename, "rb") || file == NULL)
322
#else
323
65.9k
  if ((file = fopen(filename, "rb")) == NULL)
324
0
#endif
325
65.9k
    THROW_UNIX("Cannot open input file");
326
327
65.9k
  if ((tempc = getc(file)) < 0 || ungetc(tempc, file) == EOF)
328
0
    THROW_UNIX("Could not read input file")
329
65.9k
  else if (tempc == EOF)
330
65.9k
    THROW("Input file contains no data");
331
332
65.9k
  if (setjmp(this2->jerr.setjmp_buffer)) {
333
    /* If we get here, the JPEG code has signaled an error. */
334
18.0k
    retval = -1;  goto bailout;
335
18.0k
  }
336
337
47.8k
  cinfo->data_precision = BITS_IN_JSAMPLE;
338
47.8k
  if (*pixelFormat == TJPF_UNKNOWN) cinfo->in_color_space = JCS_UNKNOWN;
339
47.8k
  else cinfo->in_color_space = pf2cs[*pixelFormat];
340
47.8k
  if (tempc == 'B') {
341
18.0k
    if ((src = jinit_read_bmp(cinfo, FALSE)) == NULL)
342
18.0k
      THROW("Could not initialize bitmap loader");
343
18.0k
    invert = !this->bottomUp;
344
47.5k
  } else if (tempc == 'P') {
345
47.5k
    if ((src = _jinit_read_ppm(cinfo)) == NULL)
346
47.5k
      THROW("Could not initialize PPM loader");
347
47.5k
    invert = this->bottomUp;
348
47.5k
  } else
349
18.4E
    THROW("Unsupported file type");
350
351
65.5k
  cinfo->mem->max_memory_to_use = (long)this->maxMemory * 1048576L;
352
353
65.5k
  src->input_file = file;
354
  /* Refuse to load images larger than the specified size. */
355
65.5k
  src->max_pixels = this->maxPixels;
356
65.5k
  (*src->start_input) (cinfo, src);
357
65.5k
  if (tempc == 'B') {
358
5.92k
    if (cinfo->X_density && cinfo->Y_density) {
359
1.44k
      this->xDensity = cinfo->X_density;
360
1.44k
      this->yDensity = cinfo->Y_density;
361
1.44k
      this->densityUnits = cinfo->density_unit;
362
1.44k
    }
363
5.92k
  }
364
65.5k
  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
365
366
65.5k
  *width = cinfo->image_width;  *height = cinfo->image_height;
367
65.5k
  *pixelFormat = cs2pf[cinfo->in_color_space];
368
369
65.5k
  pitch = PAD((*width) * tjPixelSize[*pixelFormat], align);
370
65.5k
  if (
371
#if ULLONG_MAX > SIZE_MAX
372
      (unsigned long long)pitch * (unsigned long long)(*height) >
373
      (unsigned long long)((size_t)-1) ||
374
#endif
375
65.5k
      (dstBuf = (_JSAMPLE *)malloc(pitch * (*height) *
376
65.5k
                                   sizeof(_JSAMPLE))) == NULL)
377
65.5k
    THROW("Memory allocation failure");
378
379
65.5k
  if (setjmp(this2->jerr.setjmp_buffer)) {
380
    /* If we get here, the JPEG code has signaled an error. */
381
18.2k
    retval = -1;  goto bailout;
382
18.2k
  }
383
384
97.6M
  while (cinfo->next_scanline < cinfo->image_height) {
385
97.6M
    int i, nlines = (*src->get_pixel_rows) (cinfo, src);
386
387
195M
    for (i = 0; i < nlines; i++) {
388
97.6M
      _JSAMPLE *dstptr;
389
97.6M
      int row;
390
391
97.6M
      row = cinfo->next_scanline + i;
392
97.6M
      if (invert) dstptr = &dstBuf[((*height) - row - 1) * pitch];
393
77.8M
      else dstptr = &dstBuf[row * pitch];
394
97.6M
      memcpy(dstptr, src->_buffer[i],
395
97.6M
             (*width) * tjPixelSize[*pixelFormat] * sizeof(_JSAMPLE));
396
97.6M
    }
397
97.6M
    cinfo->next_scanline += nlines;
398
97.6M
  }
399
400
47.3k
  (*src->finish_input) (cinfo, src);
401
402
65.9k
bailout:
403
65.9k
  tj3Destroy(handle2);
404
65.9k
  if (file) fclose(file);
405
65.9k
  if (retval < 0) { free(dstBuf);  dstBuf = NULL; }
406
65.9k
  return dstBuf;
407
408
#else /* BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED) */
409
410
  static const char ERROR_MSG[] =
411
    "16-bit data precision requires lossless JPEG,\n"
412
    "which was disabled at build time.";
413
  _JSAMPLE *retval = NULL;
414
415
  GET_TJINSTANCE(handle, NULL)
416
  SNPRINTF(this->errStr, JMSG_LENGTH_MAX, "%s(): %s", FUNCTION_NAME,
417
           ERROR_MSG);
418
  this->isInstanceError = TRUE;  THROWG(ERROR_MSG, NULL)
419
420
bailout:
421
  return retval;
422
423
#endif
424
47.3k
}
tj3LoadImage12
Line
Count
Source
289
40.1k
{
290
40.1k
  static const char FUNCTION_NAME[] =
291
40.1k
    GET_STRING(tj3LoadImage, BITS_IN_JSAMPLE);
292
293
40.1k
#if BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED)
294
295
40.1k
  int retval = 0, tempc;
296
40.1k
  size_t pitch;
297
40.1k
  tjhandle handle2 = NULL;
298
40.1k
  tjinstance *this2;
299
40.1k
  j_compress_ptr cinfo = NULL;
300
40.1k
  cjpeg_source_ptr src;
301
40.1k
  _JSAMPLE *dstBuf = NULL;
302
40.1k
  FILE *file = NULL;
303
40.1k
  boolean invert;
304
305
40.1k
  GET_TJINSTANCE(handle, NULL)
306
307
40.1k
  if (!filename || !width || align < 1 || !height || !pixelFormat ||
308
40.1k
      *pixelFormat < TJPF_UNKNOWN || *pixelFormat >= TJ_NUMPF)
309
40.1k
    THROW("Invalid argument");
310
40.1k
  if ((align & (align - 1)) != 0)
311
40.1k
    THROW("Alignment must be a power of 2");
312
313
  /* The instance handle passed to this function is used only for parameter
314
     retrieval.  Create a new temporary instance to avoid interfering with the
315
     libjpeg state of the primary instance. */
316
40.1k
  if ((handle2 = tj3Init(TJINIT_COMPRESS)) == NULL) return NULL;
317
40.1k
  this2 = (tjinstance *)handle2;
318
40.1k
  cinfo = &this2->cinfo;
319
320
#ifdef _MSC_VER
321
  if (fopen_s(&file, filename, "rb") || file == NULL)
322
#else
323
40.1k
  if ((file = fopen(filename, "rb")) == NULL)
324
0
#endif
325
40.1k
    THROW_UNIX("Cannot open input file");
326
327
40.1k
  if ((tempc = getc(file)) < 0 || ungetc(tempc, file) == EOF)
328
0
    THROW_UNIX("Could not read input file")
329
40.1k
  else if (tempc == EOF)
330
40.1k
    THROW("Input file contains no data");
331
332
40.1k
  if (setjmp(this2->jerr.setjmp_buffer)) {
333
    /* If we get here, the JPEG code has signaled an error. */
334
4.37k
    retval = -1;  goto bailout;
335
4.37k
  }
336
337
35.8k
  cinfo->data_precision = BITS_IN_JSAMPLE;
338
35.8k
  if (*pixelFormat == TJPF_UNKNOWN) cinfo->in_color_space = JCS_UNKNOWN;
339
35.8k
  else cinfo->in_color_space = pf2cs[*pixelFormat];
340
35.8k
  if (tempc == 'B') {
341
14
    if ((src = jinit_read_bmp(cinfo, FALSE)) == NULL)
342
14
      THROW("Could not initialize bitmap loader");
343
14
    invert = !this->bottomUp;
344
39.9k
  } else if (tempc == 'P') {
345
39.9k
    if ((src = _jinit_read_ppm(cinfo)) == NULL)
346
39.9k
      THROW("Could not initialize PPM loader");
347
39.9k
    invert = this->bottomUp;
348
39.9k
  } else
349
18.4E
    THROW("Unsupported file type");
350
351
39.9k
  cinfo->mem->max_memory_to_use = (long)this->maxMemory * 1048576L;
352
353
39.9k
  src->input_file = file;
354
  /* Refuse to load images larger than the specified size. */
355
39.9k
  src->max_pixels = this->maxPixels;
356
39.9k
  (*src->start_input) (cinfo, src);
357
39.9k
  if (tempc == 'B') {
358
0
    if (cinfo->X_density && cinfo->Y_density) {
359
0
      this->xDensity = cinfo->X_density;
360
0
      this->yDensity = cinfo->Y_density;
361
0
      this->densityUnits = cinfo->density_unit;
362
0
    }
363
0
  }
364
39.9k
  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
365
366
39.9k
  *width = cinfo->image_width;  *height = cinfo->image_height;
367
39.9k
  *pixelFormat = cs2pf[cinfo->in_color_space];
368
369
39.9k
  pitch = PAD((*width) * tjPixelSize[*pixelFormat], align);
370
39.9k
  if (
371
#if ULLONG_MAX > SIZE_MAX
372
      (unsigned long long)pitch * (unsigned long long)(*height) >
373
      (unsigned long long)((size_t)-1) ||
374
#endif
375
39.9k
      (dstBuf = (_JSAMPLE *)malloc(pitch * (*height) *
376
39.9k
                                   sizeof(_JSAMPLE))) == NULL)
377
39.9k
    THROW("Memory allocation failure");
378
379
39.9k
  if (setjmp(this2->jerr.setjmp_buffer)) {
380
    /* If we get here, the JPEG code has signaled an error. */
381
8.82k
    retval = -1;  goto bailout;
382
8.82k
  }
383
384
99.0M
  while (cinfo->next_scanline < cinfo->image_height) {
385
98.9M
    int i, nlines = (*src->get_pixel_rows) (cinfo, src);
386
387
197M
    for (i = 0; i < nlines; i++) {
388
98.9M
      _JSAMPLE *dstptr;
389
98.9M
      int row;
390
391
98.9M
      row = cinfo->next_scanline + i;
392
98.9M
      if (invert) dstptr = &dstBuf[((*height) - row - 1) * pitch];
393
84.8M
      else dstptr = &dstBuf[row * pitch];
394
98.9M
      memcpy(dstptr, src->_buffer[i],
395
98.9M
             (*width) * tjPixelSize[*pixelFormat] * sizeof(_JSAMPLE));
396
98.9M
    }
397
98.9M
    cinfo->next_scanline += nlines;
398
98.9M
  }
399
400
31.1k
  (*src->finish_input) (cinfo, src);
401
402
40.1k
bailout:
403
40.1k
  tj3Destroy(handle2);
404
40.1k
  if (file) fclose(file);
405
40.1k
  if (retval < 0) { free(dstBuf);  dstBuf = NULL; }
406
40.1k
  return dstBuf;
407
408
#else /* BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED) */
409
410
  static const char ERROR_MSG[] =
411
    "16-bit data precision requires lossless JPEG,\n"
412
    "which was disabled at build time.";
413
  _JSAMPLE *retval = NULL;
414
415
  GET_TJINSTANCE(handle, NULL)
416
  SNPRINTF(this->errStr, JMSG_LENGTH_MAX, "%s(): %s", FUNCTION_NAME,
417
           ERROR_MSG);
418
  this->isInstanceError = TRUE;  THROWG(ERROR_MSG, NULL)
419
420
bailout:
421
  return retval;
422
423
#endif
424
31.1k
}
tj3LoadImage16
Line
Count
Source
289
11.1k
{
290
11.1k
  static const char FUNCTION_NAME[] =
291
11.1k
    GET_STRING(tj3LoadImage, BITS_IN_JSAMPLE);
292
293
11.1k
#if BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED)
294
295
11.1k
  int retval = 0, tempc;
296
11.1k
  size_t pitch;
297
11.1k
  tjhandle handle2 = NULL;
298
11.1k
  tjinstance *this2;
299
11.1k
  j_compress_ptr cinfo = NULL;
300
11.1k
  cjpeg_source_ptr src;
301
11.1k
  _JSAMPLE *dstBuf = NULL;
302
11.1k
  FILE *file = NULL;
303
11.1k
  boolean invert;
304
305
11.1k
  GET_TJINSTANCE(handle, NULL)
306
307
11.1k
  if (!filename || !width || align < 1 || !height || !pixelFormat ||
308
11.1k
      *pixelFormat < TJPF_UNKNOWN || *pixelFormat >= TJ_NUMPF)
309
11.1k
    THROW("Invalid argument");
310
11.1k
  if ((align & (align - 1)) != 0)
311
11.1k
    THROW("Alignment must be a power of 2");
312
313
  /* The instance handle passed to this function is used only for parameter
314
     retrieval.  Create a new temporary instance to avoid interfering with the
315
     libjpeg state of the primary instance. */
316
11.1k
  if ((handle2 = tj3Init(TJINIT_COMPRESS)) == NULL) return NULL;
317
11.1k
  this2 = (tjinstance *)handle2;
318
11.1k
  cinfo = &this2->cinfo;
319
320
#ifdef _MSC_VER
321
  if (fopen_s(&file, filename, "rb") || file == NULL)
322
#else
323
11.1k
  if ((file = fopen(filename, "rb")) == NULL)
324
0
#endif
325
11.1k
    THROW_UNIX("Cannot open input file");
326
327
11.1k
  if ((tempc = getc(file)) < 0 || ungetc(tempc, file) == EOF)
328
0
    THROW_UNIX("Could not read input file")
329
11.1k
  else if (tempc == EOF)
330
11.1k
    THROW("Input file contains no data");
331
332
11.1k
  if (setjmp(this2->jerr.setjmp_buffer)) {
333
    /* If we get here, the JPEG code has signaled an error. */
334
1.91k
    retval = -1;  goto bailout;
335
1.91k
  }
336
337
9.21k
  cinfo->data_precision = BITS_IN_JSAMPLE;
338
9.21k
  if (*pixelFormat == TJPF_UNKNOWN) cinfo->in_color_space = JCS_UNKNOWN;
339
9.21k
  else cinfo->in_color_space = pf2cs[*pixelFormat];
340
9.21k
  if (tempc == 'B') {
341
7
    if ((src = jinit_read_bmp(cinfo, FALSE)) == NULL)
342
7
      THROW("Could not initialize bitmap loader");
343
7
    invert = !this->bottomUp;
344
10.9k
  } else if (tempc == 'P') {
345
10.9k
    if ((src = _jinit_read_ppm(cinfo)) == NULL)
346
10.9k
      THROW("Could not initialize PPM loader");
347
10.9k
    invert = this->bottomUp;
348
10.9k
  } else
349
18.4E
    THROW("Unsupported file type");
350
351
10.9k
  cinfo->mem->max_memory_to_use = (long)this->maxMemory * 1048576L;
352
353
10.9k
  src->input_file = file;
354
  /* Refuse to load images larger than the specified size. */
355
10.9k
  src->max_pixels = this->maxPixels;
356
10.9k
  (*src->start_input) (cinfo, src);
357
10.9k
  if (tempc == 'B') {
358
0
    if (cinfo->X_density && cinfo->Y_density) {
359
0
      this->xDensity = cinfo->X_density;
360
0
      this->yDensity = cinfo->Y_density;
361
0
      this->densityUnits = cinfo->density_unit;
362
0
    }
363
0
  }
364
10.9k
  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
365
366
10.9k
  *width = cinfo->image_width;  *height = cinfo->image_height;
367
10.9k
  *pixelFormat = cs2pf[cinfo->in_color_space];
368
369
10.9k
  pitch = PAD((*width) * tjPixelSize[*pixelFormat], align);
370
10.9k
  if (
371
#if ULLONG_MAX > SIZE_MAX
372
      (unsigned long long)pitch * (unsigned long long)(*height) >
373
      (unsigned long long)((size_t)-1) ||
374
#endif
375
10.9k
      (dstBuf = (_JSAMPLE *)malloc(pitch * (*height) *
376
10.9k
                                   sizeof(_JSAMPLE))) == NULL)
377
10.9k
    THROW("Memory allocation failure");
378
379
10.9k
  if (setjmp(this2->jerr.setjmp_buffer)) {
380
    /* If we get here, the JPEG code has signaled an error. */
381
4.50k
    retval = -1;  goto bailout;
382
4.50k
  }
383
384
14.0M
  while (cinfo->next_scanline < cinfo->image_height) {
385
14.0M
    int i, nlines = (*src->get_pixel_rows) (cinfo, src);
386
387
28.1M
    for (i = 0; i < nlines; i++) {
388
14.0M
      _JSAMPLE *dstptr;
389
14.0M
      int row;
390
391
14.0M
      row = cinfo->next_scanline + i;
392
14.0M
      if (invert) dstptr = &dstBuf[((*height) - row - 1) * pitch];
393
12.0M
      else dstptr = &dstBuf[row * pitch];
394
14.0M
      memcpy(dstptr, src->_buffer[i],
395
14.0M
             (*width) * tjPixelSize[*pixelFormat] * sizeof(_JSAMPLE));
396
14.0M
    }
397
14.0M
    cinfo->next_scanline += nlines;
398
14.0M
  }
399
400
6.47k
  (*src->finish_input) (cinfo, src);
401
402
11.1k
bailout:
403
11.1k
  tj3Destroy(handle2);
404
11.1k
  if (file) fclose(file);
405
11.1k
  if (retval < 0) { free(dstBuf);  dstBuf = NULL; }
406
11.1k
  return dstBuf;
407
408
#else /* BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED) */
409
410
  static const char ERROR_MSG[] =
411
    "16-bit data precision requires lossless JPEG,\n"
412
    "which was disabled at build time.";
413
  _JSAMPLE *retval = NULL;
414
415
  GET_TJINSTANCE(handle, NULL)
416
  SNPRINTF(this->errStr, JMSG_LENGTH_MAX, "%s(): %s", FUNCTION_NAME,
417
           ERROR_MSG);
418
  this->isInstanceError = TRUE;  THROWG(ERROR_MSG, NULL)
419
420
bailout:
421
  return retval;
422
423
#endif
424
6.47k
}
425
426
427
/* TurboJPEG 3+ */
428
DLLEXPORT int GET_NAME(tj3SaveImage, BITS_IN_JSAMPLE)
429
  (tjhandle handle, const char *filename, const _JSAMPLE *buffer, int width,
430
   int pitch, int height, int pixelFormat)
431
0
{
432
0
  static const char FUNCTION_NAME[] =
433
0
    GET_STRING(tj3SaveImage, BITS_IN_JSAMPLE);
434
0
  int retval = 0;
435
436
0
#if BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED)
437
438
0
  tjhandle handle2 = NULL;
439
0
  tjinstance *this2;
440
0
  j_decompress_ptr dinfo = NULL;
441
0
  djpeg_dest_ptr dst;
442
0
  FILE *file = NULL;
443
0
  char *ptr = NULL;
444
0
  boolean invert;
445
446
0
  GET_TJINSTANCE(handle, -1)
447
448
0
  if (!filename || !buffer || width < 1 || pitch < 0 || height < 1 ||
449
0
      pixelFormat < 0 || pixelFormat >= TJ_NUMPF)
450
0
    THROW("Invalid argument");
451
452
  /* The instance handle passed to this function is used only for parameter
453
     retrieval.  Create a new temporary instance to avoid interfering with the
454
     libjpeg state of the primary instance. */
455
0
  if ((handle2 = tj3Init(TJINIT_DECOMPRESS)) == NULL)
456
0
    return -1;
457
0
  this2 = (tjinstance *)handle2;
458
0
  dinfo = &this2->dinfo;
459
460
#ifdef _MSC_VER
461
  if (fopen_s(&file, filename, "wb") || file == NULL)
462
#else
463
0
  if ((file = fopen(filename, "wb")) == NULL)
464
0
#endif
465
0
    THROW_UNIX("Cannot open output file");
466
467
0
  if (setjmp(this2->jerr.setjmp_buffer)) {
468
    /* If we get here, the JPEG code has signaled an error. */
469
0
    retval = -1;  goto bailout;
470
0
  }
471
472
0
  this2->dinfo.out_color_space = pf2cs[pixelFormat];
473
0
  dinfo->image_width = width;  dinfo->image_height = height;
474
0
  dinfo->global_state = DSTATE_READY;
475
0
  dinfo->scale_num = dinfo->scale_denom = 1;
476
0
  dinfo->data_precision = BITS_IN_JSAMPLE;
477
478
0
  ptr = strrchr(filename, '.');
479
0
  if (ptr && !strcasecmp(ptr, ".bmp")) {
480
0
    if ((dst = jinit_write_bmp(dinfo, FALSE, FALSE)) == NULL)
481
0
      THROW("Could not initialize bitmap writer");
482
0
    invert = !this->bottomUp;
483
0
    dinfo->X_density = (UINT16)this->xDensity;
484
0
    dinfo->Y_density = (UINT16)this->yDensity;
485
0
    dinfo->density_unit = (UINT8)this->densityUnits;
486
0
  } else {
487
0
    if ((dst = _jinit_write_ppm(dinfo)) == NULL)
488
0
      THROW("Could not initialize PPM writer");
489
0
    invert = this->bottomUp;
490
0
  }
491
492
0
  dinfo->mem->max_memory_to_use = (long)this->maxMemory * 1048576L;
493
494
0
  dst->output_file = file;
495
0
  (*dst->start_output) (dinfo, dst);
496
0
  (*dinfo->mem->realize_virt_arrays) ((j_common_ptr)dinfo);
497
498
0
  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];
499
500
0
  while (dinfo->output_scanline < dinfo->output_height) {
501
0
    _JSAMPLE *rowptr;
502
503
0
    if (invert)
504
0
      rowptr =
505
0
        (_JSAMPLE *)&buffer[(height - dinfo->output_scanline - 1) * pitch];
506
0
    else
507
0
      rowptr = (_JSAMPLE *)&buffer[dinfo->output_scanline * pitch];
508
0
    memcpy(dst->_buffer[0], rowptr,
509
0
           width * tjPixelSize[pixelFormat] * sizeof(_JSAMPLE));
510
0
    (*dst->put_pixel_rows) (dinfo, dst, 1);
511
0
    dinfo->output_scanline++;
512
0
  }
513
514
0
  (*dst->finish_output) (dinfo, dst);
515
516
0
bailout:
517
0
  tj3Destroy(handle2);
518
0
  if (file) fclose(file);
519
0
  return retval;
520
521
#else /* BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED) */
522
523
  GET_TJINSTANCE(handle, -1)
524
  THROW("16-bit data precision requires lossless JPEG,\n"
525
        "which was disabled at build time.")
526
bailout:
527
  return retval;
528
529
#endif
530
0
}
Unexecuted instantiation: tj3SaveImage8
Unexecuted instantiation: tj3SaveImage12
Unexecuted instantiation: tj3SaveImage16
531
532
533
#undef _JSAMPLE
534
#undef _JSAMPROW
535
#undef _buffer
536
#undef _jinit_read_ppm
537
#undef _jinit_write_ppm
538
#undef _jpeg_crop_scanline
539
#undef _jpeg_read_scanlines
540
#undef _jpeg_skip_scanlines
541
#undef _jpeg_write_scanlines