Linux-JPEG格式图片显示

GEC6818开发板800*480LCD屏幕显示JPEG格式图片

jerror.h

#ifndef JMESSAGE
#ifndef JERROR_H
/* First time through, define the enum list */
#define JMAKE_ENUM_LIST
#else
/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
#define JMESSAGE(code,string)
#endif /* JERROR_H */
#endif /* JMESSAGE */#ifdef JMAKE_ENUM_LISTtypedef enum {#define JMESSAGE(code,string)  code ,#endif /* JMAKE_ENUM_LIST */JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! *//* For maintenance convenience, list is alphabetical by message code name */
JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix")
JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix")
JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode")
JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS")
JMESSAGE(JERR_BAD_CROP_SPEC, "Invalid crop request")
JMESSAGE(JERR_BAD_DCT_COEF, "DCT coefficient out of range")
JMESSAGE(JERR_BAD_DCTSIZE, "DCT scaled block size %dx%d not supported")
JMESSAGE(JERR_BAD_DROP_SAMPLING,"Component index %d: mismatching sampling ratio %d:%d, %d:%d, %c")
JMESSAGE(JERR_BAD_HUFF_TABLE, "Bogus Huffman table definition")
JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace")
JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace")
JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length")
JMESSAGE(JERR_BAD_LIB_VERSION,"Wrong JPEG library version: library is %d, caller expects %d")
JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan")
JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d")
JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d")
JMESSAGE(JERR_BAD_PROGRESSION,"Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d")
JMESSAGE(JERR_BAD_PROG_SCRIPT,"Invalid progressive parameters at scan script entry %d")
JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors")
JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d")
JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d")
JMESSAGE(JERR_BAD_STRUCT_SIZE,"JPEG parameter struct mismatch: library thinks size is %u, caller expects %u")
JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access")
JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small")
JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here")
JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet")
JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d")
JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request")
JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d")
JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x")
JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d")
JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d")
JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)")
JMESSAGE(JERR_EMS_READ, "Read from EMS failed")
JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed")
JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan")
JMESSAGE(JERR_FILE_READ, "Input file read error")
JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?")
JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet")
JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow")
JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry")
JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels")
JMESSAGE(JERR_INPUT_EMPTY, "Empty input file")
JMESSAGE(JERR_INPUT_EOF, "Premature end of input file")
JMESSAGE(JERR_MISMATCHED_QUANT_TABLE,"Cannot transcode due to multiple use of quantization table %d")
JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data")
JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change")
JMESSAGE(JERR_NOTIMPL, "Not implemented yet")
JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time")
JMESSAGE(JERR_NO_ARITH_TABLE, "Arithmetic table 0x%02x was not defined")
JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported")
JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined")
JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image")
JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined")
JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x")
JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)")
JMESSAGE(JERR_QUANT_COMPONENTS,"Cannot quantize more than %d color components")
JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors")
JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors")
JMESSAGE(JERR_SOF_BEFORE, "Invalid JPEG file structure: %s before SOF")
JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers")
JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker")
JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x")
JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers")
JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s")
JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file")
JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file")
JMESSAGE(JERR_TFILE_WRITE,"Write failed on temporary file --- out of disk space?")
JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines")
JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x")
JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up")
JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation")
JMESSAGE(JERR_XMS_READ, "Read from XMS failed")
JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed")
JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT)
JMESSAGE(JMSG_VERSION, JVERSION)
JMESSAGE(JTRC_16BIT_TABLES,"Caution: quantization tables are too coarse for baseline JPEG")
JMESSAGE(JTRC_ADOBE,"Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d")
JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u")
JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u")
JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x")
JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x")
JMESSAGE(JTRC_DQT, "Define Quantization Table %d  precision %d")
JMESSAGE(JTRC_DRI, "Define Restart Interval %u")
JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u")
JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u")
JMESSAGE(JTRC_EOI, "End Of Image")
JMESSAGE(JTRC_HUFFBITS, "        %3d %3d %3d %3d %3d %3d %3d %3d")
JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d  %d")
JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE,"Warning: thumbnail image size does not match data length %u")
JMESSAGE(JTRC_JFIF_EXTENSION,"JFIF extension marker: type 0x%02x, length %u")
JMESSAGE(JTRC_JFIF_THUMBNAIL, "    with %d x %d thumbnail image")
JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u")
JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x")
JMESSAGE(JTRC_QUANTVALS, "        %4u %4u %4u %4u %4u %4u %4u %4u")
JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors")
JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors")
JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization")
JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d")
JMESSAGE(JTRC_RST, "RST%d")
JMESSAGE(JTRC_SMOOTH_NOTIMPL,"Smoothing not supported with nonstandard sampling ratios")
JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d")
JMESSAGE(JTRC_SOF_COMPONENT, "    Component %d: %dhx%dv q=%d")
JMESSAGE(JTRC_SOI, "Start of Image")
JMESSAGE(JTRC_SOS, "Start Of Scan: %d components")
JMESSAGE(JTRC_SOS_COMPONENT, "    Component %d: dc=%d ac=%d")
JMESSAGE(JTRC_SOS_PARAMS, "  Ss=%d, Se=%d, Ah=%d, Al=%d")
JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s")
JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s")
JMESSAGE(JTRC_THUMB_JPEG,"JFIF extension marker: JPEG-compressed thumbnail image, length %u")
JMESSAGE(JTRC_THUMB_PALETTE,"JFIF extension marker: palette thumbnail image, length %u")
JMESSAGE(JTRC_THUMB_RGB,"JFIF extension marker: RGB thumbnail image, length %u")
JMESSAGE(JTRC_UNKNOWN_IDS,"Unrecognized component IDs %d %d %d, assuming YCbCr")
JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u")
JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u")
JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d")
JMESSAGE(JWRN_ARITH_BAD_CODE, "Corrupt JPEG data: bad arithmetic code")
JMESSAGE(JWRN_BOGUS_PROGRESSION,"Inconsistent progression sequence for component %d coefficient %d")
JMESSAGE(JWRN_EXTRANEOUS_DATA,"Corrupt JPEG data: %u extraneous bytes before marker 0x%02x")
JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment")
JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code")
JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d")
JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file")
JMESSAGE(JWRN_MUST_RESYNC,"Corrupt JPEG data: found marker 0x%02x instead of RST%d")
JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG")
JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines")#ifdef JMAKE_ENUM_LISTJMSG_LASTMSGCODE
} J_MESSAGE_CODE;#undef JMAKE_ENUM_LIST
#endif /* JMAKE_ENUM_LIST *//* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
#undef JMESSAGE#ifndef JERROR_H
#define JERROR_H/* Macros to simplify using the error and trace message stuff */
/* The first parameter is either type of cinfo pointer *//* Fatal errors (print message and exit) */
#define ERREXIT(cinfo,code)  \((cinfo)->err->msg_code = (code), \(*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
#define ERREXIT1(cinfo,code,p1)  \((cinfo)->err->msg_code = (code), \(cinfo)->err->msg_parm.i[0] = (p1), \(*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
#define ERREXIT2(cinfo,code,p1,p2)  \((cinfo)->err->msg_code = (code), \(cinfo)->err->msg_parm.i[0] = (p1), \(cinfo)->err->msg_parm.i[1] = (p2), \(*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
#define ERREXIT3(cinfo,code,p1,p2,p3)  \((cinfo)->err->msg_code = (code), \(cinfo)->err->msg_parm.i[0] = (p1), \(cinfo)->err->msg_parm.i[1] = (p2), \(cinfo)->err->msg_parm.i[2] = (p3), \(*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
#define ERREXIT4(cinfo,code,p1,p2,p3,p4)  \((cinfo)->err->msg_code = (code), \(cinfo)->err->msg_parm.i[0] = (p1), \(cinfo)->err->msg_parm.i[1] = (p2), \(cinfo)->err->msg_parm.i[2] = (p3), \(cinfo)->err->msg_parm.i[3] = (p4), \(*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
#define ERREXIT6(cinfo,code,p1,p2,p3,p4,p5,p6)  \((cinfo)->err->msg_code = (code), \(cinfo)->err->msg_parm.i[0] = (p1), \(cinfo)->err->msg_parm.i[1] = (p2), \(cinfo)->err->msg_parm.i[2] = (p3), \(cinfo)->err->msg_parm.i[3] = (p4), \(cinfo)->err->msg_parm.i[4] = (p5), \(cinfo)->err->msg_parm.i[5] = (p6), \(*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
#define ERREXITS(cinfo,code,str)  \((cinfo)->err->msg_code = (code), \strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \(*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))#define MAKESTMT(stuff)     do { stuff } while (0)/* Nonfatal errors (we can keep going, but the data is probably corrupt) */
#define WARNMS(cinfo,code)  \((cinfo)->err->msg_code = (code), \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
#define WARNMS1(cinfo,code,p1)  \((cinfo)->err->msg_code = (code), \(cinfo)->err->msg_parm.i[0] = (p1), \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
#define WARNMS2(cinfo,code,p1,p2)  \((cinfo)->err->msg_code = (code), \(cinfo)->err->msg_parm.i[0] = (p1), \(cinfo)->err->msg_parm.i[1] = (p2), \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))/* Informational/debugging messages */
#define TRACEMS(cinfo,lvl,code)  \((cinfo)->err->msg_code = (code), \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
#define TRACEMS1(cinfo,lvl,code,p1)  \((cinfo)->err->msg_code = (code), \(cinfo)->err->msg_parm.i[0] = (p1), \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
#define TRACEMS2(cinfo,lvl,code,p1,p2)  \((cinfo)->err->msg_code = (code), \(cinfo)->err->msg_parm.i[0] = (p1), \(cinfo)->err->msg_parm.i[1] = (p2), \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
#define TRACEMS3(cinfo,lvl,code,p1,p2,p3)  \MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \_mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \(cinfo)->err->msg_code = (code); \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4)  \MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \_mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \(cinfo)->err->msg_code = (code); \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
#define TRACEMS5(cinfo,lvl,code,p1,p2,p3,p4,p5)  \MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \_mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \_mp[4] = (p5); \(cinfo)->err->msg_code = (code); \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8)  \MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \_mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \_mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \(cinfo)->err->msg_code = (code); \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
#define TRACEMSS(cinfo,lvl,code,str)  \((cinfo)->err->msg_code = (code), \strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \(*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))#endif /* JERROR_H */

