开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
ijl.h
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：53k
源码类别：

游戏

开发平台：

Visual C++

ijl.h：源码内容
  1. /*M*
  2. //
  3. //
  4. //               INTEL CORPORATION PROPRIETARY INFORMATION
  5. //  This software is supplied under the terms of a license agreement or
  6. //  nondisclosure agreement with Intel Corporation and may not be copied
  7. //  or disclosed except in accordance with the terms of that agreement.
  8. //        Copyright (c) 1998 Intel Corporation. All Rights Reserved.
  9. //
  10. //
  11. //  File:
  12. //    ijl.h
  13. //
  14. //  Purpose:
  15. //    IJL Common Header File
  16. //    This file contains:  definitions for data types, data
  17. //    structures, error codes, and function prototypes used
  18. //    in the Intel(R) JPEG Library (IJL).
  19. //
  20. //  Version:
  21. //    1.5
  22. //
  23. *M*/
  25. #ifndef __IJL_H__
  26. #define __IJL_H__
  29. #if defined( __cplusplus )
  30. extern "C" {
  31. #endif
  34. #ifndef IJL_ALL_WARNINGS
  36. #if _MSC_VER >= 1000
  38. /* nonstandard extension used : nameless struct/union          */
  39. #pragma warning(disable : 4201)
  40. /* nonstandard extension used : bit field types other than int */
  41. #pragma warning(disable : 4214)
  42. /* unreferenced inline function has been removed               */
  43. #pragma warning(disable : 4514)
  44. /* named type definition in parentheses                        */
  45. #pragma warning(disable : 4115)
  47. #endif /* _MSC_VER >= 1000 */
  49. #endif /* IJL_ALL_WARNINGS */
  52. #define IJL_STDCALL __stdcall
  55. /* align struct on 8 bytes boundary */
  56. #pragma pack (8)
  59. /* /////////////////////////////////////////////////////////////////////////
  60. // Macros/Constants */
  62. /* Size of file I/O buffer (4K). */
  63. #define JBUFSIZE    4096
  66. #define IJL_INT64  __int64
  67. #define IJL_UINT64 unsigned IJL_INT64
  70. #ifndef IJLAPI
  71.   #ifdef IJL_MSEXPORTS
  72.     #define IJLAPI(type,name,arg) 
  73.       extern __declspec(dllimport) type IJL_STDCALL name arg
  74.   #else
  75.     #define IJLAPI(type,name,arg) 
  76.       extern type IJL_STDCALL name arg
  77.   #endif
  78. #endif
  82. #define IJL_DIB_ALIGN (sizeof(int) - 1)
  84. #define IJL_DIB_UWIDTH(width,nchannels) 
  85.   ((width) * (nchannels))
  87. #define IJL_DIB_AWIDTH(width,nchannels) 
  88.   ( ((IJL_DIB_UWIDTH(width,nchannels) + IJL_DIB_ALIGN) & (~IJL_DIB_ALIGN)) )
  90. #define IJL_DIB_PAD_BYTES(width,nchannels) 
  91.   ( IJL_DIB_AWIDTH(width,nchannels) - IJL_DIB_UWIDTH(width,nchannels) )
  94. #define IJL_DIB_SCALE_SIZE(jpgsize,scale) 
  95.   ( ((jpgsize) + (scale) - 1) / (scale) )
  100. /*D*
  101. ////////////////////////////////////////////////////////////////////////////
  102. // Name:        IJLibVersion
  103. //
  104. // Purpose:     Stores library version info.
  105. //
  106. // Context:
  107. //
  108. // Example:
  109. //   major           - 1
  110. //   minor           - 0
  111. //   build           - 1
  112. //   Name            - "ijl10.dll"
  113. //   Version         - "1.0.1 Beta1"
  114. //   InternalVersion - "1.0.1.1"
  115. //   BuildDate       - "Sep 22 1998"
  116. //   CallConv        - "DLL"
  117. //
  118. ////////////////////////////////////////////////////////////////////////////
  119. *D*/
  121. typedef struct _IJLibVersion
  122. {
  123.   int         major;
  124.   int         minor;
  125.   int         build;
  126.   const char* Name;
  127.   const char* Version;
  128.   const char* InternalVersion;
  129.   const char* BuildDate;
  130.   const char* CallConv;
  132. } IJLibVersion;
  135. /*D*
  136. ////////////////////////////////////////////////////////////////////////////
  137. // Name:        IJL_RECT
  138. //
  139. // Purpose:     Keep coordinates for rectangle region of image
  140. //
  141. // Context:     Used to specify roi
  142. //
  143. // Fields:
  144. //
  145. ////////////////////////////////////////////////////////////////////////////
  146. *D*/
  148. typedef struct _IJL_RECT
  149. {
  150.   long  left;
  151.   long  top;
  152.   long  right;
  153.   long  bottom;
  155. } IJL_RECT;
  158. /*D*
  159. ////////////////////////////////////////////////////////////////////////////
  160. // Name:        IJL_HANDLE
  161. //
  162. // Purpose:     file handle
  163. //
  164. // Context:     used internally
  165. //
  166. // Fields:
  167. //
  168. ////////////////////////////////////////////////////////////////////////////
  169. *D*/
  171. typedef void* IJL_HANDLE;
  174. /*D*
  175. ////////////////////////////////////////////////////////////////////////////
  176. // Name:        IJLIOTYPE
  177. //
  178. // Purpose:     Possible types of data read/write/other operations to be
  179. //              performed by the functions IJL_Read and IJL_Write.
  180. //
  181. //              See the Developer's Guide for details on appropriate usage.
  182. //
  183. // Fields:
  184. //
  185. //  IJL_JFILE_XXXXXXX   Indicates JPEG data in a stdio file.
  186. //
  187. //  IJL_JBUFF_XXXXXXX   Indicates JPEG data in an addressable buffer.
  188. //
  189. ////////////////////////////////////////////////////////////////////////////
  190. *D*/
  192. typedef enum _IJLIOTYPE
  193. {
  194.   IJL_SETUP                   = -1,
  197.   /* Read JPEG parameters (i.e., height, width, channels, sampling, etc.) */
  198.   /* from a JPEG bit stream. */
  199.   IJL_JFILE_READPARAMS        =  0,
  200.   IJL_JBUFF_READPARAMS        =  1,
  202.   /* Read a JPEG Interchange Format image. */
  203.   IJL_JFILE_READWHOLEIMAGE    =  2,
  204.   IJL_JBUFF_READWHOLEIMAGE    =  3,
  206.   /* Read JPEG tables from a JPEG Abbreviated Format bit stream. */
  207.   IJL_JFILE_READHEADER        =  4,
  208.   IJL_JBUFF_READHEADER        =  5,
  210.   /* Read image info from a JPEG Abbreviated Format bit stream. */
  211.   IJL_JFILE_READENTROPY       =  6,
  212.   IJL_JBUFF_READENTROPY       =  7,
  214.   /* Write an entire JFIF bit stream. */
  215.   IJL_JFILE_WRITEWHOLEIMAGE   =  8,
  216.   IJL_JBUFF_WRITEWHOLEIMAGE   =  9,
  218.   /* Write a JPEG Abbreviated Format bit stream. */
  219.   IJL_JFILE_WRITEHEADER       = 10,
  220.   IJL_JBUFF_WRITEHEADER       = 11,
  222.   /* Write image info to a JPEG Abbreviated Format bit stream. */
  223.   IJL_JFILE_WRITEENTROPY      = 12,
  224.   IJL_JBUFF_WRITEENTROPY      = 13,
  227.   /* Scaled Decoding Options: */
  229.   /* Reads a JPEG image scaled to 1/2 size. */
  230.   IJL_JFILE_READONEHALF       = 14,
  231.   IJL_JBUFF_READONEHALF       = 15,
  233.   /* Reads a JPEG image scaled to 1/4 size. */
  234.   IJL_JFILE_READONEQUARTER    = 16,
  235.   IJL_JBUFF_READONEQUARTER    = 17,
  237.   /* Reads a JPEG image scaled to 1/8 size. */
  238.   IJL_JFILE_READONEEIGHTH     = 18,
  239.   IJL_JBUFF_READONEEIGHTH     = 19,
  241.   /* Reads an embedded thumbnail from a JFIF bit stream. */
  242.   IJL_JFILE_READTHUMBNAIL     = 20,
  243.   IJL_JBUFF_READTHUMBNAIL     = 21
  245. } IJLIOTYPE;
  248. /*D*
  249. ////////////////////////////////////////////////////////////////////////////
  250. // Name:        IJL_COLOR
  251. //
  252. // Purpose:     Possible color space formats.
  253. //
  254. //              Note these formats do *not* necessarily denote
  255. //              the number of channels in the color space.
  256. //              There exists separate "channel" fields in the
  257. //              JPEG_CORE_PROPERTIES data structure specifically
  258. //              for indicating the number of channels in the
  259. //              JPEG and/or DIB color spaces.
  260. //
  261. //              See the Developer's Guide for details on appropriate usage.
  262. //
  263. ////////////////////////////////////////////////////////////////////////////
  264. *D*/
  266. typedef enum _IJL_COLOR
  267. {
  268.   IJL_RGB         = 1,    /* Red-Green-Blue color space. */
  269.   IJL_BGR         = 2,    /* Reversed channel ordering from IJL_RGB. */
  270.   IJL_YCBCR       = 3,    /* Luminance-Chrominance color space as defined */
  271.                           /* by CCIR Recommendation 601. */
  272.   IJL_G           = 4,    /* Grayscale color space. */
  273.   IJL_RGBA_FPX    = 5,    /* FlashPix RGB 4 channel color space that */
  274.                           /* has pre-multiplied opacity. */
  275.   IJL_YCBCRA_FPX  = 6,    /* FlashPix YCbCr 4 channel color space that */
  276.                           /* has pre-multiplied opacity. */
  278.   IJL_OTHER       = 255   /* Some other color space not defined by the IJL. */
  279.                           /* (This means no color space conversion will */
  280.                           /* be done by the IJL.) */
  282. } IJL_COLOR;
  285. /*D*
  286. ////////////////////////////////////////////////////////////////////////////
  287. // Name:        IJL_JPGSUBSAMPLING
  288. //
  289. // Purpose:     Possible subsampling formats used in the JPEG.
  290. //
  291. //              See the Developer's Guide for details on appropriate usage.
  292. //
  293. ////////////////////////////////////////////////////////////////////////////
  294. *D*/
  296. typedef enum _IJL_JPGSUBSAMPLING
  297. {
  298.   IJL_NONE    = 0,    /* Corresponds to "No Subsampling". */
  299.                       /* Valid on a JPEG w/ any number of channels. */
  300.   IJL_411     = 1,    /* Valid on a JPEG w/ 3 channels. */
  301.   IJL_422     = 2,    /* Valid on a JPEG w/ 3 channels. */
  303.   IJL_4114    = 3,    /* Valid on a JPEG w/ 4 channels. */
  304.   IJL_4224    = 4     /* Valid on a JPEG w/ 4 channels. */
  306. } IJL_JPGSUBSAMPLING;
  309. /*D*
  310. ////////////////////////////////////////////////////////////////////////////
  311. // Name:        IJL_DIBSUBSAMPLING
  312. //
  313. // Purpose:     Possible subsampling formats used in the DIB.
  314. //
  315. //              See the Developer's Guide for details on appropriate usage.
  316. //
  317. ////////////////////////////////////////////////////////////////////////////
  318. *D*/
  320. typedef IJL_JPGSUBSAMPLING IJL_DIBSUBSAMPLING;
  323. /*D*
  324. ////////////////////////////////////////////////////////////////////////////
  325. // Name:        HUFFMAN_TABLE
  326. //
  327. // Purpose:     Stores Huffman table information in a fast-to-use format.
  328. //
  329. // Context:     Used by Huffman encoder/decoder to access Huffman table
  330. //              data.  Raw Huffman tables are formatted to fit this
  331. //              structure prior to use.
  332. //
  333. // Fields:
  334. //  huff_class  0 == DC Huffman or lossless table, 1 == AC table.
  335. //  ident       Huffman table identifier, 0-3 valid (Extended Baseline).
  336. //  huffelem    Huffman elements for codes <= 8 bits long;
  337. //              contains both zero run-length and symbol length in bits.
  338. //  huffval     Huffman values for codes 9-16 bits in length.
  339. //  mincode     Smallest Huffman code of length n.
  340. //  maxcode     Largest Huffman code of length n.
  341. //  valptr      Starting index into huffval[] for symbols of length k.
  342. //
  343. ////////////////////////////////////////////////////////////////////////////
  344. *D*/
  346. typedef struct _HUFFMAN_TABLE
  347. {
  348.   int             huff_class;
  349.   int             ident;
  350.   unsigned int    huffelem[256];
  351.   unsigned short  huffval[256];
  352.   unsigned short  mincode[17];
  353.   short           maxcode[18];
  354.   unsigned short  valptr[17];
  356. } HUFFMAN_TABLE;
  359. /*D*
  360. ////////////////////////////////////////////////////////////////////////////
  361. // Name:        JPEGHuffTable
  362. //
  363. // Purpose:     Stores pointers to JPEG-binary spec compliant
  364. //              Huffman table information.
  365. //
  366. // Context:     Used by interface and table methods to specify encoder
  367. //              tables to generate and store JPEG images.
  368. //
  369. // Fields:
  370. //  bits        Points to number of codes of length i (<=16 supported).
  371. //  vals        Value associated with each Huffman code.
  372. //  hclass      0 == DC table, 1 == AC table.
  373. //  ident       Specifies the identifier for this table.
  374. //              0-3 for extended JPEG compliance.
  375. //
  376. ////////////////////////////////////////////////////////////////////////////
  377. *D*/
  379. typedef struct _JPEGHuffTable
  380. {
  381.   unsigned char* bits;
  382.   unsigned char* vals;
  383.   unsigned char  hclass;
  384.   unsigned char  ident;
  386. } JPEGHuffTable;
  389. /*D*
  390. ////////////////////////////////////////////////////////////////////////////
  391. // Name:        QUANT_TABLE
  392. //
  393. // Purpose:     Stores quantization table information in a
  394. //              fast-to-use format.
  395. //
  396. // Context:     Used by quantizer/dequantizer to store formatted
  397. //              quantization tables.
  398. //
  399. // Fields:
  400. //  precision   0 => elements contains 8-bit elements,
  401. //              1 => elements contains 16-bit elements.
  402. //  ident       Table identifier (0-3).
  403. //  elements    Pointer to 64 table elements + 16 extra elements to catch
  404. //              input data errors that may cause malfunction of the
  405. //              Huffman decoder.
  406. //  elarray     Space for elements (see above) plus 8 bytes to align
  407. //              to a quadword boundary.
  408. //
  409. ////////////////////////////////////////////////////////////////////////////
  410. *D*/
  412. typedef struct _QUANT_TABLE
  413. {
  414.   int    precision;
  415.   int    ident;
  416.   short* elements;
  417.   short  elarray [84];
  419. } QUANT_TABLE;
  422. /*D*
  423. ////////////////////////////////////////////////////////////////////////////
  424. // Name:        JPEGQuantTable
  425. //
  426. // Purpose:     Stores pointers to JPEG binary spec compliant
  427. //              quantization table information.
  428. //
  429. // Context:     Used by interface and table methods to specify encoder
  430. //              tables to generate and store JPEG images.
  431. //
  432. // Fields:
  433. //  quantizer   Zig-zag order elements specifying quantization factors.
  434. //  ident       Specifies identifier for this table.
  435. //              0-3 valid for Extended Baseline JPEG compliance.
  436. //
  437. ////////////////////////////////////////////////////////////////////////////
  438. *D*/
  440. typedef struct _JPEGQuantTable
  441. {
  442.   unsigned char* quantizer;
  443.   unsigned char  ident;
  445. } JPEGQuantTable;
  448. /*D*
  449. ////////////////////////////////////////////////////////////////////////////
  450. // Name:        FRAME_COMPONENT
  451. //
  452. // Purpose:     One frame-component structure is allocated per component
  453. //              in a frame.
  454. //
  455. // Context:     Used by Huffman decoder to manage components.
  456. //
  457. // Fields:
  458. //  ident       Component identifier.  The tables use this ident to
  459. //              determine the correct table for each component.
  460. //  hsampling   Horizontal subsampling factor for this component,
  461. //              1-4 are legal.
  462. //  vsampling   Vertical subsampling factor for this component,
  463. //              1-4 are legal.
  464. //  quant_sel   Quantization table selector.  The quantization table
  465. //              used by this component is determined via this selector.
  466. //
  467. ////////////////////////////////////////////////////////////////////////////
  468. *D*/
  470. typedef struct _FRAME_COMPONENT
  471. {
  472.   int ident;
  473.   int hsampling;
  474.   int vsampling;
  475.   int quant_sel;
  477. } FRAME_COMPONENT;
  480. /*D*
  481. ////////////////////////////////////////////////////////////////////////////
  482. // Name:        FRAME
  483. //
  484. // Purpose:     Stores frame-specific data.
  485. //
  486. // Context:     One Frame structure per image.
  487. //
  488. // Fields:
  489. //  precision       Sample precision in bits.
  490. //  width           Width of the source image in pixels.
  491. //  height          Height of the source image in pixels.
  492. //  MCUheight       Height of a frame MCU.
  493. //  MCUwidth        Width of a frame MCU.
  494. //  max_hsampling   Max horiz sampling ratio of any component in the frame.
  495. //  max_vsampling   Max vert sampling ratio of any component in the frame.
  496. //  ncomps          Number of components/channels in the frame.
  497. //  horMCU          Number of horizontal MCUs in the frame.
  498. //  totalMCU        Total number of MCUs in the frame.
  499. //  comps           Array of 'ncomps' component descriptors.
  500. //  restart_interv  Indicates number of MCUs after which to restart the
  501. //                  entropy parameters.
  502. //  SeenAllDCScans  Used when decoding Multiscan images to determine if
  503. //                  all channels of an image have been decoded.
  504. //  SeenAllACScans  (See SeenAllDCScans)
  505. //
  506. ////////////////////////////////////////////////////////////////////////////
  507. *D*/
  509. typedef struct _FRAME
  510. {
  511.   int              precision;
  512.   int              width;
  513.   int              height;
  514.   int              MCUheight;
  515.   int              MCUwidth;
  516.   int              max_hsampling;
  517.   int              max_vsampling;
  518.   int              ncomps;
  519.   int              horMCU;
  520.   long             totalMCU;
  521.   FRAME_COMPONENT* comps;
  522.   int              restart_interv;
  523.   int              SeenAllDCScans;
  524.   int              SeenAllACScans;
  526. } FRAME;
  529. /*D*
  530. ////////////////////////////////////////////////////////////////////////////
  531. // Name:        SCAN_COMPONENT
  532. //
  533. // Purpose:     One scan-component structure is allocated per component
  534. //              of each scan in a frame.
  535. //
  536. // Context:     Used by Huffman decoder to manage components within scans.
  537. //
  538. // Fields:
  539. //  comp        Component number, index to the comps member of FRAME.
  540. //  hsampling   Horizontal sampling factor.
  541. //  vsampling   Vertical sampling factor.
  542. //  dc_table    DC Huffman table pointer for this scan.
  543. //  ac_table    AC Huffman table pointer for this scan.
  544. //  quant_table Quantization table pointer for this scan.
  545. //
  546. ////////////////////////////////////////////////////////////////////////////
  547. *D*/
  549. typedef struct _SCAN_COMPONENT
  550. {
  551.   int            comp;
  552.   int            hsampling;
  553.   int            vsampling;
  554.   HUFFMAN_TABLE* dc_table;
  555.   HUFFMAN_TABLE* ac_table;
  556.   QUANT_TABLE*   quant_table;
  558. } SCAN_COMPONENT;
  561. /*D*
  562. ////////////////////////////////////////////////////////////////////////////
  563. // Name:        SCAN
  564. //
  565. // Purpose:     One SCAN structure is allocated per scan in a frame.
  566. //
  567. // Context:     Used by Huffman decoder to manage scans.
  568. //
  569. // Fields:
  570. //  ncomps          Number of image components in a scan, 1-4 legal.
  571. //  gray_scale      If TRUE, decode only the Y channel.
  572. //  start_spec      Start coefficient of spectral or predictor selector.
  573. //  end_spec        End coefficient of spectral selector.
  574. //  approx_high     High bit position in successive approximation
  575. //                  Progressive coding.
  576. //  approx_low      Low bit position in successive approximation
  577. //                  Progressive coding.
  578. //  restart_interv  Restart interval, 0 if disabled.
  579. //  curxMCU         Next horizontal MCU index to be processed after
  580. //                  an interrupted SCAN.
  581. //  curyMCU         Next vertical MCU index to be processed after
  582. //                  an interrupted SCAN.
  583. //  dc_diff         Array of DC predictor values for DPCM modes.
  584. //  comps           Array of ncomps SCAN_COMPONENT component identifiers.
  585. //
  586. ////////////////////////////////////////////////////////////////////////////
  587. *D*/
  589. typedef struct _SCAN
  590. {
  591.   int             ncomps;
  592.   int             gray_scale;
  593.   int             start_spec;
  594.   int             end_spec;
  595.   int             approx_high;
  596.   int             approx_low;
  597.   unsigned int    restart_interv;
  598.   int             curxMCU;
  599.   int             curyMCU;
  600.   int             dc_diff[4];
  601.   SCAN_COMPONENT* comps;
  603. } SCAN;
  606. /*D*
  607. ////////////////////////////////////////////////////////////////////////////
  608. // Name:        DCTTYPE
  609. //
  610. // Purpose:     Possible algorithms to be used to perform the discrete
  611. //              cosine transform (DCT).
  612. //
  613. // Fields:
  614. //  IJL_AAN     The AAN (Arai, Agui, and Nakajima) algorithm from
  615. //              Trans. IEICE, vol. E 71(11), 1095-1097, Nov. 1988.
  616. //  IJL_IPP     The modified K. R. Rao and P. Yip algorithm from
  617. //              Intel Performance Primitives Library
  618. //
  619. ////////////////////////////////////////////////////////////////////////////
  620. *D*/
  622. typedef enum _DCTTYPE
  623. {
  624.   IJL_AAN = 0,
  625.   IJL_IPP = 1
  627. } DCTTYPE;
  630. /*D*
  631. ////////////////////////////////////////////////////////////////////////////
  632. // Name:        UPSAMPLING_TYPE
  633. //
  634. // Purpose:            -  Possible algorithms to be used to perform upsampling
  635. //
  636. // Fields:
  637. //  IJL_BOX_FILTER      - the algorithm is simple replication of the input pixel
  638. //                        onto the corresponding output pixels (box filter);
  639. //  IJL_TRIANGLE_FILTER - 3/4 * nearer pixel + 1/4 * further pixel in each
  640. //                        dimension
  641. ////////////////////////////////////////////////////////////////////////////
  642. *D*/
  644. typedef enum _UPSAMPLING_TYPE
  645. {
  646.   IJL_BOX_FILTER      = 0,
  647.   IJL_TRIANGLE_FILTER = 1
  649. } UPSAMPLING_TYPE;
  652. /*D*
  653. ////////////////////////////////////////////////////////////////////////////
  654. // Name:        SAMPLING_STATE
  655. //
  656. // Purpose:     Stores current conditions of sampling. Only for upsampling 
  657. //              with triangle filter is used now.
  658. //
  659. // Fields:
  660. //  top_row        - pointer to buffer with MCUs, that are located above than
  661. //                   current row of MCUs;
  662. //  cur_row        - pointer to buffer with current row of MCUs;
  663. //  bottom_row     - pointer to buffer with MCUs, that are located below than
  664. //                   current row of MCUs;
  665. //  last_row       - pointer to bottom boundary of last row of MCUs
  666. //  cur_row_number - number of row of MCUs, that is decoding;
  667. //  user_interrupt - field to store jprops->interrupt, because of we prohibit 
  668. //                   interrupts while top row of MCUs is upsampling.
  669. ////////////////////////////////////////////////////////////////////////////
  670. *D*/
  672. typedef struct _SAMPLING_STATE
  673. {
  674.   short* top_row;
  675.   short* cur_row;
  676.   short* bottom_row;
  677.   short* last_row;
  678.   int    cur_row_number;
  680. } SAMPLING_STATE;
  683. /*D*
  684. ////////////////////////////////////////////////////////////////////////////
  685. // Name:        PROCESSOR_TYPE
  686. //
  687. // Purpose:     Possible types of processors.
  688. //              Note that the enums are defined in ascending order
  689. //              depending upon their various IA32 instruction support.
  690. //
  691. // Fields:
  692. //
  693. // IJL_OTHER_PROC
  694. //      Does not support the CPUID instruction and
  695. //      assumes no Pentium(R) processor instructions.
  696. //
  697. // IJL_PENTIUM_PROC
  698. //      Corresponds to an Intel(R) Pentium(R) processor
  699. //      (or a 100% compatible) that supports the
  700. //      Pentium(R) processor instructions.
  701. //
  702. // IJL_PENTIUM_PRO_PROC
  703. //      Corresponds to an Intel(R) Pentium(R) Pro processor
  704. //      (or a 100% compatible) that supports the
  705. //      Pentium(R) Pro processor instructions.
  706. //
  707. // IJL_PENTIUM_PROC_MMX_TECH
  708. //      Corresponds to an Intel(R) Pentium(R) processor
  709. //      with MMX(TM) technology (or a 100% compatible)
  710. //      that supports the MMX(TM) instructions.
  711. //
  712. // IJL_PENTIUM_II_PROC
  713. //      Corresponds to an Intel(R) Pentium(R) II processor
  714. //      (or a 100% compatible) that supports both the
  715. //      Pentium(R) Pro processor instructions and the
  716. //      MMX(TM) instructions.
  717. //
  718. // IJL_PENTIUM_III_PROC
  719. //      Corresponds to an Intel(R) Pentium(R) III processor
  720. //
  721. // IJL_NEW_PROCESSOR
  722. //      Correponds to new processor
  723. //
  724. //  Any additional processor types that support a superset
  725. //  of both the Pentium(R) Pro processor instructions and the
  726. //  MMX(TM) instructions should be given an enum value greater
  727. //  than IJL_PENTIUM_III_PROC.
  728. //
  729. ////////////////////////////////////////////////////////////////////////////
  730. *D*/
  732. typedef enum _PROCESSOR_TYPE
  733. {
  734.   IJL_OTHER_PROC            = 0,
  735.   IJL_PENTIUM_PROC          = 1,
  736.   IJL_PENTIUM_PRO_PROC      = 2,
  737.   IJL_PENTIUM_PROC_MMX_TECH = 3,
  738.   IJL_PENTIUM_II_PROC       = 4,
  739.   IJL_PENTIUM_III_PROC      = 5,
  740.   IJL_PENTIUM_4_PROC        = 6,
  741.   IJL_NEW_PROCESSOR         = 7
  743. } PROCESSOR_TYPE;
  746. /*D*
  747. ////////////////////////////////////////////////////////////////////////////
  748. // Name:        RAW_DATA_TYPES_STATE
  749. //
  750. // Purpose:     Stores data types: raw dct coefficients or raw sampled data.
  751. //              Pointer to structure in JPEG_PROPERTIES is NULL, if any raw
  752. //              data isn't request (DIBBytes!=NULL).
  753. //
  754. // Fields:
  755. //  short* raw_ptrs[4] - pointers to buffers with raw data; one pointer 
  756. //                       corresponds one JPG component;
  757. //  data_type          - 0 - raw dct coefficients, 1 - raw sampled data.
  758. ////////////////////////////////////////////////////////////////////////////
  759. *D*/
  760. typedef struct _RAW_DATA_TYPES_STATE
  761. {
  762.   int data_type;
  763.   unsigned short* raw_ptrs[4];
  765. } RAW_DATA_TYPES_STATE;
  768. /*D*
  769. ////////////////////////////////////////////////////////////////////////////
  770. // Name:        ENTROPYSTRUCT
  771. //
  772. // Purpose:     Stores the decoder state information necessary to "jump"
  773. //              to a particular MCU row in a compressed entropy stream.
  774. //
  775. // Context:     Used to persist the decoder state within Decode_Scan when
  776. //              decoding using ROIs.
  777. //
  778. // Fields:
  779. //      offset              Offset (in bytes) into the entropy stream
  780. //                          from the beginning.
  781. //      dcval1              DC val at the beginning of the MCU row
  782. //                          for component 1.
  783. //      dcval2              DC val at the beginning of the MCU row
  784. //                          for component 2.
  785. //      dcval3              DC val at the beginning of the MCU row
  786. //                          for component 3.
  787. //      dcval4              DC val at the beginning of the MCU row
  788. //                          for component 4.
  789. //      bit_buffer_64       64-bit Huffman bit buffer.  Stores current
  790. //                          bit buffer at the start of a MCU row.
  791. //                          Also used as a 32-bit buffer on 32-bit
  792. //                          architectures.
  793. //      bitbuf_bits_valid   Number of valid bits in the above bit buffer.
  794. //      unread_marker       Have any markers been decoded but not
  795. //                          processed at the beginning of a MCU row?
  796. //                          This entry holds the unprocessed marker, or
  797. //                          0 if none.
  798. //
  799. ////////////////////////////////////////////////////////////////////////////
  800. *D*/
  802. typedef struct _ENTROPYSTRUCT
  803. {
  804.   unsigned int   offset;
  805.   int            dcval1;
  806.   int            dcval2;
  807.   int            dcval3;
  808.   int            dcval4;
  809.   IJL_UINT64     bit_buffer_64;
  810.   int            bitbuf_bits_valid;
  811.   unsigned char  unread_marker;
  813. } ENTROPYSTRUCT;
  816. /*D*
  817. ////////////////////////////////////////////////////////////////////////////
  818. // Name:        STATE
  819. //
  820. // Purpose:     Stores the active state of the IJL.
  821. //
  822. // Context:     Used by all low-level routines to store pseudo-global or
  823. //              state variables.
  824. //
  825. // Fields:
  826. //      bit_buffer_64           64-bit bitbuffer utilized by Huffman
  827. //                              encoder/decoder algorithms utilizing routines
  828. //                              designed for MMX(TM) technology.
  829. //      bit_buffer_32           32-bit bitbuffer for all other Huffman
  830. //                              encoder/decoder algorithms.
  831. //      bitbuf_bits_valid       Number of bits in the above two fields that
  832. //                              are valid.
  833. //
  834. //      cur_entropy_ptr         Current position (absolute address) in
  835. //                              the entropy buffer.
  836. //      start_entropy_ptr       Starting position (absolute address) of
  837. //                              the entropy buffer.
  838. //      end_entropy_ptr         Ending position (absolute address) of
  839. //                              the entropy buffer.
  840. //      entropy_bytes_processed Number of bytes actually processed
  841. //                              (passed over) in the entropy buffer.
  842. //      entropy_buf_maxsize     Max size of the entropy buffer.
  843. //      entropy_bytes_left      Number of bytes left in the entropy buffer.
  844. //      Prog_EndOfBlock_Run     Progressive block run counter.
  845. //
  846. //      DIB_ptr                 Temporary offset into the input/output DIB.
  847. //
  848. //      unread_marker           If a marker has been read but not processed,
  849. //                              stick it in this field.
  850. //      processor_type          (0, 1, or 2) == current processor does not
  851. //                              support MMX(TM) instructions.
  852. //                              (3 or 4) == current processor does
  853. //                              support MMX(TM) instructions.
  854. //      cur_scan_comp           On which component of the scan are we working?
  855. //      file                    Process file handle, or
  856. //                              0x00000000 if no file is defined.
  857. //      JPGBuffer               Entropy buffer (~4K).
  858. //
  859. //
  860. ////////////////////////////////////////////////////////////////////////////
  861. *D*/
  863. typedef struct _STATE
  864. {
  865.   /* Bit buffer. */
  866.   IJL_UINT64     bit_buffer_64;
  867.   unsigned int   bit_buffer_32;
  868.   int            bitbuf_bits_valid;
  870.   /* Entropy. */
  871.   unsigned char* cur_entropy_ptr;
  872.   unsigned char* start_entropy_ptr;
  873.   unsigned char* end_entropy_ptr;
  874.   int            entropy_bytes_processed;
  875.   int            entropy_buf_maxsize;
  876.   int            entropy_bytes_left;
  877.   int            Prog_EndOfBlock_Run;
  879.   /* Input or output DIB. */
  880.   unsigned char* DIB_ptr;
  882.   /* Control. */
  883.   unsigned char  unread_marker;
  884.   PROCESSOR_TYPE processor_type;
  885.   int            cur_scan_comp;
  886.   IJL_HANDLE     file;
  887.   unsigned char  JPGBuffer [JBUFSIZE];
  889. } STATE;
  892. /*D*
  893. ////////////////////////////////////////////////////////////////////////////
  894. // Name:        FAST_MCU_PROCESSING_TYPE
  895. //
  896. // Purpose:     Advanced Control Option.  Do NOT modify.
  897. //              WARNING:  Used for internal reference only.
  898. //
  899. // Fields:
  900. //
  901. //   IJL_(sampling)_(JPEG color space)_(sampling)_(DIB color space)
  902. //      Decode is read left to right w/ upsampling.
  903. //      Encode is read right to left w/ subsampling.
  904. //
  905. ////////////////////////////////////////////////////////////////////////////
  906. *D*/
  908. typedef enum _FAST_MCU_PROCESSING_TYPE
  909. {
  910.   IJL_NO_CC_OR_US                   = 0,
  912.   IJL_111_YCBCR_111_RGB             = 1,
  913.   IJL_111_YCBCR_111_BGR             = 2,
  915.   IJL_411_YCBCR_111_RGB             = 3,
  916.   IJL_411_YCBCR_111_BGR             = 4,
  918.   IJL_422_YCBCR_111_RGB             = 5,
  919.   IJL_422_YCBCR_111_BGR             = 6,
  921.   IJL_111_YCBCR_1111_RGBA_FPX       = 7,
  922.   IJL_411_YCBCR_1111_RGBA_FPX       = 8,
  923.   IJL_422_YCBCR_1111_RGBA_FPX       = 9,
  925.   IJL_1111_YCBCRA_FPX_1111_RGBA_FPX = 10,
  926.   IJL_4114_YCBCRA_FPX_1111_RGBA_FPX = 11,
  927.   IJL_4224_YCBCRA_FPX_1111_RGBA_FPX = 12,
  929.   IJL_111_RGB_1111_RGBA_FPX         = 13,
  931.   IJL_1111_RGBA_FPX_1111_RGBA_FPX   = 14,
  933.   IJL_111_OTHER_111_OTHER           = 15,
  934.   IJL_411_OTHER_111_OTHER           = 16,
  935.   IJL_422_OTHER_111_OTHER           = 17,
  937.   IJL_YCBYCR_YCBCR                  = 18,
  939.   IJL_YCBCR_YCBYCR                  = 19   // decoding to YCbCr 422 format
  941. } FAST_MCU_PROCESSING_TYPE;
  944. /*D*
  945. ////////////////////////////////////////////////////////////////////////////
  946. // Name:        JPEG_PROPERTIES
  947. //
  948. // Purpose:     Stores low-level and control information.  It is used by
  949. //              both the encoder and decoder.  An advanced external user
  950. //              may access this structure to expand the interface
  951. //              capability.
  952. //
  953. //              See the Developer's Guide for an expanded description
  954. //              of this structure and its use.
  955. //
  956. // Context:     Used by all interface methods and most IJL routines.
  957. //
  958. // Fields:
  959. //
  960. //  iotype              IN:     Specifies type of data operation
  961. //                              (read/write/other) to be
  962. //                              performed by IJL_Read or IJL_Write.
  963. //  roi                 IN:     Rectangle-Of-Interest to read from, or
  964. //                              write to, in pixels.
  965. //  dcttype             IN:     DCT alogrithm to be used.
  966. //  fast_processing     OUT:    Supported fast pre/post-processing path.
  967. //                              This is set by the IJL.
  968. //  interrupt           IN:     Signals an interrupt has been requested.
  969. //
  970. //  DIBBytes            IN:     Pointer to buffer of uncompressed data.
  971. //  DIBWidth            IN:     Width of uncompressed data.
  972. //  DIBHeight           IN:     Height of uncompressed data.
  973. //  DIBPadBytes         IN:     Padding (in bytes) at end of each
  974. //                              row in the uncompressed data.
  975. //  DIBChannels         IN:     Number of components in the
  976. //                              uncompressed data.
  977. //  DIBColor            IN:     Color space of uncompressed data.
  978. //  DIBSubsampling      IN:     Required to be IJL_NONE or IJL_422.
  979. //  DIBLineBytes        OUT:    Number of bytes in an output DIB line
  980. //                              including padding.
  981. //
  982. //  JPGFile             IN:     Pointer to file based JPEG.
  983. //  JPGBytes            IN:     Pointer to buffer based JPEG.
  984. //  JPGSizeBytes        IN:     Max buffer size. Used with JPGBytes.
  985. //                      OUT:    Number of compressed bytes written.
  986. //  JPGWidth            IN:     Width of JPEG image.
  987. //                      OUT:    After reading (except READHEADER).
  988. //  JPGHeight           IN:     Height of JPEG image.
  989. //                      OUT:    After reading (except READHEADER).
  990. //  JPGChannels         IN:     Number of components in JPEG image.
  991. //                      OUT:    After reading (except READHEADER).
  992. //  JPGColor            IN:     Color space of JPEG image.
  993. //  JPGSubsampling      IN:     Subsampling of JPEG image.
  994. //                      OUT:    After reading (except READHEADER).
  995. //  JPGThumbWidth       OUT:    JFIF embedded thumbnail width [0-255].
  996. //  JPGThumbHeight      OUT:    JFIF embedded thumbnail height [0-255].
  997. //
  998. //  cconversion_reqd    OUT:    If color conversion done on decode, TRUE.
  999. //  upsampling_reqd     OUT:    If upsampling done on decode, TRUE.
  1000. //  jquality            IN:     [0-100] where highest quality is 100.
  1001. //  jinterleaveType     IN/OUT: 0 => MCU interleaved file, and
  1002. //                              1 => 1 scan per component.
  1003. //  numxMCUs            OUT:    Number of MCUs in the x direction.
  1004. //  numyMCUs            OUT:    Number of MCUs in the y direction.
  1005. //
  1006. //  nqtables            IN/OUT: Number of quantization tables.
  1007. //  maxquantindex       IN/OUT: Maximum index of quantization tables.
  1008. //  nhuffActables       IN/OUT: Number of AC Huffman tables.
  1009. //  nhuffDctables       IN/OUT: Number of DC Huffman tables.
  1010. //  maxhuffindex        IN/OUT: Maximum index of Huffman tables.
  1011. //  jFmtQuant           IN/OUT: Formatted quantization table info.
  1012. //  jFmtAcHuffman       IN/OUT: Formatted AC Huffman table info.
  1013. //  jFmtDcHuffman       IN/OUT: Formatted DC Huffman table info.
  1014. //
  1015. //  jEncFmtQuant        IN/OUT: Pointer to one of the above, or
  1016. //                              to externally persisted table.
  1017. //  jEncFmtAcHuffman    IN/OUT: Pointer to one of the above, or
  1018. //                              to externally persisted table.
  1019. //  jEncFmtDcHuffman    IN/OUT: Pointer to one of the above, or
  1020. //                              to externally persisted table.
  1021. //
  1022. //  use_default_qtables IN:     Set to default quantization tables.
  1023. //                              Clear to supply your own.
  1024. //  use_default_htables IN:     Set to default Huffman tables.
  1025. //                              Clear to supply your own.
  1026. //  rawquanttables      IN:     Up to 4 sets of quantization tables.
  1027. //  rawhufftables       IN:     Alternating pairs (DC/AC) of up to 4
  1028. //                              sets of raw Huffman tables.
  1029. //  HuffIdentifierAC    IN:     Indicates what channel the user-
  1030. //                              supplied Huffman AC tables apply to.
  1031. //  HuffIdentifierDC    IN:     Indicates what channel the user-
  1032. //                              supplied Huffman DC tables apply to.
  1033. //
  1034. //  jframe              OUT:    Structure with frame-specific info.
  1035. //  needframe           OUT:    TRUE when a frame has been detected.
  1036. //
  1037. //  jscan               Persistence for current scan pointer when
  1038. //                      interrupted.
  1039. //
  1040. //  state               OUT:    Contains info on the state of the IJL.
  1041. //  SawAdobeMarker      OUT:    Decoder saw an APP14 marker somewhere.
  1042. //  AdobeXform          OUT:    If SawAdobeMarker TRUE, this indicates
  1043. //                              the JPEG color space given by that marker.
  1044. //
  1045. //  rowoffsets          Persistence for the decoder MCU row origins
  1046. //                      when decoding by ROI.  Offsets (in bytes
  1047. //                      from the beginning of the entropy data)
  1048. //                      to the start of each of the decoded rows.
  1049. //                      Fill the offsets with -1 if they have not
  1050. //                      been initalized and NULL could be the
  1051. //                      offset to the first row.
  1052. //
  1053. //  MCUBuf              OUT:    Quadword aligned internal buffer.
  1054. //                              Big enough for the largest MCU
  1055. //                              (10 blocks) with extra room for
  1056. //                              additional operations.
  1057. //  tMCUBuf             OUT:    Version of above, without alignment.
  1058. //
  1059. //  processor_type      OUT:    Determines type of processor found
  1060. //                              during initialization.
  1061. //
  1062. //  raw_coefs           IN:     Place to hold pointers to raw data buffers or
  1063. //                              raw DCT coefficients buffers
  1064. //
  1065. //  progressive_found   OUT:    1 when progressive image detected.
  1066. //  coef_buffer         IN:     Pointer to a larger buffer containing
  1067. //                              frequency coefficients when they
  1068. //                              cannot be decoded dynamically
  1069. //                              (i.e., as in progressive decoding).
  1070. //
  1071. //  upsampling_type     IN:     Type of sampling:
  1072. //                              IJL_BOX_FILTER or IJL_TRIANGLE_FILTER.
  1073. //  SAMPLING_STATE*    OUT:     pointer to structure, describing current
  1074. //                              condition of upsampling
  1075. //
  1076. //  AdobeVersion       OUT      version field, if Adobe APP14 marker detected
  1077. //  AdobeFlags0        OUT      flags0 field, if Adobe APP14 marker detected
  1078. //  AdobeFlags1        OUT      flags1 field, if Adobe APP14 marker detected
  1079. //
  1080. //  jfif_app0_detected OUT:     1 - if JFIF APP0 marker detected,  
  1081. //                              0 - if not
  1082. //  jfif_app0_version  IN/OUT   The JFIF file version
  1083. //  jfif_app0_units    IN/OUT   units for the X and Y densities
  1084. //                              0 - no units, X and Y specify
  1085. //                                  the pixel aspect ratio
  1086. //                              1 - X and Y are dots per inch
  1087. //                              2 - X and Y are dots per cm
  1088. //  jfif_app0_Xdensity IN/OUT   horizontal pixel density
  1089. //  jfif_app0_Ydensity IN/OUT   vertical pixel density
  1090. //
  1091. //  jpeg_comment       IN       pointer to JPEG comments
  1092. //  jpeg_comment_size  IN/OUT   size of JPEG comments, in bytes
  1093. //
  1094. //  raw_coefs          IN/OUT   if !NULL, then pointer to vector of pointers
  1095. //                              (size = JPGChannels) to buffers for raw (short)
  1096. //                              dct coefficients. 1 pointer corresponds to one
  1097. //                              component;
  1098. //
  1099. ////////////////////////////////////////////////////////////////////////////
  1100. *D*/
  1102. typedef struct _JPEG_PROPERTIES
  1103. {
  1104.   /* Compression/Decompression control. */
  1105.   IJLIOTYPE                iotype;               /* default = IJL_SETUP */
  1106.   IJL_RECT                 roi;                  /* default = 0 */
  1107.   DCTTYPE                  dcttype;              /* default = IJL_AAN */
  1108.   FAST_MCU_PROCESSING_TYPE fast_processing;      /* default = IJL_NO_CC_OR_US */
  1109.   int                      interrupt;            /* default = FALSE */
  1111.   /* DIB specific I/O data specifiers. */
  1112.   unsigned char*           DIBBytes;             /* default = NULL */
  1113.   int                      DIBWidth;             /* default = 0 */
  1114.   int                      DIBHeight;            /* default = 0 */
  1115.   int                      DIBPadBytes;          /* default = 0 */
  1116.   int                      DIBChannels;          /* default = 3 */
  1117.   IJL_COLOR                DIBColor;             /* default = IJL_BGR */
  1118.   IJL_DIBSUBSAMPLING       DIBSubsampling;       /* default = IJL_NONE */
  1119.   int                      DIBLineBytes;         /* default = 0 */
  1121.   /* JPEG specific I/O data specifiers. */
  1122.   const char*              JPGFile;              /* default = NULL */
  1123.   unsigned char*           JPGBytes;             /* default = NULL */
  1124.   int                      JPGSizeBytes;         /* default = 0 */
  1125.   int                      JPGWidth;             /* default = 0 */
  1126.   int                      JPGHeight;            /* default = 0 */
  1127.   int                      JPGChannels;          /* default = 3 */
  1128.   IJL_COLOR                JPGColor;             /* default = IJL_YCBCR */
  1129.   IJL_JPGSUBSAMPLING       JPGSubsampling;       /* default = IJL_411 */
  1130.   int                      JPGThumbWidth;        /* default = 0 */
  1131.   int                      JPGThumbHeight;       /* default = 0 */
  1133.   /* JPEG conversion properties. */
  1134.   int                      cconversion_reqd;     /* default = TRUE */
  1135.   int                      upsampling_reqd;      /* default = TRUE */
  1136.   int                      jquality;             /* default = 75 */
  1137.   int                      jinterleaveType;      /* default = 0 */
  1138.   int                      numxMCUs;             /* default = 0 */
  1139.   int                      numyMCUs;             /* default = 0 */
  1141.   /* Tables. */
  1142.   int                      nqtables;
  1143.   int                      maxquantindex;
  1144.   int                      nhuffActables;
  1145.   int                      nhuffDctables;
  1146.   int                      maxhuffindex;
  1148.   QUANT_TABLE              jFmtQuant[4];
  1149.   HUFFMAN_TABLE            jFmtAcHuffman[4];
  1150.   HUFFMAN_TABLE            jFmtDcHuffman[4];
  1152.   short*                   jEncFmtQuant[4];
  1153.   HUFFMAN_TABLE*           jEncFmtAcHuffman[4];
  1154.   HUFFMAN_TABLE*           jEncFmtDcHuffman[4];
  1156.   /* Allow user-defined tables. */
  1157.   int                      use_external_qtables;
  1158.   int                      use_external_htables;
  1160.   JPEGQuantTable           rawquanttables[4];
  1161.   JPEGHuffTable            rawhufftables[8];
  1162.   char                     HuffIdentifierAC[4];
  1163.   char                     HuffIdentifierDC[4];
  1165.   /* Frame specific members. */
  1166.   FRAME                    jframe;
  1167.   int                      needframe;
  1169.   /* SCAN persistent members. */
  1170.   SCAN*                    jscan;
  1172.   /* State members. */
  1173.   STATE                    state;
  1174.   int                      SawAdobeMarker;
  1175.   int                      AdobeXform;
  1177.   /* ROI decoder members. */
  1178.   ENTROPYSTRUCT*           rowoffsets;
  1180.   /* Intermediate buffers. */
  1181.   unsigned char*           MCUBuf;
  1182.   unsigned char            tMCUBuf[720*2];
  1184.   /* Processor detected. */
  1185.   PROCESSOR_TYPE           processor_type;
  1187.   RAW_DATA_TYPES_STATE*    raw_coefs;
  1189.   /* Progressive mode members. */
  1190.   int                      progressive_found;
  1191.   short*                   coef_buffer;
  1193.   /* Upsampling mode members. */
  1194.   UPSAMPLING_TYPE          upsampling_type;
  1195.   SAMPLING_STATE*          sampling_state_ptr;
  1197.   /* Adobe APP14 segment variables */
  1198.   unsigned short           AdobeVersion;         /* default = 100 */
  1199.   unsigned short           AdobeFlags0;          /* default = 0 */
  1200.   unsigned short           AdobeFlags1;          /* default = 0 */
  1202.   /* JFIF APP0 segment variables */
  1203.   int                      jfif_app0_detected;
  1204.   unsigned short           jfif_app0_version;    /* default = 0x0101 */
  1205.   unsigned char            jfif_app0_units;      /* default = 0 - pixel */
  1206.   unsigned short           jfif_app0_Xdensity;   /* default = 1 */
  1207.   unsigned short           jfif_app0_Ydensity;   /* default = 1 */
  1209.   /* comments related fields */
  1210.   char*                    jpeg_comment;         /* default = NULL */
  1211.   unsigned short           jpeg_comment_size;    /* default = 0 */
  1213. } JPEG_PROPERTIES;
  1216. /*D*
  1217. ////////////////////////////////////////////////////////////////////////////
  1218. // Name:        JPEG_CORE_PROPERTIES
  1219. //
  1220. // Purpose:     This is the primary data structure between the IJL and
  1221. //              the external user.  It stores JPEG state information
  1222. //              and controls the IJL.  It is user-modifiable.
  1223. //
  1224. //              See the Developer's Guide for details on appropriate usage.
  1225. //
  1226. // Context:     Used by all low-level IJL routines to store
  1227. //              pseudo-global information.
  1228. //
  1229. // Fields:
  1230. //
  1231. //  UseJPEGPROPERTIES   Set this flag != 0 if you wish to override
  1232. //                      the JPEG_CORE_PROPERTIES "IN" parameters with
  1233. //                      the JPEG_PROPERTIES parameters.
  1234. //
  1235. //  DIBBytes            IN:     Pointer to buffer of uncompressed data.
  1236. //  DIBWidth            IN:     Width of uncompressed data.
  1237. //  DIBHeight           IN:     Height of uncompressed data.
  1238. //  DIBPadBytes         IN:     Padding (in bytes) at end of each
  1239. //                              row in the uncompressed data.
  1240. //  DIBChannels         IN:     Number of components in the
  1241. //                              uncompressed data.
  1242. //  DIBColor            IN:     Color space of uncompressed data.
  1243. //  DIBSubsampling      IN:     Required to be IJL_NONE or IJL_422.
  1244. //
  1245. //  JPGFile             IN:     Pointer to file based JPEG.
  1246. //  JPGBytes            IN:     Pointer to buffer based JPEG.
  1247. //  JPGSizeBytes        IN:     Max buffer size. Used with JPGBytes.
  1248. //                      OUT:    Number of compressed bytes written.
  1249. //  JPGWidth            IN:     Width of JPEG image.
  1250. //                      OUT:    After reading (except READHEADER).
  1251. //  JPGHeight           IN:     Height of JPEG image.
  1252. //                      OUT:    After reading (except READHEADER).
  1253. //  JPGChannels         IN:     Number of components in JPEG image.
  1254. //                      OUT:    After reading (except READHEADER).
  1255. //  JPGColor            IN:     Color space of JPEG image.
  1256. //  JPGSubsampling      IN:     Subsampling of JPEG image.
  1257. //                      OUT:    After reading (except READHEADER).
  1258. //  JPGThumbWidth       OUT:    JFIF embedded thumbnail width [0-255].
  1259. //  JPGThumbHeight      OUT:    JFIF embedded thumbnail height [0-255].
  1260. //
  1261. //  cconversion_reqd    OUT:    If color conversion done on decode, TRUE.
  1262. //  upsampling_reqd     OUT:    If upsampling done on decode, TRUE.
  1263. //  jquality            IN:     [0-100] where highest quality is 100.
  1264. //
  1265. //  jprops              "Low-Level" IJL data structure.
  1266. //
  1267. ////////////////////////////////////////////////////////////////////////////
  1268. *D*/
  1270. typedef struct _JPEG_CORE_PROPERTIES
  1271. {
  1272.   int                UseJPEGPROPERTIES;         /* default = 0 */
  1274.   /* DIB specific I/O data specifiers. */
  1275.   unsigned char*     DIBBytes;                  /* default = NULL */
  1276.   int                DIBWidth;                  /* default = 0 */
  1277.   int                DIBHeight;                 /* default = 0 */
  1278.   int                DIBPadBytes;               /* default = 0 */
  1279.   int                DIBChannels;               /* default = 3 */
  1280.   IJL_COLOR          DIBColor;                  /* default = IJL_BGR */
  1281.   IJL_DIBSUBSAMPLING DIBSubsampling;            /* default = IJL_NONE */
  1283.   /* JPEG specific I/O data specifiers. */
  1284.   const char*        JPGFile;                   /* default = NULL */
  1285.   unsigned char*     JPGBytes;                  /* default = NULL */
  1286.   int                JPGSizeBytes;              /* default = 0 */
  1287.   int                JPGWidth;                  /* default = 0 */
  1288.   int                JPGHeight;                 /* default = 0 */
  1289.   int                JPGChannels;               /* default = 3 */
  1290.   IJL_COLOR          JPGColor;                  /* default = IJL_YCBCR */
  1291.   IJL_JPGSUBSAMPLING JPGSubsampling;            /* default = IJL_411 */
  1292.   int                JPGThumbWidth;             /* default = 0 */
  1293.   int                JPGThumbHeight;            /* default = 0 */
  1295.   /* JPEG conversion properties. */
  1296.   int                cconversion_reqd;          /* default = TRUE */
  1297.   int                upsampling_reqd;           /* default = TRUE */
  1298.   int                jquality;                  /* default = 75 */
  1300.   /* Low-level properties. */
  1301.   JPEG_PROPERTIES    jprops;
  1303. } JPEG_CORE_PROPERTIES;
  1306. /*D*
  1307. ////////////////////////////////////////////////////////////////////////////
  1308. // Name:        IJLERR
  1309. //
  1310. // Purpose:     Listing of possible "error" codes returned by the IJL.
  1311. //
  1312. //              See the Developer's Guide for details on appropriate usage.
  1313. //
  1314. // Context:     Used for error checking.
  1315. //
  1316. ////////////////////////////////////////////////////////////////////////////
  1317. *D*/
  1319. typedef enum _IJLERR
  1320. {
  1321.   /* The following "error" values indicate an "OK" condition. */
  1322.   IJL_OK                          = 0,
  1323.   IJL_INTERRUPT_OK                = 1,
  1324.   IJL_ROI_OK                      = 2,
  1326.   /* The following "error" values indicate an error has occurred. */
  1327.   IJL_EXCEPTION_DETECTED          =  -1,
  1328.   IJL_INVALID_ENCODER             =  -2,
  1329.   IJL_UNSUPPORTED_SUBSAMPLING     =  -3,
  1330.   IJL_UNSUPPORTED_BYTES_PER_PIXEL =  -4,
  1331.   IJL_MEMORY_ERROR                =  -5,
  1332.   IJL_BAD_HUFFMAN_TABLE           =  -6,
  1333.   IJL_BAD_QUANT_TABLE             =  -7,
  1334.   IJL_INVALID_JPEG_PROPERTIES     =  -8,
  1335.   IJL_ERR_FILECLOSE               =  -9,
  1336.   IJL_INVALID_FILENAME            = -10,
  1337.   IJL_ERROR_EOF                   = -11,
  1338.   IJL_PROG_NOT_SUPPORTED          = -12,
  1339.   IJL_ERR_NOT_JPEG                = -13,
  1340.   IJL_ERR_COMP                    = -14,
  1341.   IJL_ERR_SOF                     = -15,
  1342.   IJL_ERR_DNL                     = -16,
  1343.   IJL_ERR_NO_HUF                  = -17,
  1344.   IJL_ERR_NO_QUAN                 = -18,
  1345.   IJL_ERR_NO_FRAME                = -19,
  1346.   IJL_ERR_MULT_FRAME              = -20,
  1347.   IJL_ERR_DATA                    = -21,
  1348.   IJL_ERR_NO_IMAGE                = -22,
  1349.   IJL_FILE_ERROR                  = -23,
  1350.   IJL_INTERNAL_ERROR              = -24,
  1351.   IJL_BAD_RST_MARKER              = -25,
  1352.   IJL_THUMBNAIL_DIB_TOO_SMALL     = -26,
  1353.   IJL_THUMBNAIL_DIB_WRONG_COLOR   = -27,
  1354.   IJL_BUFFER_TOO_SMALL            = -28,
  1355.   IJL_UNSUPPORTED_FRAME           = -29,
  1356.   IJL_ERR_COM_BUFFER              = -30,
  1357.   IJL_RESERVED                    = -99
  1359. } IJLERR;
  1364. /* /////////////////////////////////////////////////////////////////////////
  1365. //                     Function Prototypes (API Calls)                    //
  1366. ///////////////////////////////////////////////////////////////////////// */
  1369. /*F*
  1370. ////////////////////////////////////////////////////////////////////////////
  1371. // Name:        ijlInit
  1372. //
  1373. // Purpose:     Used to initalize the IJL.
  1374. //
  1375. //              See the Developer's Guide for details on appropriate usage.
  1376. //
  1377. // Context:     Always call this before anything else.
  1378. //              Also, only call this with a new jcprops structure, or
  1379. //              after calling IJL_Free.  Otherwise, dynamically
  1380. //              allocated memory may be leaked.
  1381. //
  1382. // Returns:     Any IJLERR value.  IJL_OK indicates success.
  1383. //
  1384. // Parameters:
  1385. //  jcprops     Pointer to an externally allocated
  1386. //              JPEG_CORE_PROPERTIES structure.
  1387. //
  1388. ////////////////////////////////////////////////////////////////////////////
  1389. *F*/
  1391. IJLAPI(IJLERR, ijlInit, ( JPEG_CORE_PROPERTIES* jcprops ));
  1394. /*F*
  1395. ////////////////////////////////////////////////////////////////////////////
  1396. // Name:        ijlFree
  1397. //
  1398. // Purpose:     Used to properly close down the IJL.
  1399. //
  1400. //              See the Developer's Guide for details on appropriate usage.
  1401. //
  1402. // Context:     Always call this when done using the IJL to perform
  1403. //              clean-up of dynamically allocated memory.
  1404. //              Note, IJL_Init will have to be called to use the
  1405. //              IJL again.
  1406. //
  1407. // Returns:     Any IJLERR value.  IJL_OK indicates success.
  1408. //
  1409. // Parameters:
  1410. //  jcprops     Pointer to an externally allocated
  1411. //              JPEG_CORE_PROPERTIES structure.
  1412. //
  1413. ////////////////////////////////////////////////////////////////////////////
  1414. *F*/
  1416. IJLAPI(IJLERR, ijlFree, ( JPEG_CORE_PROPERTIES* jcprops ));
  1419. /*F*
  1420. ////////////////////////////////////////////////////////////////////////////
  1421. // Name:        IJL_Read
  1422. //
  1423. // Purpose:     Used to read JPEG data (entropy, or header, or both) into
  1424. //              a user-supplied buffer (to hold the image data) and/or
  1425. //              into the JPEG_CORE_PROPERTIES structure (to hold the
  1426. //              header info).
  1427. //
  1428. // Context:     See the Developer's Guide for a detailed description
  1429. //              on the use of this function.  The jcprops main data
  1430. //              members are checked for consistency.
  1431. //
  1432. // Returns:     Any IJLERR value.  IJL_OK indicates success.
  1433. //
  1434. // Parameters:
  1435. //  jcprops     Pointer to an externally allocated
  1436. //              JPEG_CORE_PROPERTIES structure.
  1437. //  iotype      Specifies what type of read operation to perform.
  1438. //
  1439. ////////////////////////////////////////////////////////////////////////////
  1440. *F*/
  1442. IJLAPI(IJLERR, ijlRead, ( JPEG_CORE_PROPERTIES* jcprops, IJLIOTYPE iotype ));
  1445. /*F*
  1446. ////////////////////////////////////////////////////////////////////////////
  1447. // Name:        ijlWrite
  1448. //
  1449. // Purpose:     Used to write JPEG data (entropy, or header, or both) into
  1450. //              a user-supplied buffer (to hold the image data) and/or
  1451. //              into the JPEG_CORE_PROPERTIES structure (to hold the
  1452. //              header info).
  1453. //
  1454. // Context:     See the Developer's Guide for a detailed description
  1455. //              on the use of this function.  The jcprops main data
  1456. //              members are checked for consistency.
  1457. //
  1458. // Returns:     Any IJLERR value.  IJL_OK indicates success.
  1459. //
  1460. // Parameters:
  1461. //  jcprops     Pointer to an externally allocated
  1462. //              JPEG_CORE_PROPERTIES structure.
  1463. //  iotype      Specifies what type of write operation to perform.
  1464. //
  1465. ////////////////////////////////////////////////////////////////////////////
  1466. *F*/
  1468. IJLAPI(IJLERR, ijlWrite, ( JPEG_CORE_PROPERTIES* jcprops, IJLIOTYPE iotype ));
  1471. /*F*
  1472. ////////////////////////////////////////////////////////////////////////////
  1473. // Name:        ijlGetLibVersion
  1474. //
  1475. // Purpose:     To identify the version number of the IJL.
  1476. //
  1477. // Context:     Call to get the IJL version number.
  1478. //
  1479. // Returns:     pointer to IJLibVersion struct
  1480. //
  1481. // Parameters:  none
  1482. //
  1483. ////////////////////////////////////////////////////////////////////////////
  1484. *F*/
  1486. IJLAPI(const IJLibVersion*, ijlGetLibVersion, (void));
  1489. /*F*
  1490. ////////////////////////////////////////////////////////////////////////////
  1491. // Name:        ijlErrorStr
  1492. //
  1493. // Purpose:     Gets the string to describe error code.
  1494. //
  1495. // Context:     Is called to get descriptive string on arbitrary IJLERR code.
  1496. //
  1497. // Returns:     pointer to string
  1498. //
  1499. // Parameters:  IJLERR - IJL error code
  1500. //
  1501. ////////////////////////////////////////////////////////////////////////////
  1502. *F*/
  1504. IJLAPI(const char*, ijlErrorStr, (IJLERR code));
  1509. #if defined( __cplusplus )
  1510. }
  1511. #endif
  1513. #endif  /* __IJL_H__ */