← Back to branch summary

~ubuntu-branches/ubuntu/raring/hplip/raring

« back to all changes in this revision

Viewing changes to prnt/hpcups/ModeJpeg.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Mark Purcell
  • Date: 2009-12-14 20:08:44 UTC
  • mfrom: (2.1.118 lucid)
  • Revision ID: james.westby@ubuntu.com-20091214200844-z8qhqwgppbu3t7ze
Tags: 3.9.10-4
http://bugs.debian.org/560796
KBSD patch from KiBi (Closes: #560796)

Show diffs side-by-side

added added

removed removed

Lines of Context:
prnt/hpcups/ModeJpeg.cpp
 
1
/*****************************************************************************\
 
2
  ModeJpeg.cpp : Jpeg compressor implementation
 
3
 
 
4
  Copyright (c) 1996 - 2009, Hewlett-Packard Co.
 
5
  All rights reserved.
 
6
 
 
7
  Redistribution and use in source and binary forms, with or without
 
8
  modification, are permitted provided that the following conditions
 
9
  are met:
 
10
  1. Redistributions of source code must retain the above copyright
 
11
     notice, this list of conditions and the following disclaimer.
 
12
  2. Redistributions in binary form must reproduce the above copyright
 
13
     notice, this list of conditions and the following disclaimer in the
 
14
     documentation and/or other materials provided with the distribution.
 
15
  3. Neither the name of Hewlett-Packard nor the names of its
 
16
     contributors may be used to endorse or promote products derived
 
17
     from this software without specific prior written permission.
 
18
 
 
19
  THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
 
20
  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 
21
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
 
22
  NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
23
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 
24
  TO, PATENT INFRINGEMENT; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 
25
  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 
26
  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
27
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 
28
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
29
\*****************************************************************************/
 
30
 
 
31
#include "CommonDefinitions.h"
 
32
#include <setjmp.h>
 
33
#include "ModeJpeg.h"
 
34
#include <dlfcn.h>
 
35
#include "Utils.h"
 
36
 
 
37
#define MAX_JPEG_FILE_SIZE 2097152    // 2 Mgabytes
 
38
 
 
39
extern "C"
 
40
{
 
41
    int (*HPLJJRCompress) (BYTE        *pCompressedData,
 
42
                           uint32_t    *pCompressedDataLen,
 
43
                           BYTE        *InputData,
 
44
                           const uint32_t    uiLogicalImageWidth,
 
45
                           const uint32_t    uiLogicalImageHeight);
 
46
}
 
47
 
 
48
ModeJpeg::ModeJpeg(unsigned int raster_width) : Compressor (raster_width, false)
 
49
{
 
50
    m_eCompressor       = COMPRESSOR_JPEG_QUICKCONNECT;
 
51
    m_iColorMode        = 0;
 
52
    m_max_file_size     = MAX_JPEG_FILE_SIZE;;
 
53
    compressedsize      = 0;
 
54
    m_iRowWidth         = (int) raster_width * 3;
 
55
    m_iRowNumber        = 0;
 
56
    m_iBandHeight       = 0;
 
57
    m_uiGrayscaleOffset = 0;
 
58
    m_pbyInputBuffer    = NULL;
 
59
    m_hHPLibHandle      = NULL;
 
60
    compressBuf         = NULL;
 
61
 
 
62
//  Don't need originalKData buffer allocate by Compressor, delete it
 
63
    if (originalKData)
 
64
    {
 
65
        delete [] originalKData;
 
66
        originalKData = NULL;
 
67
    }
 
68
}
 
69
 
 
70
DRIVER_ERROR ModeJpeg::Init(int max_file_size, int page_height)
 
71
{
 
72
    int    buffer_size = m_iRowWidth * (page_height + 2);
 
73
    m_pbyInputBuffer = new BYTE[buffer_size];
 
74
    if (m_pbyInputBuffer == NULL)
 
75
    {
 
76
        return ALLOCMEM_ERROR;
 
77
    }
 
78
    if (max_file_size > 0)
 
79
    {
 
80
        m_max_file_size = (unsigned int) max_file_size;
 
81
    }
 
82
    compressBuf = new BYTE[m_max_file_size];
 
83
    if (compressBuf == NULL)
 
84
    {
 
85
        return ALLOCMEM_ERROR;
 
86
    }
 
87
    m_iBandHeight = page_height;
 
88
    return NO_ERROR;
 
89
}
 
90
 
 
91
DRIVER_ERROR ModeJpeg::Init(int color_mode, int band_height, COMPRESS_MODE *eCompressMode, QTableInfo *qtable_info)
 
92
{
 
93
    DRIVER_ERROR    err;
 
94
    m_iColorMode = color_mode;
 
95
    m_pQTableInfo = qtable_info;
 
96
    int    buf_size = band_height * m_iRowWidth;
 
97
    err = Init(buf_size, band_height);
 
98
    if (err != NO_ERROR)
 
99
    {
 
100
        return err;
 
101
    }
 
102
 
 
103
//  If plugin is not available or the plugin does not contain Taos compressor, stay with JPEG compression
 
104
    m_eCompressor = COMPRESSOR_JPEG_JETREADY;
 
105
    if (*eCompressMode == COMPRESS_MODE_LJ)
 
106
    {
 
107
        m_hHPLibHandle = LoadPlugin ("lj.so");
 
108
        if (m_hHPLibHandle)
 
109
        {
 
110
            dlerror ();
 
111
            *(void **) (&HPLJJRCompress) = dlsym (m_hHPLibHandle, "HPJetReadyCompress");
 
112
            if (HPLJJRCompress == NULL)
 
113
            {
 
114
                dlclose(m_hHPLibHandle);
 
115
                m_hHPLibHandle = NULL;
 
116
                *eCompressMode = COMPRESS_MODE_JPEG;
 
117
            }
 
118
            else
 
119
            {
 
120
                m_eCompressor = COMPRESSOR_TAOS;
 
121
            }
 
122
        }
 
123
    }
 
124
    return err;
 
125
}
 
126
 
 
127
ModeJpeg::~ModeJpeg()
 
128
{
 
129
    if (m_hHPLibHandle)
 
130
    {
 
131
        dlclose(m_hHPLibHandle);
 
132
    }
 
133
    if (m_pbyInputBuffer)
 
134
    {
 
135
        delete [] m_pbyInputBuffer;
 
136
    }
 
137
}
 
138
 
 
139
void ModeJpeg::Flush()
 
140
{
 
141
    if (m_iRowNumber > 0)
 
142
    {
 
143
        compress();
 
144
    }
 
145
}
 
146
 
 
147
#define RGBTOGRAY(rgb) (BYTE) ((rgb[0] * 30 + rgb[1] * 59 + rgb[2] * 11) / 100)
 
148
void ModeJpeg::rgbToGray(BYTE *rgbData, int iNumBytes)
 
149
{
 
150
    if (m_eCompressor == COMPRESSOR_TAOS)
 
151
    {
 
152
        BYTE    *p = m_pbyInputBuffer + (m_iRowNumber * m_iRowWidth);
 
153
        for (int i = 0; i < iNumBytes; i += 3, rgbData += 3)
 
154
        {
 
155
            *p++ = RGBTOGRAY(rgbData);
 
156
            *p++ = 0;
 
157
            *p++ - 0;
 
158
        }
 
159
        return;
 
160
    }
 
161
    BYTE    *p = m_pbyInputBuffer + (m_iRowNumber * m_iRowWidth / 3);
 
162
    for (int i = 0; i < iNumBytes; i += 3, rgbData += 3)
 
163
    {
 
164
        *p++ = 255 - RGBTOGRAY(rgbData);
 
165
    }
 
166
}
 
167
 
 
168
bool ModeJpeg::Process(RASTERDATA *input)
 
169
{
 
170
    if (input == NULL)
 
171
    {
 
172
        return false;
 
173
    }
 
174
    if (input->rasterdata[COLORTYPE_COLOR])
 
175
    {
 
176
        if (m_iColorMode == 0)
 
177
        {
 
178
            memcpy(m_pbyInputBuffer + (m_iRowNumber * m_iRowWidth), input->rasterdata[COLORTYPE_COLOR],
 
179
                   input->rastersize[COLORTYPE_COLOR]);
 
180
        }
 
181
        else
 
182
        {
 
183
            rgbToGray(input->rasterdata[COLORTYPE_COLOR], input->rastersize[COLORTYPE_COLOR]);
 
184
        }
 
185
    }
 
186
    m_iRowNumber++;
 
187
    if (m_iRowNumber == m_iBandHeight)
 
188
    {
 
189
        compress();
 
190
        return true;
 
191
    }
 
192
    return false;
 
193
}
 
194
 
 
195
bool ModeJpeg::NextOutputRaster (RASTERDATA &next_raster)
 
196
{
 
197
    if (iRastersReady == 0)
 
198
    {
 
199
        return false;
 
200
    }
 
201
    if (myplane == COLORTYPE_COLOR && compressedsize != 0)
 
202
    {
 
203
        next_raster.rastersize[COLORTYPE_COLOR] = compressedsize - m_uiGrayscaleOffset;
 
204
        next_raster.rasterdata[COLORTYPE_COLOR] = compressBuf + m_uiGrayscaleOffset;
 
205
    }
 
206
    else
 
207
    {
 
208
        next_raster.rastersize[COLORTYPE_COLOR] = 0;
 
209
        next_raster.rasterdata[COLORTYPE_COLOR] = NULL;
 
210
    }
 
211
    next_raster.rastersize[COLORTYPE_BLACK] = 0;
 
212
    next_raster.rasterdata[COLORTYPE_BLACK] = NULL;
 
213
 
 
214
    iRastersReady = 0;
 
215
    m_uiGrayscaleOffset = 0;
 
216
    return true;
 
217
}
 
218
 
 
219
static void output_buffer_callback (JOCTET *outbuf, BYTE *buffer, int size)
 
220
{
 
221
    ModeJpeg    *pModeJpeg = (ModeJpeg *) outbuf;
 
222
    pModeJpeg->StoreJpegData (buffer, size);
 
223
}
 
224
 
 
225
void ModeJpeg::StoreJpegData (BYTE *buffer, int iSize)
 
226
{
 
227
    compressedsize += iSize;
 
228
    if (compressedsize < m_max_file_size)
 
229
    {
 
230
        memcpy (compressBuf + compressedsize - iSize, buffer, iSize);
 
231
    }
 
232
    else
 
233
    {
 
234
        compressedsize = m_max_file_size + 1;
 
235
    }
 
236
}
 
237
 
 
238
//----------------------------------------------------------------
 
239
// These are "overrides" to the JPEG library error routines
 
240
//----------------------------------------------------------------
 
241
 
 
242
static void HPJpeg_error (j_common_ptr cinfo)
 
243
{
 
244
 
 
245
}
 
246
 
 
247
extern "C"
 
248
{
 
249
    void jpeg_buffer_dest (j_compress_ptr cinfo, JOCTET* outbuff, void* flush_output_buffer_callback);
 
250
    void hp_rgb_ycc_setup (int iFlag);
 
251
}
 
252
 
 
253
void ModeJpeg::compress () 
 
254
{
 
255
    switch(m_eCompressor)
 
256
    {
 
257
        case COMPRESSOR_JPEG_QUICKCONNECT:
 
258
        {
 
259
            jpegCompressForQuickConnect();
 
260
            break;
 
261
        }
 
262
        case COMPRESSOR_JPEG_JETREADY:
 
263
        {
 
264
            jpegCompressForJetReady();
 
265
            break;
 
266
        }
 
267
        case COMPRESSOR_TAOS:
 
268
        {
 
269
            taosCompressForJetReady();
 
270
            break;
 
271
        }
 
272
    }
 
273
    m_iRowNumber = 0;
 
274
    iRastersReady = 1;
 
275
    memset(m_pbyInputBuffer, 0xFF, m_iRowWidth * m_iBandHeight);
 
276
}
 
277
 
 
278
void ModeJpeg::jpegCompressForQuickConnect()
 
279
{
 
280
    BYTE    *p;
 
281
    int     iQuality = 100;
 
282
 
 
283
/*
 
284
 *  Convert the byte buffer to jpg, if converted size is greater than 2MB, delete it and
 
285
 *  convert with a higher compression factor.
 
286
 */
 
287
 
 
288
    struct jpeg_compress_struct cinfo;
 
289
    struct jpeg_error_mgr       jerr;
 
290
    jmp_buf                     setjmp_buffer;
 
291
 
 
292
    bool    bRedo;
 
293
 
 
294
//  Use the standard RGB to YCC table rather than the modified one for JetReady
 
295
 
 
296
    hp_rgb_ycc_setup (0);
 
297
    do
 
298
    {
 
299
        bRedo = 0;
 
300
        compressedsize = 0;
 
301
        memset (compressBuf, 0xFF, m_max_file_size);
 
302
        p = m_pbyInputBuffer;
 
303
 
 
304
        cinfo.err = jpeg_std_error (&jerr);
 
305
        jerr.error_exit = HPJpeg_error;
 
306
        if (setjmp (setjmp_buffer))
 
307
        {
 
308
            jpeg_destroy_compress (&cinfo);
 
309
            return;
 
310
        }
 
311
 
 
312
        jpeg_create_compress (&cinfo);
 
313
        cinfo.in_color_space = JCS_RGB;
 
314
        jpeg_set_defaults (&cinfo);
 
315
        cinfo.image_width = m_iRowWidth / 3;
 
316
        cinfo.image_height = m_iRowNumber;
 
317
        cinfo.input_components = 3;
 
318
        cinfo.data_precision = 8;
 
319
        jpeg_set_quality (&cinfo, iQuality, TRUE);
 
320
        jpeg_buffer_dest (&cinfo, (JOCTET *) this, (void *) (output_buffer_callback));
 
321
        jpeg_start_compress (&cinfo, TRUE);
 
322
        JSAMPROW    pRowArray[1];
 
323
        for (int i = 0; i < m_iRowNumber; i++)
 
324
        {
 
325
            pRowArray[0] = (JSAMPROW) p;
 
326
            jpeg_write_scanlines (&cinfo, pRowArray, 1);
 
327
            p += (m_iRowWidth);
 
328
            if (compressedsize > m_max_file_size)
 
329
            {
 
330
                compressedsize = 0;
 
331
                bRedo = 1;
 
332
            }
 
333
        }
 
334
        jpeg_finish_compress (&cinfo);
 
335
        jpeg_destroy_compress (&cinfo);
 
336
        iQuality -= 10;
 
337
        if (iQuality == 0)
 
338
        {
 
339
            compressedsize = 0;
 
340
            return;
 
341
        }
 
342
    } while (bRedo);
 
343
    return;
 
344
}
 
345
 
 
346
void ModeJpeg::jpegCompressForJetReady()
 
347
{
 
348
    struct jpeg_compress_struct cinfo;
 
349
    struct jpeg_error_mgr       jerr;
 
350
    jmp_buf                     setjmp_buffer;
 
351
 
 
352
 
 
353
//  Use the modified Mojave CSC table
 
354
    hp_rgb_ycc_setup (1);
 
355
 
 
356
    compressedsize = 0;
 
357
    memset (compressBuf, 0xFF, m_max_file_size);
 
358
 
 
359
    cinfo.err = jpeg_std_error (&jerr);
 
360
    jerr.error_exit = HPJpeg_error;
 
361
    if (setjmp (setjmp_buffer))
 
362
    {
 
363
        jpeg_destroy_compress (&cinfo);
 
364
        return;
 
365
    }
 
366
 
 
367
    jpeg_create_compress (&cinfo);
 
368
    cinfo.in_color_space = (m_iColorMode == 0) ? JCS_RGB : JCS_GRAYSCALE;
 
369
    jpeg_set_defaults (&cinfo);
 
370
    cinfo.image_width = m_iRowWidth / 3;
 
371
    cinfo.image_height = m_iBandHeight;
 
372
    cinfo.input_components = (m_iColorMode == 0) ? 3 : 1;
 
373
    cinfo.data_precision = 8;
 
374
 
 
375
    // Create a static quant table here. 
 
376
 
 
377
    static unsigned int mojave_quant_table1[64] =  {
 
378
                                                    2,3,4,5,5,5,5,5,
 
379
                                                    3,6,5,8,5,8,5,8,
 
380
                                                    4,5,5,5,5,5,5,5,
 
381
                                                    5,8,5,8,5,8,5,8,
 
382
                                                    5,5,5,5,5,5,5,5,
 
383
                                                    5,8,5,8,5,8,5,8,
 
384
                                                    5,5,5,5,5,5,5,5,
 
385
                                                    5,8,5,8,5,8,5,8
 
386
                                                    };
 
387
    
 
388
    //
 
389
    // JetReady specific Q-Tables will be added here. We do the following:
 
390
    //  1. Add three Q-Tables.
 
391
    //  2. Scale the Q-Table elemets with the given scale factor.
 
392
    //  3. Check to see if any of the element in the table is greater than 255
 
393
    //     reset that elemet to 255.
 
394
    //  5. There is a specific scaling needed to be done to the first 6 
 
395
    //     elements in the matrix. This is required to achieve better
 
396
    //     compression ratio.
 
397
    //  4. Check to see if any the of the recently modified element is
 
398
    //     greater than 255, reset that to 255.
 
399
    //
 
400
    //  Please refer to sRGBLaserHostBasedSoftwareERS.doc v9.0 section 5.2.5.3.1.1
 
401
    //  for more details.
 
402
    //
 
403
    //  [NOTE] These loop needs to be further optimized.
 
404
    //
 
405
    for (int i = 0; i < 3; i++)
 
406
    {
 
407
        // Adding Q-Table.
 
408
 
 
409
        jpeg_add_quant_table(&cinfo, i, mojave_quant_table1,  0, FALSE );
 
410
        //
 
411
        // Scaling the Q-Table elements. 
 
412
        // Reset the element to 255, if it is greater than 255.
 
413
        //
 
414
 
 
415
        for(int j = 1; j < 64; j++)
 
416
        {
 
417
            cinfo.quant_tbl_ptrs[i]->quantval[j] = (UINT16)((mojave_quant_table1[j] * m_pQTableInfo->qFactor) & 0xFF);  
 
418
        }   // for (int j = 1; j < 64; j++)
 
419
 
 
420
        //
 
421
        // Special scaling for first 6 elements in the table.
 
422
        // Reset the specially scaled elements 255, if it is greater than 255.
 
423
        //
 
424
 
 
425
        //
 
426
        // 1st component in the table. Unchanged, I need not change anything here.
 
427
        //
 
428
        cinfo.quant_tbl_ptrs[i]->quantval[0] = (UINT16)mojave_quant_table1[0];
 
429
        
 
430
        //
 
431
        // 2nd and 3rd components in the zig zag order
 
432
        //
 
433
        // The following dTemp is being used  to ceil the vales: e.g 28.5 to 29
 
434
        //
 
435
        double dTemp = mojave_quant_table1[1] * (1 + 0.25 * (m_pQTableInfo->qFactor - 1)) + 0.5;
 
436
        cinfo.quant_tbl_ptrs[i]->quantval[1] = (UINT16)dTemp & 0xFF;
 
437
        
 
438
        dTemp = mojave_quant_table1[8] * (1 + 0.25 * (m_pQTableInfo->qFactor - 1)) + 0.5;
 
439
        cinfo.quant_tbl_ptrs[i]->quantval[8] = (UINT16)dTemp & 0xFF;
 
440
       
 
441
        //
 
442
        // 4th, 5th and 6th components in the zig zag order
 
443
        //
 
444
        dTemp = mojave_quant_table1[16] * (1 + 0.50 * (m_pQTableInfo->qFactor - 1)) + 0.5;
 
445
        cinfo.quant_tbl_ptrs[i]->quantval[16] = (UINT16)dTemp & 0xFF;
 
446
        
 
447
        dTemp = mojave_quant_table1[9] * (1 + 0.50 * (m_pQTableInfo->qFactor - 1)) + 0.5;
 
448
        cinfo.quant_tbl_ptrs[i]->quantval[9]  = (UINT16)dTemp & 0xFF;
 
449
        
 
450
        dTemp = mojave_quant_table1[2] * (1 + 0.50 * (m_pQTableInfo->qFactor - 1)) + 0.5;
 
451
        cinfo.quant_tbl_ptrs[i]->quantval[2]  = (UINT16)dTemp & 0xFF;
 
452
    }   // for (i = 0; i < 3; i++)
 
453
 
 
454
    // Hard code to use sampling mode 4:4:4
 
455
 
 
456
    cinfo.comp_info[0].h_samp_factor = 1;
 
457
    cinfo.comp_info[0].v_samp_factor = 1;
 
458
 
 
459
    jpeg_buffer_dest (&cinfo, (JOCTET *) this, (void *) (output_buffer_callback));
 
460
 
 
461
    int    row_width = m_iRowWidth;
 
462
    if (m_iColorMode != 0)
 
463
    {
 
464
        row_width = m_iRowWidth / 3;
 
465
        cinfo.write_JFIF_header = FALSE;
 
466
        cinfo.write_Adobe_marker = FALSE;
 
467
        jpeg_suppress_tables(&cinfo, TRUE);
 
468
    }
 
469
 
 
470
    jpeg_start_compress (&cinfo, TRUE);
 
471
    JSAMPROW    pRowArray[1];
 
472
    BYTE        *pScanLine = m_pbyInputBuffer;
 
473
    int         i;
 
474
    for (i = 0; i < m_iBandHeight; i++)
 
475
    {
 
476
        pRowArray[0] = (JSAMPROW) pScanLine;
 
477
        jpeg_write_scanlines (&cinfo, pRowArray, 1);
 
478
        pScanLine += (row_width);
 
479
    }
 
480
    jpeg_finish_compress (&cinfo);
 
481
 
 
482
//  Read the quantization table used for this compression
 
483
 
 
484
    if (cinfo.quant_tbl_ptrs[0] != NULL)
 
485
    {
 
486
//        memcpy(m_pQTableInfo->qtable0, cinfo.quant_tbl_ptrs[0]->quantval, QTABLE_SIZE);
 
487
        for (i = 0; i < QTABLE_SIZE; i++)
 
488
        {
 
489
            m_pQTableInfo->qtable0[i] = cinfo.quant_tbl_ptrs[0]->quantval[i];
 
490
        }
 
491
    }
 
492
    if (cinfo.quant_tbl_ptrs[1] != NULL)
 
493
    {
 
494
//        memcpy(m_pQTableInfo->qtable1, cinfo.quant_tbl_ptrs[1]->quantval, QTABLE_SIZE);
 
495
        for (i = 0; i < QTABLE_SIZE; i++)
 
496
        {
 
497
            m_pQTableInfo->qtable1[i] = cinfo.quant_tbl_ptrs[1]->quantval[i];
 
498
        }
 
499
    }
 
500
    if (cinfo.quant_tbl_ptrs[2] != NULL)
 
501
    {
 
502
//        memcpy(m_pQTableInfo->qtable2, cinfo.quant_tbl_ptrs[2]->quantval, QTABLE_SIZE);
 
503
        for (i = 0; i < QTABLE_SIZE; i++)
 
504
        {
 
505
            m_pQTableInfo->qtable2[i] = cinfo.quant_tbl_ptrs[2]->quantval[i];
 
506
        }
 
507
    }
 
508
    jpeg_destroy_compress (&cinfo);
 
509
    if (m_iColorMode != 0)
 
510
    {
 
511
        unsigned int    l = 0;
 
512
        while (l < compressedsize)
 
513
        {
 
514
            if (compressBuf[l] == 0xFF && compressBuf[l+1] == 0xDA)
 
515
                break;
 
516
            l++;
 
517
        }
 
518
        if (l != compressedsize)
 
519
        {
 
520
            m_uiGrayscaleOffset = l + 10;
 
521
        }
 
522
    }
 
523
}
 
524
 
 
525
void ModeJpeg::taosCompressForJetReady()
 
526
{
 
527
    int    iRet;
 
528
    int    bufSize = m_max_file_size;
 
529
    iRet = HPLJJRCompress(compressBuf, (uint32_t *) &bufSize, m_pbyInputBuffer, m_iRowWidth / 3, m_iBandHeight);
 
530
    compressedsize = (iRet < 0) ? 0 : bufSize;
 
531
}
 
532