jpeglib.h

/** jpeglib.h** Copyright (C) 1991-1998, Thomas G. Lane.* Modified 2002-2017 by Guido Vollbeding.* This file is part of the Independent JPEG Group's software.* For conditions of distribution and use, see the accompanying README file.** This file defines the application interface for the JPEG library.* Most applications using the library need only include this file,* and perhaps jerror.h if they want to know the exact error codes.*/#ifndef JPEGLIB_H
#define JPEGLIB_H/** First we include the configuration files that record how this* installation of the JPEG library is set up.  jconfig.h can be* generated automatically for many systems.  jmorecfg.h contains* manual configuration options that most people need not worry about.*/#ifndef JCONFIG_INCLUDED    /* in case jinclude.h already did */
#include "jconfig.h"      /* widely used configuration options */
#endif
#include "jmorecfg.h"     /* seldom changed options */#ifdef __cplusplus
#ifndef DONT_USE_EXTERN_C
extern "C" {#endif
#endif/* Version IDs for the JPEG library.* Might be useful for tests like "#if JPEG_LIB_VERSION >= 90".*/#define JPEG_LIB_VERSION        90  /* Compatibility version 9.0 */
#define JPEG_LIB_VERSION_MAJOR  9
#define JPEG_LIB_VERSION_MINOR  3/* Various constants determining the sizes of things.* All of these are specified by the JPEG standard,* so don't change them if you want to be compatible.*/#define DCTSIZE          8   /* The basic DCT block is 8x8 coefficients */
#define DCTSIZE2        64  /* DCTSIZE squared; # of elements in a block */
#define NUM_QUANT_TBLS      4   /* Quantization tables are numbered 0..3 */
#define NUM_HUFF_TBLS       4   /* Huffman tables are numbered 0..3 */
#define NUM_ARITH_TBLS      16  /* Arith-coding tables are numbered 0..15 */
#define MAX_COMPS_IN_SCAN   4   /* JPEG limit on # of components in one scan */
#define MAX_SAMP_FACTOR     4   /* JPEG limit on sampling factors */
/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;* the PostScript DCT filter can emit files with many more than 10 blocks/MCU.* If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU* to handle it.  We even let you do this from the jconfig.h file.  However,* we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe* sometimes emits noncompliant files doesn't mean you should too.*/
#define C_MAX_BLOCKS_IN_MCU   10 /* compressor's limit on blocks per MCU */
#ifndef D_MAX_BLOCKS_IN_MCU
#define D_MAX_BLOCKS_IN_MCU   10 /* decompressor's limit on blocks per MCU */
#endif/* Data structures for images (arrays of samples and of DCT coefficients).* On 80x86 machines, the image arrays are too big for near pointers,* but the pointer arrays can fit in near memory.*/typedef JSAMPLE FAR *JSAMPROW;    /* ptr to one image row of pixel samples. */
typedef JSAMPROW *JSAMPARRAY;   /* ptr to some rows (a 2-D sample array) */
typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */
typedef JBLOCK FAR *JBLOCKROW;  /* pointer to one row of coefficient blocks */
typedef JBLOCKROW *JBLOCKARRAY;     /* a 2-D array of coefficient blocks */
typedef JBLOCKARRAY *JBLOCKIMAGE;   /* a 3-D array of coefficient blocks */typedef JCOEF FAR *JCOEFPTR; /* useful in a couple of places *//* Types for JPEG compression parameters and working tables. *//* DCT coefficient quantization tables. */typedef struct {/* This array gives the coefficient quantizers in natural array order* (not the zigzag order in which they are stored in a JPEG DQT marker).* CAUTION: IJG versions prior to v6a kept this array in zigzag order.*/UINT16 quantval[DCTSIZE2];    /* quantization step for each coefficient *//* This field is used only during compression.  It's initialized FALSE when* the table is created, and set TRUE when it's been output to the file.* You could suppress output of a table by setting this to TRUE.* (See jpeg_suppress_tables for an example.)*/boolean sent_table;        /* TRUE when table has been output */
} JQUANT_TBL;/* Huffman coding tables. */typedef struct {/* These two fields directly represent the contents of a JPEG DHT marker */UINT8 bits[17];     /* bits[k] = # of symbols with codes of *//* length k bits; bits[0] is unused */UINT8 huffval[256];        /* The symbols, in order of incr code length *//* This field is used only during compression.  It's initialized FALSE when* the table is created, and set TRUE when it's been output to the file.* You could suppress output of a table by setting this to TRUE.* (See jpeg_suppress_tables for an example.)*/boolean sent_table;     /* TRUE when table has been output */
} JHUFF_TBL;/* Basic info about one component (color channel). */typedef struct {/* These values are fixed over the whole image. *//* For compression, they must be supplied by parameter setup; *//* for decompression, they are read from the SOF marker. */int component_id;     /* identifier for this component (0..255) */int component_index;        /* its index in SOF or cinfo->comp_info[] */int h_samp_factor;       /* horizontal sampling factor (1..4) */int v_samp_factor;       /* vertical sampling factor (1..4) */int quant_tbl_no;      /* quantization table selector (0..3) *//* These values may vary between scans. *//* For compression, they must be supplied by parameter setup; *//* for decompression, they are read from the SOS marker. *//* The decompressor output side may not use these variables. */int dc_tbl_no;      /* DC entropy table selector (0..3) */int ac_tbl_no;        /* AC entropy table selector (0..3) *//* Remaining fields should be treated as private by applications. *//* These values are computed during compression or decompression startup: *//* Component's size in DCT blocks.* Any dummy blocks added to complete an MCU are not counted; therefore* these values do not depend on whether a scan is interleaved or not.*/JDIMENSION width_in_blocks;JDIMENSION height_in_blocks;/* Size of a DCT block in samples,* reflecting any scaling we choose to apply during the DCT step.* Values from 1 to 16 are supported.* Note that different components may receive different DCT scalings.*/int DCT_h_scaled_size;int DCT_v_scaled_size;/* The downsampled dimensions are the component's actual, unpadded number* of samples at the main buffer (preprocessing/compression interface);* DCT scaling is included, so* downsampled_width =*   ceil(image_width * Hi/Hmax * DCT_h_scaled_size/block_size)* and similarly for height.*/JDIMENSION downsampled_width;     /* actual width in samples */JDIMENSION downsampled_height; /* actual height in samples *//* For decompression, in cases where some of the components will be* ignored (eg grayscale output from YCbCr image), we can skip most* computations for the unused components.* For compression, some of the components will need further quantization* scale by factor of 2 after DCT (eg BG_YCC output from normal RGB input).* The field is first set TRUE for decompression, FALSE for compression* in initial_setup, and then adapted in color conversion setup.*/boolean component_needed;/* These values are computed before starting a scan of the component. *//* The decompressor output side may not use these variables. */int MCU_width;        /* number of blocks per MCU, horizontally */int MCU_height;     /* number of blocks per MCU, vertically */int MCU_blocks;       /* MCU_width * MCU_height */int MCU_sample_width;   /* MCU width in samples: MCU_width * DCT_h_scaled_size */int last_col_width;        /* # of non-dummy blocks across in last MCU */int last_row_height;      /* # of non-dummy blocks down in last MCU *//* Saved quantization table for component; NULL if none yet saved.* See jdinput.c comments about the need for this information.* This field is currently used only for decompression.*/JQUANT_TBL * quant_table;/* Private per-component storage for DCT or IDCT subsystem. */void * dct_table;
} jpeg_component_info;/* The script for encoding a multiple-scan file is an array of these: */typedef struct {int comps_in_scan;        /* number of components encoded in this scan */int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */int Ss, Se;           /* progressive JPEG spectral selection parms */int Ah, Al;          /* progressive JPEG successive approx. parms */
} jpeg_scan_info;/* The decompressor can save APPn and COM markers in a list of these: */typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr;struct jpeg_marker_struct {jpeg_saved_marker_ptr next;   /* next in list, or NULL */UINT8 marker;            /* marker code: JPEG_COM, or JPEG_APP0+n */unsigned int original_length;   /* # bytes of data in the file */unsigned int data_length;  /* # bytes of data saved at data[] */JOCTET FAR * data;     /* the data contained in the marker *//* the marker length word is not counted in data_length or original_length */
};/* Known color spaces. */typedef enum {JCS_UNKNOWN,       /* error/unspecified */JCS_GRAYSCALE,       /* monochrome */JCS_RGB,        /* red/green/blue, standard RGB (sRGB) */JCS_YCbCr,     /* Y/Cb/Cr (also known as YUV), standard YCC */JCS_CMYK,        /* C/M/Y/K */JCS_YCCK,      /* Y/Cb/Cr/K */JCS_BG_RGB,      /* big gamut red/green/blue, bg-sRGB */JCS_BG_YCC       /* big gamut Y/Cb/Cr, bg-sYCC */
} J_COLOR_SPACE;/* Supported color transforms. */typedef enum {JCT_NONE           = 0,JCT_SUBTRACT_GREEN = 1
} J_COLOR_TRANSFORM;/* DCT/IDCT algorithm options. */typedef enum {JDCT_ISLOW,      /* slow but accurate integer algorithm */JDCT_IFAST,        /* faster, less accurate integer method */JDCT_FLOAT        /* floating-point: accurate, fast on fast HW */
} J_DCT_METHOD;#ifndef JDCT_DEFAULT     /* may be overridden in jconfig.h */
#define JDCT_DEFAULT  JDCT_ISLOW
#endif
#ifndef JDCT_FASTEST        /* may be overridden in jconfig.h */
#define JDCT_FASTEST  JDCT_IFAST
#endif/* Dithering options for decompression. */typedef enum {JDITHER_NONE,     /* no dithering */JDITHER_ORDERED,  /* simple ordered dither */JDITHER_FS       /* Floyd-Steinberg error diffusion dither */
} J_DITHER_MODE;/* Common fields between JPEG compression and decompression master structs. */#define jpeg_common_fields \struct jpeg_error_mgr * err;  /* Error handler module */\struct jpeg_memory_mgr * mem;    /* Memory manager module */\struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\void * client_data;        /* Available for use by application */\boolean is_decompressor; /* So common code can tell which is which */\int global_state       /* For checking call sequence validity *//* Routines that are to be used by both halves of the library are declared* to receive a pointer to this structure.  There are no actual instances of* jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.*/
struct jpeg_common_struct {jpeg_common_fields;      /* Fields common to both master struct types *//* Additional fields follow in an actual jpeg_compress_struct or* jpeg_decompress_struct.  All three structs must agree on these* initial fields!  (This would be a lot cleaner in C++.)*/
};typedef struct jpeg_common_struct * j_common_ptr;
typedef struct jpeg_compress_struct * j_compress_ptr;
typedef struct jpeg_decompress_struct * j_decompress_ptr;/* Master record for a compression instance */struct jpeg_compress_struct {jpeg_common_fields;     /* Fields shared with jpeg_decompress_struct *//* Destination for compressed data */struct jpeg_destination_mgr * dest;/* Description of source image --- these fields must be filled in by* outer application before starting compression.  in_color_space must* be correct before you can even call jpeg_set_defaults().*/JDIMENSION image_width; /* input image width */JDIMENSION image_height; /* input image height */int input_components;       /* # of color components in input image */J_COLOR_SPACE in_color_space; /* colorspace of input image */double input_gamma;      /* image gamma of input image *//* Compression parameters --- these fields must be set before calling* jpeg_start_compress().  We recommend calling jpeg_set_defaults() to* initialize everything to reasonable defaults, then changing anything* the application specifically wants to change.  That way you won't get* burnt when new parameters are added.  Also note that there are several* helper routines to simplify changing parameters.*/unsigned int scale_num, scale_denom; /* fraction by which to scale image */JDIMENSION jpeg_width;   /* scaled JPEG image width */JDIMENSION jpeg_height;    /* scaled JPEG image height *//* Dimensions of actual JPEG image that will be written to file,* derived from input dimensions by scaling factors above.* These fields are computed by jpeg_start_compress().* You can also use jpeg_calc_jpeg_dimensions() to determine these values* in advance of calling jpeg_start_compress().*/int data_precision;     /* bits of precision in image data */int num_components;        /* # of color components in JPEG image */J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */jpeg_component_info * comp_info;/* comp_info[i] describes component that appears i'th in SOF */JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];int q_scale_factor[NUM_QUANT_TBLS];/* ptrs to coefficient quantization tables, or NULL if not defined,* and corresponding scale factors (percentage, initialized 100).*/JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];/* ptrs to Huffman coding tables, or NULL if not defined */UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */int num_scans;      /* # of entries in scan_info array */const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL *//* The default value of scan_info is NULL, which causes a single-scan* sequential JPEG file to be emitted.  To create a multi-scan file,* set num_scans and scan_info to point to an array of scan definitions.*/boolean raw_data_in;       /* TRUE=caller supplies downsampled data */boolean arith_code;     /* TRUE=arithmetic coding, FALSE=Huffman */boolean optimize_coding;   /* TRUE=optimize entropy encoding parms */boolean CCIR601_sampling;    /* TRUE=first samples are cosited */boolean do_fancy_downsampling; /* TRUE=apply fancy downsampling */int smoothing_factor;       /* 1..100, or 0 for no input smoothing */J_DCT_METHOD dct_method;   /* DCT algorithm selector *//* The restart interval can be specified in absolute MCUs by setting* restart_interval, or in MCU rows by setting restart_in_rows* (in which case the correct restart_interval will be figured* for each scan).*/unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */int restart_in_rows;     /* if > 0, MCU rows per restart interval *//* Parameters controlling emission of special markers. */boolean write_JFIF_header;   /* should a JFIF marker be written? */UINT8 JFIF_major_version; /* What to write for the JFIF version number */UINT8 JFIF_minor_version;/* These three values are not used by the JPEG code, merely copied *//* into the JFIF APP0 marker.  density_unit can be 0 for unknown, *//* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect *//* ratio is defined by X_density/Y_density even when density_unit=0. */UINT8 density_unit;        /* JFIF code for pixel size units */UINT16 X_density;       /* Horizontal pixel density */UINT16 Y_density;     /* Vertical pixel density */boolean write_Adobe_marker; /* should an Adobe marker be written? */J_COLOR_TRANSFORM color_transform;/* Color transform identifier, writes LSE marker if nonzero *//* State variable: index of next scanline to be written to* jpeg_write_scanlines().  Application may use this to control its* processing loop, e.g., "while (next_scanline < image_height)".*/JDIMENSION next_scanline;    /* 0 .. image_height-1  *//* Remaining fields are known throughout compressor, but generally* should not be touched by a surrounding application.*//** These fields are computed during compression startup*/boolean progressive_mode;  /* TRUE if scan script uses progressive mode */int max_h_samp_factor;   /* largest h_samp_factor */int max_v_samp_factor;   /* largest v_samp_factor */int min_DCT_h_scaled_size;   /* smallest DCT_h_scaled_size of any component */int min_DCT_v_scaled_size; /* smallest DCT_v_scaled_size of any component */JDIMENSION total_iMCU_rows;    /* # of iMCU rows to be input to coef ctlr *//* The coefficient controller receives data in units of MCU rows as defined* for fully interleaved scans (whether the JPEG file is interleaved or not).* There are v_samp_factor * DCT_v_scaled_size sample rows of each component* in an "iMCU" (interleaved MCU) row.*//** These fields are valid during any one scan.* They describe the components and MCUs actually appearing in the scan.*/int comps_in_scan;      /* # of JPEG components in this scan */jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];/* *cur_comp_info[i] describes component that appears i'th in SOS */JDIMENSION MCUs_per_row; /* # of MCUs across the image */JDIMENSION MCU_rows_in_scan;    /* # of MCU rows in the image */int blocks_in_MCU;      /* # of DCT blocks per MCU */int MCU_membership[C_MAX_BLOCKS_IN_MCU];/* MCU_membership[i] is index in cur_comp_info of component owning *//* i'th block in an MCU */int Ss, Se, Ah, Al;        /* progressive JPEG parameters for scan */int block_size;       /* the basic DCT block size: 1..16 */const int * natural_order; /* natural-order position array */int lim_Se;           /* min( Se, DCTSIZE2-1 ) *//** Links to compression subobjects (methods and private variables of modules)*/struct jpeg_comp_master * master;struct jpeg_c_main_controller * main;struct jpeg_c_prep_controller * prep;struct jpeg_c_coef_controller * coef;struct jpeg_marker_writer * marker;struct jpeg_color_converter * cconvert;struct jpeg_downsampler * downsample;struct jpeg_forward_dct * fdct;struct jpeg_entropy_encoder * entropy;jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */int script_space_size;
};/* Master record for a decompression instance */struct jpeg_decompress_struct {jpeg_common_fields;        /* Fields shared with jpeg_compress_struct *//* Source of compressed data */struct jpeg_source_mgr * src;/* Basic description of image --- filled in by jpeg_read_header(). *//* Application may inspect these values to decide how to process image. */JDIMENSION image_width; /* nominal image width (from SOF marker) */JDIMENSION image_height; /* nominal image height */int num_components;       /* # of color components in JPEG image */J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image *//* Decompression processing parameters --- these fields must be set before* calling jpeg_start_decompress().  Note that jpeg_read_header() initializes* them to default values.*/J_COLOR_SPACE out_color_space; /* colorspace for output */unsigned int scale_num, scale_denom; /* fraction by which to scale image */double output_gamma;       /* image gamma wanted in output */boolean buffered_image;   /* TRUE=multiple output passes */boolean raw_data_out;     /* TRUE=downsampled data wanted */J_DCT_METHOD dct_method; /* IDCT algorithm selector */boolean do_fancy_upsampling;   /* TRUE=apply fancy upsampling */boolean do_block_smoothing;   /* TRUE=apply interblock smoothing */boolean quantize_colors;  /* TRUE=colormapped output wanted *//* the following are ignored if not quantize_colors: */J_DITHER_MODE dither_mode;  /* type of color dithering to use */boolean two_pass_quantize;  /* TRUE=use two-pass color quantization */int desired_number_of_colors;    /* max # colors to use in created colormap *//* these are significant only in buffered-image mode: */boolean enable_1pass_quant;    /* enable future use of 1-pass quantizer */boolean enable_external_quant;/* enable future use of external colormap */boolean enable_2pass_quant;    /* enable future use of 2-pass quantizer *//* Description of actual output image that will be returned to application.* These fields are computed by jpeg_start_decompress().* You can also use jpeg_calc_output_dimensions() to determine these values* in advance of calling jpeg_start_decompress().*/JDIMENSION output_width;   /* scaled image width */JDIMENSION output_height;   /* scaled image height */int out_color_components;  /* # of color components in out_color_space */int output_components;    /* # of color components returned *//* output_components is 1 (a colormap index) when quantizing colors;* otherwise it equals out_color_components.*/int rec_outbuf_height; /* min recommended height of scanline buffer *//* If the buffer passed to jpeg_read_scanlines() is less than this many rows* high, space and time will be wasted due to unnecessary data copying.* Usually rec_outbuf_height will be 1 or 2, at most 4.*//* When quantizing colors, the output colormap is described by these fields.* The application can supply a colormap by setting colormap non-NULL before* calling jpeg_start_decompress; otherwise a colormap is created during* jpeg_start_decompress or jpeg_start_output.* The map has out_color_components rows and actual_number_of_colors columns.*/int actual_number_of_colors;  /* number of entries in use */JSAMPARRAY colormap;      /* The color map as a 2-D pixel array *//* State variables: these variables indicate the progress of decompression.* The application may examine these but must not modify them.*//* Row index of next scanline to be read from jpeg_read_scanlines().* Application may use this to control its processing loop, e.g.,* "while (output_scanline < output_height)".*/JDIMENSION output_scanline;    /* 0 .. output_height-1  *//* Current input scan number and number of iMCU rows completed in scan.* These indicate the progress of the decompressor input side.*/int input_scan_number; /* Number of SOS markers seen so far */JDIMENSION input_iMCU_row;   /* Number of iMCU rows completed *//* The "output scan number" is the notional scan being displayed by the* output side.  The decompressor will not allow output scan/row number* to get ahead of input scan/row, but it can fall arbitrarily far behind.*/int output_scan_number;    /* Nominal scan number being displayed */JDIMENSION output_iMCU_row;    /* Number of iMCU rows read *//* Current progression status.  coef_bits[c][i] indicates the precision* with which component c's DCT coefficient i (in zigzag order) is known.* It is -1 when no data has yet been received, otherwise it is the point* transform (shift) value for the most recent scan of the coefficient* (thus, 0 at completion of the progression).* This pointer is NULL when reading a non-progressive file.*/int (*coef_bits)[DCTSIZE2];    /* -1 or current Al value for each coef *//* Internal JPEG parameters --- the application usually need not look at* these fields.  Note that the decompressor output side may not use* any parameters that can change between scans.*//* Quantization and Huffman tables are carried forward across input* datastreams when processing abbreviated JPEG datastreams.*/JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];/* ptrs to coefficient quantization tables, or NULL if not defined */JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];/* ptrs to Huffman coding tables, or NULL if not defined *//* These parameters are never carried across datastreams, since they* are given in SOF/SOS markers or defined to be reset by SOI.*/int data_precision;        /* bits of precision in image data */jpeg_component_info * comp_info;/* comp_info[i] describes component that appears i'th in SOF */boolean is_baseline;       /* TRUE if Baseline SOF0 encountered */boolean progressive_mode;    /* TRUE if SOFn specifies progressive mode */boolean arith_code;        /* TRUE=arithmetic coding, FALSE=Huffman */UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart *//* These fields record data obtained from optional markers recognized by* the JPEG library.*/boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found *//* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */UINT8 JFIF_major_version;  /* JFIF version number */UINT8 JFIF_minor_version;UINT8 density_unit;       /* JFIF code for pixel size units */UINT16 X_density;       /* Horizontal pixel density */UINT16 Y_density;     /* Vertical pixel density */boolean saw_Adobe_marker;   /* TRUE iff an Adobe APP14 marker was found */UINT8 Adobe_transform;    /* Color transform code from Adobe marker */J_COLOR_TRANSFORM color_transform;/* Color transform identifier derived from LSE marker, otherwise zero */boolean CCIR601_sampling; /* TRUE=first samples are cosited *//* Aside from the specific data retained from APPn markers known to the* library, the uninterpreted contents of any or all APPn and COM markers* can be saved in a list for examination by the application.*/jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers *//* Remaining fields are known throughout decompressor, but generally* should not be touched by a surrounding application.*//** These fields are computed during decompression startup*/int max_h_samp_factor;   /* largest h_samp_factor */int max_v_samp_factor;   /* largest v_samp_factor */int min_DCT_h_scaled_size;   /* smallest DCT_h_scaled_size of any component */int min_DCT_v_scaled_size; /* smallest DCT_v_scaled_size of any component */JDIMENSION total_iMCU_rows;    /* # of iMCU rows in image *//* The coefficient controller's input and output progress is measured in* units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows* in fully interleaved JPEG scans, but are used whether the scan is* interleaved or not.  We define an iMCU row as v_samp_factor DCT block* rows of each component.  Therefore, the IDCT output contains* v_samp_factor * DCT_v_scaled_size sample rows of a component per iMCU row.*/JSAMPLE * sample_range_limit; /* table for fast range-limiting *//** These fields are valid during any one scan.* They describe the components and MCUs actually appearing in the scan.* Note that the decompressor output side must not use these fields.*/int comps_in_scan;       /* # of JPEG components in this scan */jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];/* *cur_comp_info[i] describes component that appears i'th in SOS */JDIMENSION MCUs_per_row; /* # of MCUs across the image */JDIMENSION MCU_rows_in_scan;    /* # of MCU rows in the image */int blocks_in_MCU;      /* # of DCT blocks per MCU */int MCU_membership[D_MAX_BLOCKS_IN_MCU];/* MCU_membership[i] is index in cur_comp_info of component owning *//* i'th block in an MCU */int Ss, Se, Ah, Al;        /* progressive JPEG parameters for scan *//* These fields are derived from Se of first SOS marker.*/int block_size;     /* the basic DCT block size: 1..16 */const int * natural_order; /* natural-order position array for entropy decode */int lim_Se;            /* min( Se, DCTSIZE2-1 ) for entropy decode *//* This field is shared between entropy decoder and marker parser.* It is either zero or the code of a JPEG marker that has been* read from the data source, but has not yet been processed.*/int unread_marker;/** Links to decompression subobjects (methods, private variables of modules)*/struct jpeg_decomp_master * master;struct jpeg_d_main_controller * main;struct jpeg_d_coef_controller * coef;struct jpeg_d_post_controller * post;struct jpeg_input_controller * inputctl;struct jpeg_marker_reader * marker;struct jpeg_entropy_decoder * entropy;struct jpeg_inverse_dct * idct;struct jpeg_upsampler * upsample;struct jpeg_color_deconverter * cconvert;struct jpeg_color_quantizer * cquantize;
};/* "Object" declarations for JPEG modules that may be supplied or called* directly by the surrounding application.* As with all objects in the JPEG library, these structs only define the* publicly visible methods and state variables of a module.  Additional* private fields may exist after the public ones.*//* Error handler object */struct jpeg_error_mgr {/* Error exit handler: does not return to caller */JMETHOD(noreturn_t, error_exit, (j_common_ptr cinfo));/* Conditionally emit a trace or warning message */JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));/* Routine that actually outputs a trace or error message */JMETHOD(void, output_message, (j_common_ptr cinfo));/* Format a message string for the most recent JPEG error or message */JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
#define JMSG_LENGTH_MAX  200    /* recommended size of format_message buffer *//* Reset error state variables at start of a new image */JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));/* The message ID code and any parameters are saved here.* A message can have one string parameter or up to 8 int parameters.*/int msg_code;
#define JMSG_STR_PARM_MAX  80union {int i[8];char s[JMSG_STR_PARM_MAX];} msg_parm;/* Standard state variables for error facility */int trace_level;     /* max msg_level that will be displayed *//* For recoverable corrupt-data errors, we emit a warning message,* but keep going unless emit_message chooses to abort.  emit_message* should count warnings in num_warnings.  The surrounding application* can check for bad data by seeing if num_warnings is nonzero at the* end of processing.*/long num_warnings;       /* number of corrupt-data warnings *//* These fields point to the table(s) of error message strings.* An application can change the table pointer to switch to a different* message list (typically, to change the language in which errors are* reported).  Some applications may wish to add additional error codes* that will be handled by the JPEG library error mechanism; the second* table pointer is used for this purpose.** First table includes all errors generated by JPEG library itself.* Error code 0 is reserved for a "no such error string" message.*/const char * const * jpeg_message_table; /* Library errors */int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message *//* Second table can be added by application (see cjpeg/djpeg for example).* It contains strings numbered first_addon_message..last_addon_message.*/const char * const * addon_message_table; /* Non-library errors */int first_addon_message;   /* code for first string in addon table */int last_addon_message;   /* code for last string in addon table */
};/* Progress monitor object */struct jpeg_progress_mgr {JMETHOD(void, progress_monitor, (j_common_ptr cinfo));long pass_counter;       /* work units completed in this pass */long pass_limit;     /* total number of work units in this pass */int completed_passes;      /* passes completed so far */int total_passes;      /* total number of passes expected */
};/* Data destination object for compression */struct jpeg_destination_mgr {JOCTET * next_output_byte;  /* => next byte to write in buffer */size_t free_in_buffer; /* # of byte spaces remaining in buffer */JMETHOD(void, init_destination, (j_compress_ptr cinfo));JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));JMETHOD(void, term_destination, (j_compress_ptr cinfo));
};/* Data source object for decompression */struct jpeg_source_mgr {const JOCTET * next_input_byte; /* => next byte to read from buffer */size_t bytes_in_buffer;   /* # of bytes remaining in buffer */JMETHOD(void, init_source, (j_decompress_ptr cinfo));JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));JMETHOD(void, term_source, (j_decompress_ptr cinfo));
};/* Memory manager object.* Allocates "small" objects (a few K total), "large" objects (tens of K),* and "really big" objects (virtual arrays with backing store if needed).* The memory manager does not allow individual objects to be freed; rather,* each created object is assigned to a pool, and whole pools can be freed* at once.  This is faster and more convenient than remembering exactly what* to free, especially where malloc()/free() are not too speedy.* NB: alloc routines never return NULL.  They exit to error_exit if not* successful.*/#define JPOOL_PERMANENT 0   /* lasts until master record is destroyed */
#define JPOOL_IMAGE 1   /* lasts until done with image/datastream */
#define JPOOL_NUMPOOLS  2typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
typedef struct jvirt_barray_control * jvirt_barray_ptr;struct jpeg_memory_mgr {/* Method pointers */JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,size_t sizeofobject));JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,size_t sizeofobject));JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,JDIMENSION samplesperrow,JDIMENSION numrows));JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,JDIMENSION blocksperrow,JDIMENSION numrows));JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,int pool_id,boolean pre_zero,JDIMENSION samplesperrow,JDIMENSION numrows,JDIMENSION maxaccess));JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,int pool_id,boolean pre_zero,JDIMENSION blocksperrow,JDIMENSION numrows,JDIMENSION maxaccess));JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,jvirt_sarray_ptr ptr,JDIMENSION start_row,JDIMENSION num_rows,boolean writable));JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,jvirt_barray_ptr ptr,JDIMENSION start_row,JDIMENSION num_rows,boolean writable));JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));JMETHOD(void, self_destruct, (j_common_ptr cinfo));/* Limit on memory allocation for this JPEG object.  (Note that this is* merely advisory, not a guaranteed maximum; it only affects the space* used for virtual-array buffers.)  May be changed by outer application* after creating the JPEG object.*/long max_memory_to_use;/* Maximum allocation request accepted by alloc_large. */long max_alloc_chunk;
};/* Routine signature for application-supplied marker processing methods.* Need not pass marker code since it is stored in cinfo->unread_marker.*/
typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));/* Declarations for routines called by application.* The JPP macro hides prototype parameters from compilers that can't cope.* Note JPP requires double parentheses.*/#ifdef HAVE_PROTOTYPES
#define JPP(arglist)    arglist
#else
#define JPP(arglist)    ()
#endif/* Short forms of external names for systems with brain-damaged linkers.* We shorten external names to be unique in the first six letters, which* is good enough for all known systems.* (If your compiler itself needs names to be unique in less than 15 * characters, you are out of luck.  Get a better compiler.)*/#ifdef NEED_SHORT_EXTERNAL_NAMES
#define jpeg_std_error      jStdError
#define jpeg_CreateCompress jCreaCompress
#define jpeg_CreateDecompress   jCreaDecompress
#define jpeg_destroy_compress   jDestCompress
#define jpeg_destroy_decompress jDestDecompress
#define jpeg_stdio_dest     jStdDest
#define jpeg_stdio_src      jStdSrc
#define jpeg_mem_dest       jMemDest
#define jpeg_mem_src        jMemSrc
#define jpeg_set_defaults   jSetDefaults
#define jpeg_set_colorspace jSetColorspace
#define jpeg_default_colorspace jDefColorspace
#define jpeg_set_quality    jSetQuality
#define jpeg_set_linear_quality jSetLQuality
#define jpeg_default_qtables    jDefQTables
#define jpeg_add_quant_table    jAddQuantTable
#define jpeg_quality_scaling    jQualityScaling
#define jpeg_simple_progression jSimProgress
#define jpeg_suppress_tables    jSuppressTables
#define jpeg_alloc_quant_table  jAlcQTable
#define jpeg_alloc_huff_table   jAlcHTable
#define jpeg_start_compress jStrtCompress
#define jpeg_write_scanlines    jWrtScanlines
#define jpeg_finish_compress    jFinCompress
#define jpeg_calc_jpeg_dimensions   jCjpegDimensions
#define jpeg_write_raw_data jWrtRawData
#define jpeg_write_marker   jWrtMarker
#define jpeg_write_m_header jWrtMHeader
#define jpeg_write_m_byte   jWrtMByte
#define jpeg_write_tables   jWrtTables
#define jpeg_read_header    jReadHeader
#define jpeg_start_decompress   jStrtDecompress
#define jpeg_read_scanlines jReadScanlines
#define jpeg_finish_decompress  jFinDecompress
#define jpeg_read_raw_data  jReadRawData
#define jpeg_has_multiple_scans jHasMultScn
#define jpeg_start_output   jStrtOutput
#define jpeg_finish_output  jFinOutput
#define jpeg_input_complete jInComplete
#define jpeg_new_colormap   jNewCMap
#define jpeg_consume_input  jConsumeInput
#define jpeg_core_output_dimensions jCoreDimensions
#define jpeg_calc_output_dimensions jCalcDimensions
#define jpeg_save_markers   jSaveMarkers
#define jpeg_set_marker_processor   jSetMarker
#define jpeg_read_coefficients  jReadCoefs
#define jpeg_write_coefficients jWrtCoefs
#define jpeg_copy_critical_parameters   jCopyCrit
#define jpeg_abort_compress jAbrtCompress
#define jpeg_abort_decompress   jAbrtDecompress
#define jpeg_abort      jAbort
#define jpeg_destroy        jDestroy
#define jpeg_resync_to_restart  jResyncRestart
#endif /* NEED_SHORT_EXTERNAL_NAMES *//* Default error-management setup */
EXTERN(struct jpeg_error_mgr *) jpeg_std_errorJPP((struct jpeg_error_mgr * err));/* Initialization of JPEG compression objects.* jpeg_create_compress() and jpeg_create_decompress() are the exported* names that applications should call.  These expand to calls on* jpeg_CreateCompress and jpeg_CreateDecompress with additional information* passed for version mismatch checking.* NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.*/
#define jpeg_create_compress(cinfo) \jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \(size_t) sizeof(struct jpeg_compress_struct))
#define jpeg_create_decompress(cinfo) \jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \(size_t) sizeof(struct jpeg_decompress_struct))
EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo,int version, size_t structsize));
EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo,int version, size_t structsize));
/* Destruction of JPEG compression objects */
EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo));
EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));/* Standard data source and destination managers: stdio streams. */
/* Caller is responsible for opening the file before and closing after. */
EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));/* Data source and destination managers: memory buffers. */
EXTERN(void) jpeg_mem_dest JPP((j_compress_ptr cinfo,unsigned char ** outbuffer,unsigned long * outsize));
EXTERN(void) jpeg_mem_src JPP((j_decompress_ptr cinfo,const unsigned char * inbuffer,unsigned long insize));/* Default parameter setup for compression */
EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo));
/* Compression parameter setup aids */
EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo,J_COLOR_SPACE colorspace));
EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo));
EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,boolean force_baseline));
EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo,int scale_factor,boolean force_baseline));
EXTERN(void) jpeg_default_qtables JPP((j_compress_ptr cinfo,boolean force_baseline));
EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,const unsigned int *basic_table,int scale_factor,boolean force_baseline));
EXTERN(int) jpeg_quality_scaling JPP((int quality));
EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo));
EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo,boolean suppress));
EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo));/* Main entry points for compression */
EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,boolean write_all_tables));
EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo,JSAMPARRAY scanlines,JDIMENSION num_lines));
EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo));/* Precalculate JPEG dimensions for current compression parameters. */
EXTERN(void) jpeg_calc_jpeg_dimensions JPP((j_compress_ptr cinfo));/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo,JSAMPIMAGE data,JDIMENSION num_lines));/* Write a special marker.  See libjpeg.txt concerning safe usage. */
EXTERN(void) jpeg_write_markerJPP((j_compress_ptr cinfo, int marker,const JOCTET * dataptr, unsigned int datalen));
/* Same, but piecemeal. */
EXTERN(void) jpeg_write_m_headerJPP((j_compress_ptr cinfo, int marker, unsigned int datalen));
EXTERN(void) jpeg_write_m_byteJPP((j_compress_ptr cinfo, int val));/* Alternate compression function: just write an abbreviated table file */
EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo));/* Decompression startup: read start of JPEG datastream to see what's there */
EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo,boolean require_image));
/* Return value is one of: */
#define JPEG_SUSPENDED      0 /* Suspended due to lack of input data */
#define JPEG_HEADER_OK      1 /* Found valid image datastream */
#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */
/* If you pass require_image = TRUE (normal case), you need not check for* a TABLES_ONLY return code; an abbreviated file will cause an error exit.* JPEG_SUSPENDED is only possible if you use a data source module that can* give a suspension return (the stdio source module doesn't).*//* Main entry points for decompression */
EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo));
EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo,JSAMPARRAY scanlines,JDIMENSION max_lines));
EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo));/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo,JSAMPIMAGE data,JDIMENSION max_lines));/* Additional entry points for buffered-image mode. */
EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo,int scan_number));
EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo));
EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo));
EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo));
EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo));
/* Return value is one of: */
/* #define JPEG_SUSPENDED   0    Suspended due to lack of input data */
#define JPEG_REACHED_SOS    1 /* Reached start of new scan */
#define JPEG_REACHED_EOI    2 /* Reached end of image */
#define JPEG_ROW_COMPLETED  3 /* Completed one iMCU row */
#define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan *//* Precalculate output dimensions for current decompression parameters. */
EXTERN(void) jpeg_core_output_dimensions JPP((j_decompress_ptr cinfo));
EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));/* Control saving of COM and APPn markers into marker_list. */
EXTERN(void) jpeg_save_markersJPP((j_decompress_ptr cinfo, int marker_code,unsigned int length_limit));/* Install a special processing method for COM or APPn markers. */
EXTERN(void) jpeg_set_marker_processorJPP((j_decompress_ptr cinfo, int marker_code,jpeg_marker_parser_method routine));/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo,jvirt_barray_ptr * coef_arrays));
EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,j_compress_ptr dstinfo));/* If you choose to abort compression or decompression before completing* jpeg_finish_(de)compress, then you need to clean up to release memory,* temporary files, etc.  You can just call jpeg_destroy_(de)compress* if you're done with the JPEG object, but if you want to clean it up and* reuse it, call this:*/
EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo));
EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo));/* Generic versions of jpeg_abort and jpeg_destroy that work on either* flavor of JPEG object.  These may be more convenient in some places.*/
EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo));
EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo));/* Default restart-marker-resync procedure for use by data source modules */
EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,int desired));/* These marker codes are exported since applications and data source modules* are likely to want to use them.*/#define JPEG_RST0  0xD0    /* RST0 marker code */
#define JPEG_EOI    0xD9    /* EOI marker code */
#define JPEG_APP0   0xE0    /* APP0 marker code */
#define JPEG_COM    0xFE    /* COM marker code *//* If we have a brain-damaged compiler that emits warnings (or worse, errors)* for structure definitions that are never filled in, keep it quiet by* supplying dummy definitions for the various substructures.*/#ifdef INCOMPLETE_TYPES_BROKEN
#ifndef JPEG_INTERNALS      /* will be defined in jpegint.h */
struct jvirt_sarray_control { long dummy; };
struct jvirt_barray_control { long dummy; };
struct jpeg_comp_master { long dummy; };
struct jpeg_c_main_controller { long dummy; };
struct jpeg_c_prep_controller { long dummy; };
struct jpeg_c_coef_controller { long dummy; };
struct jpeg_marker_writer { long dummy; };
struct jpeg_color_converter { long dummy; };
struct jpeg_downsampler { long dummy; };
struct jpeg_forward_dct { long dummy; };
struct jpeg_entropy_encoder { long dummy; };
struct jpeg_decomp_master { long dummy; };
struct jpeg_d_main_controller { long dummy; };
struct jpeg_d_coef_controller { long dummy; };
struct jpeg_d_post_controller { long dummy; };
struct jpeg_input_controller { long dummy; };
struct jpeg_marker_reader { long dummy; };
struct jpeg_entropy_decoder { long dummy; };
struct jpeg_inverse_dct { long dummy; };
struct jpeg_upsampler { long dummy; };
struct jpeg_color_deconverter { long dummy; };
struct jpeg_color_quantizer { long dummy; };
#endif /* JPEG_INTERNALS */
#endif /* INCOMPLETE_TYPES_BROKEN *//** The JPEG library modules define JPEG_INTERNALS before including this file.* The internal structure declarations are read only when that is true.* Applications using the library should not include jpegint.h, but may wish* to include jerror.h.*/#ifdef JPEG_INTERNALS
#include "jpegint.h"      /* fetch private declarations */
#include "jerror.h"       /* fetch error codes too */
#endif#ifdef __cplusplus
#ifndef DONT_USE_EXTERN_C
}
#endif
#endif#endif /* JPEGLIB_H */

display_jpeg.c

#include <stdio.h>
#include <setjmp.h>
#include <stdlib.h>
#include <jpeglib.h>
#include <jerror.h>extern JSAMPLE * image_buffer; /* Points to large array of R,G,B-order data */
extern int image_height;    /* Number of rows in image */
extern int image_width;     /* Number of columns in image */struct my_error_mgr {struct jpeg_error_mgr pub;    /* "public" fields */jmp_buf setjmp_buffer;        /* for return to caller */
};typedef struct my_error_mgr * my_error_ptr;METHODDEF(void)
my_error_exit (j_common_ptr cinfo)
{/* cinfo->err really points to a my_error_mgr struct, so coerce pointer */my_error_ptr myerr = (my_error_ptr) cinfo->err;/* Always display the message. *//* We could postpone this until after returning, if we chose. */(*cinfo->err->output_message) (cinfo);/* Return control to the setjmp point */longjmp(myerr->setjmp_buffer, 1);
}int display_format_jpeg(const char *filename, unsigned int x_s, unsigned int y_s, unsigned int *lcd_buf_ptr)
{struct jpeg_decompress_struct cinfo;struct my_error_mgr jerr;FILE * infile;        /* source file */int row_stride;        /* physical row width in output buffer */if((infile = fopen(filename, "rb")) == NULL) {fprintf(stderr, "can't open %s\n", filename);return 0;}cinfo.err = jpeg_std_error(&jerr.pub);jerr.pub.error_exit = my_error_exit;if(setjmp(jerr.setjmp_buffer)) {    jpeg_destroy_decompress(&cinfo);fclose(infile);return 0;}jpeg_create_decompress(&cinfo);jpeg_stdio_src(&cinfo, infile);jpeg_read_header(&cinfo, TRUE);jpeg_start_decompress(&cinfo);row_stride = cinfo.output_width * cinfo.output_components;char *buffer;      /* Output row buffer */buffer =(char *)(*cinfo.mem->alloc_sarray)((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);unsigned int x, y = y_s;unsigned int color;char *buf_save = buffer;while(cinfo.output_scanline < cinfo.output_height) {    buffer = buf_save;jpeg_read_scanlines(&cinfo, (JSAMPARRAY)&buffer, 1);for(x=x_s; x<x_s+cinfo.output_width; x++){color = buffer[0]<<16 | buffer[1]<<8 |buffer[2];lcd_display_point(x, y, color, lcd_buf_ptr);buffer+=3;}y++;}jpeg_finish_decompress(&cinfo);jpeg_destroy_decompress(&cinfo);fclose(infile);return 1;
}

lcd.c

#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define FB_SIZE 800*480*4void lcd_display_point(unsigned int x, unsigned int y, unsigned int color, unsigned int *lcd_fb_ptr)
{*(lcd_fb_ptr+800*y+x) = color;
}int open_lcd_device(unsigned int **lcd_fb_ptr)
{int lcd_fd;lcd_fd = open("/dev/fb0", O_RDWR);if(lcd_fd == -1){perror("open lcd device failed\n");return -1;}*lcd_fb_ptr = mmap( NULL, FB_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, lcd_fd, 0);if(*lcd_fb_ptr == MAP_FAILED){perror("map lcd_fb error\n");return -1;}return lcd_fd;
}int close_lcd_device(int lcd_fd, unsigned int *lcd_fb_ptr)
{munmap(lcd_fb_ptr, FB_SIZE);return close(lcd_fd);
}

测试

#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <setjmp.h>
#include <stdlib.h>
#include <jpeglib.h>
#include <jerror.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>int *p=NULL;
int pingmu_init()
{int fd;fd = open("/dev/fb0",O_RDWR);if (-1 == fd){perror("LCD打开失败");return -1;}p = mmap(NULL,   //代表映射的空间地址由程序进行分配800*480*4, //代表要映射的空间大小为800*480*4个字节PROT_WRITE|PROT_READ,//代表这块映射后的内存空间的读写权限MAP_SHARED,//代表这个映射后的看空间其他程序也可以使用fd,         //要映射的文件的文件描述符0);           //代表不要跳过源文件的任何一个字节if (p==MAP_FAILED){perror("打开失败");}
}int main(int argc, char const *argv[])
{pingmu_init();display_format_jpeg(argv[1],0,0,p);return 0;
}

Linux-JPEG格式图片显示相关推荐

Freemarker下载Word文档(文字+图片+表格)Idea示例 (附word展示图片异常解决方案)(附JPEG格式图片通过imageio.read方法读取为null解决方案)
流程:拿到word模板转为ftl格式并填充占位符参数,调用java代码填充参数即可 (文末附word打开图片显示异常,wps打开却显示正常的解决方案) (文末附Jpeg格式图片获取为null解决方案 ...
Python实现base64编码文件转化为jpg/png/jpeg/格式图片
Python实现base64编码文件转化为jpg/png/jpeg/格式图片这个base64文件是图片转化的才行,不是随便找个base64文件都行的 base64图片文件qiaoba.py /9j/ ...
C++实现JPEG格式图片解析（附代码）
在网上看了好多解析JPEG图片的文章,多多少少都有问题,下面是我参考过的文章链接: 首先,解析的步骤 1.读取文件的信息 2.Huffman编码解码 3.直流交流编码解析然而,读取多少个8×8矩阵才 ...
使IE浏览器支持webp格式图片显示
webp是一种图像压缩格式,由谷歌推出,开源免费.webp格式图片具有很多优势,相比于传统的png.jpg等在同等图像质量下面,它的图像占有空间更少,因此,可以广泛用于各种对存储空间要求较高的场景中, ...
点击/拖拽两种方式，预览并上传png/jpg/jpeg格式图片
<template><div class="content"><div class="PictureBox"><img ...
QT5开发及实例学习之十八显示Qt5 SVG格式图片
SVG 的英文全称是 Scalable Vector Graphics,即可缩放的矢量图形.它是由万维网络联盟 ( World Wide Web Consortium, W3C ) 在 2000 ...
将BMP 格式图片转换为 JPEG 格式【c语言】
源码链接: https://blog.csdn.net/qq_44394952/article/details/122587475?spm=1001.2014.3001.5502. 一.任务及目标利 ...
【正点原子I.MX6U-MINI应用篇】5、嵌入式Linux在LCD上显示BMP、JPG、PNG图片
一.BMP图像介绍与显示我们常用的图片格式有很多,一般最常用的有三种:JPEG(或 JPG).PNG.BMP和GIF.其中 JPEG(或JPG).PNG以及 BMP 都是静态图片,而 GIF 则可以 ...
Linux应用开发-LCD显示BMP图片
1. 前言 BMP是一种与硬件设备无关的图像文件格式,是Windows环境中交换与图有关的数据的一种标准,在Windows环境中运行的图形图像软件都支持BMP图像格式.BMP格式的图片存放的就是原始的 ...

Linux-JPEG格式图片显示

Linux-JPEG格式图片显示相关推荐

最新文章

热门文章