jdmarker.c File Reference

#include "jinclude.h"
#include "jpeglib.h"

Include dependency graph for jdmarker.c:

Go to the source code of this file.

Classes
struct	my_marker_reader

Macros
#define	JPEG_INTERNALS
#define	INPUT_VARS(cinfo)
#define	INPUT_SYNC(cinfo)
#define	INPUT_RELOAD(cinfo)
#define	MAKE_BYTE_AVAIL(cinfo, action)
#define	INPUT_BYTE(cinfo, V, action)
#define	INPUT_2BYTES(cinfo, V, action)
#define	get_dac(cinfo)   skip_variable(cinfo)
#define	APP0_DATA_LEN   14 /* Length of interesting data in APP0 */
#define	APP14_DATA_LEN   12 /* Length of interesting data in APP14 */
#define	APPN_DATA_LEN   14 /* Must be the largest of the above!! */

Typedefs
typedef my_marker_reader *	my_marker_ptr

Enumerations
enum	JPEG_MARKER {   M_SOF0 = 0xc0 , M_SOF1 = 0xc1 , M_SOF2 = 0xc2 , M_SOF3 = 0xc3 ,   M_SOF5 = 0xc5 , M_SOF6 = 0xc6 , M_SOF7 = 0xc7 , M_JPG = 0xc8 ,   M_SOF9 = 0xc9 , M_SOF10 = 0xca , M_SOF11 = 0xcb , M_SOF13 = 0xcd ,   M_SOF14 = 0xce , M_SOF15 = 0xcf , M_DHT = 0xc4 , M_DAC = 0xcc ,   M_RST0 = 0xd0 , M_RST1 = 0xd1 , M_RST2 = 0xd2 , M_RST3 = 0xd3 ,   M_RST4 = 0xd4 , M_RST5 = 0xd5 , M_RST6 = 0xd6 , M_RST7 = 0xd7 ,   M_SOI = 0xd8 , M_EOI = 0xd9 , M_SOS = 0xda , M_DQT = 0xdb ,   M_DNL = 0xdc , M_DRI = 0xdd , M_DHP = 0xde , M_EXP = 0xdf ,   M_APP0 = 0xe0 , M_APP1 = 0xe1 , M_APP2 = 0xe2 , M_APP3 = 0xe3 ,   M_APP4 = 0xe4 , M_APP5 = 0xe5 , M_APP6 = 0xe6 , M_APP7 = 0xe7 ,   M_APP8 = 0xe8 , M_APP9 = 0xe9 , M_APP10 = 0xea , M_APP11 = 0xeb ,   M_APP12 = 0xec , M_APP13 = 0xed , M_APP14 = 0xee , M_APP15 = 0xef ,   M_JPG0 = 0xf0 , M_JPG8 = 0xf8 , M_JPG13 = 0xfd , M_COM = 0xfe ,   M_TEM = 0x01 , M_ERROR = 0x100 , M_SOF0 = 0xc0 , M_SOF1 = 0xc1 ,   M_SOF2 = 0xc2 , M_SOF3 = 0xc3 , M_SOF5 = 0xc5 , M_SOF6 = 0xc6 ,   M_SOF7 = 0xc7 , M_JPG = 0xc8 , M_SOF9 = 0xc9 , M_SOF10 = 0xca ,   M_SOF11 = 0xcb , M_SOF13 = 0xcd , M_SOF14 = 0xce , M_SOF15 = 0xcf ,   M_DHT = 0xc4 , M_DAC = 0xcc , M_RST0 = 0xd0 , M_RST1 = 0xd1 ,   M_RST2 = 0xd2 , M_RST3 = 0xd3 , M_RST4 = 0xd4 , M_RST5 = 0xd5 ,   M_RST6 = 0xd6 , M_RST7 = 0xd7 , M_SOI = 0xd8 , M_EOI = 0xd9 ,   M_SOS = 0xda , M_DQT = 0xdb , M_DNL = 0xdc , M_DRI = 0xdd ,   M_DHP = 0xde , M_EXP = 0xdf , M_APP0 = 0xe0 , M_APP1 = 0xe1 ,   M_APP2 = 0xe2 , M_APP3 = 0xe3 , M_APP4 = 0xe4 , M_APP5 = 0xe5 ,   M_APP6 = 0xe6 , M_APP7 = 0xe7 , M_APP8 = 0xe8 , M_APP9 = 0xe9 ,   M_APP10 = 0xea , M_APP11 = 0xeb , M_APP12 = 0xec , M_APP13 = 0xed ,   M_APP14 = 0xee , M_APP15 = 0xef , M_JPG0 = 0xf0 , M_JPG8 = 0xf8 ,   M_JPG13 = 0xfd , M_COM = 0xfe , M_TEM = 0x01 , M_ERROR = 0x100 }

Functions
	get_soi (j_decompress_ptr cinfo)
	get_sof (j_decompress_ptr cinfo, boolean is_baseline, boolean is_prog, boolean is_arith)
	get_sos (j_decompress_ptr cinfo)
	get_dht (j_decompress_ptr cinfo)
	get_dqt (j_decompress_ptr cinfo)
	get_dri (j_decompress_ptr cinfo)
	get_lse (j_decompress_ptr cinfo)
	examine_app0 (j_decompress_ptr cinfo, JOCTET FAR *data, unsigned int datalen, INT32 remaining)
	examine_app14 (j_decompress_ptr cinfo, JOCTET FAR *data, unsigned int datalen, INT32 remaining)
	get_interesting_appn (j_decompress_ptr cinfo)
	skip_variable (j_decompress_ptr cinfo)
	next_marker (j_decompress_ptr cinfo)
	first_marker (j_decompress_ptr cinfo)
	read_markers (j_decompress_ptr cinfo)
	read_restart_marker (j_decompress_ptr cinfo)
	jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired)
	reset_marker_reader (j_decompress_ptr cinfo)
	jinit_marker_reader (j_decompress_ptr cinfo)
	jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code, jpeg_marker_parser_method routine)

Macro Definition Documentation

APP0_DATA_LEN

#define APP0_DATA_LEN   14 /* Length of interesting data in APP0 */

Definition at line 713 of file jdmarker.c.

APP14_DATA_LEN

#define APP14_DATA_LEN   12 /* Length of interesting data in APP14 */

Definition at line 714 of file jdmarker.c.

APPN_DATA_LEN

#define APPN_DATA_LEN   14 /* Must be the largest of the above!! */

Definition at line 715 of file jdmarker.c.

get_dac

#define get_dac

(

cinfo

)

skip_variable(cinfo)

Definition at line 453 of file jdmarker.c.

INPUT_2BYTES

#define INPUT_2BYTES	(		cinfo,
			V,
			action
	)

Value:

    MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
          bytes_in_buffer--; \
          V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \
          MAKE_BYTE_AVAIL(cinfo,action); \
          bytes_in_buffer--; \
          V += GETJOCTET(*next_input_byte++); )

Definition at line 158 of file jdmarker.c.

INPUT_BYTE

#define INPUT_BYTE	(		cinfo,
			V,
			action
	)

Value:

    MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
          bytes_in_buffer--; \
          V = GETJOCTET(*next_input_byte++); )

Definition at line 150 of file jdmarker.c.

INPUT_RELOAD

#define INPUT_RELOAD

(

cinfo

)

Value:

    ( next_input_byte = datasrc->next_input_byte,  \
      bytes_in_buffer = datasrc->bytes_in_buffer )

Definition at line 132 of file jdmarker.c.

INPUT_SYNC

#define INPUT_SYNC

(

cinfo

)

Value:

    ( datasrc->next_input_byte = next_input_byte,  \
      datasrc->bytes_in_buffer = bytes_in_buffer )

Definition at line 127 of file jdmarker.c.

INPUT_VARS

#define INPUT_VARS

(

cinfo

)

Value:

    struct jpeg_source_mgr * datasrc = (cinfo)->src;  \
    const JOCTET * next_input_byte = datasrc->next_input_byte;  \
    size_t bytes_in_buffer = datasrc->bytes_in_buffer

Definition at line 121 of file jdmarker.c.

JPEG_INTERNALS

#define JPEG_INTERNALS

Definition at line 16 of file jdmarker.c.

MAKE_BYTE_AVAIL

#define MAKE_BYTE_AVAIL	(		cinfo,
			action
	)

Value:

    if (bytes_in_buffer == 0) {  \
      if (! (*datasrc->fill_input_buffer) (cinfo))  \
        { action; }  \
      INPUT_RELOAD(cinfo);  \
    }

Definition at line 140 of file jdmarker.c.

Typedef Documentation

my_marker_ptr

typedef my_marker_reader* my_marker_ptr

Definition at line 109 of file jdmarker.c.

Enumeration Type Documentation

JPEG_MARKER

enum JPEG_MARKER

Enumerator
M_SOF0
M_SOF1
M_SOF2
M_SOF3
M_SOF5
M_SOF6
M_SOF7
M_JPG
M_SOF9
M_SOF10
M_SOF11
M_SOF13
M_SOF14
M_SOF15
M_DHT
M_DAC
M_RST0
M_RST1
M_RST2
M_RST3
M_RST4
M_RST5
M_RST6
M_RST7
M_SOI
M_EOI
M_SOS
M_DQT
M_DNL
M_DRI
M_DHP
M_EXP
M_APP0
M_APP1
M_APP2
M_APP3
M_APP4
M_APP5
M_APP6
M_APP7
M_APP8
M_APP9
M_APP10
M_APP11
M_APP12
M_APP13
M_APP14
M_APP15
M_JPG0
M_JPG8
M_JPG13
M_COM
M_TEM
M_ERROR
M_SOF0
M_SOF1
M_SOF2
M_SOF3
M_SOF5
M_SOF6
M_SOF7
M_JPG
M_SOF9
M_SOF10
M_SOF11
M_SOF13
M_SOF14
M_SOF15
M_DHT
M_DAC
M_RST0
M_RST1
M_RST2
M_RST3
M_RST4
M_RST5
M_RST6
M_RST7
M_SOI
M_EOI
M_SOS
M_DQT
M_DNL
M_DRI
M_DHP
M_EXP
M_APP0
M_APP1
M_APP2
M_APP3
M_APP4
M_APP5
M_APP6
M_APP7
M_APP8
M_APP9
M_APP10
M_APP11
M_APP12
M_APP13
M_APP14
M_APP15
M_JPG0
M_JPG8
M_JPG13
M_COM
M_TEM
M_ERROR

Definition at line 21 of file jdmarker.c.

             {          /* JPEG marker codes */
  M_SOF0  = 0xc0,
  M_SOF1  = 0xc1,
  M_SOF2  = 0xc2,
  M_SOF3  = 0xc3,
 
  M_SOF5  = 0xc5,
  M_SOF6  = 0xc6,
  M_SOF7  = 0xc7,
 
  M_JPG   = 0xc8,
  M_SOF9  = 0xc9,
  M_SOF10 = 0xca,
  M_SOF11 = 0xcb,
 
  M_SOF13 = 0xcd,
  M_SOF14 = 0xce,
  M_SOF15 = 0xcf,
 
  M_DHT   = 0xc4,
 
  M_DAC   = 0xcc,
 
  M_RST0  = 0xd0,
  M_RST1  = 0xd1,
  M_RST2  = 0xd2,
  M_RST3  = 0xd3,
  M_RST4  = 0xd4,
  M_RST5  = 0xd5,
  M_RST6  = 0xd6,
  M_RST7  = 0xd7,
 
  M_SOI   = 0xd8,
  M_EOI   = 0xd9,
  M_SOS   = 0xda,
  M_DQT   = 0xdb,
  M_DNL   = 0xdc,
  M_DRI   = 0xdd,
  M_DHP   = 0xde,
  M_EXP   = 0xdf,
 
  M_APP0  = 0xe0,
  M_APP1  = 0xe1,
  M_APP2  = 0xe2,
  M_APP3  = 0xe3,
  M_APP4  = 0xe4,
  M_APP5  = 0xe5,
  M_APP6  = 0xe6,
  M_APP7  = 0xe7,
  M_APP8  = 0xe8,
  M_APP9  = 0xe9,
  M_APP10 = 0xea,
  M_APP11 = 0xeb,
  M_APP12 = 0xec,
  M_APP13 = 0xed,
  M_APP14 = 0xee,
  M_APP15 = 0xef,
 
  M_JPG0  = 0xf0,
  M_JPG8  = 0xf8,
  M_JPG13 = 0xfd,
  M_COM   = 0xfe,
 
  M_TEM   = 0x01,
 
  M_ERROR = 0x100
} JPEG_MARKER;

Function Documentation

examine_app0()

examine_app0	(	j_decompress_ptr	cinfo,
		JOCTET FAR *	data,
		unsigned int	datalen,
		INT32	remaining
	)

Definition at line 719 of file jdmarker.c.

{
  INT32 totallen = (INT32) datalen + remaining;
 
  if (datalen >= APP0_DATA_LEN &&
      GETJOCTET(data[0]) == 0x4A &&
      GETJOCTET(data[1]) == 0x46 &&
      GETJOCTET(data[2]) == 0x49 &&
      GETJOCTET(data[3]) == 0x46 &&
      GETJOCTET(data[4]) == 0) {
    /* Found JFIF APP0 marker: save info */
    cinfo->saw_JFIF_marker = TRUE;
    cinfo->JFIF_major_version = GETJOCTET(data[5]);
    cinfo->JFIF_minor_version = GETJOCTET(data[6]);
    cinfo->density_unit = GETJOCTET(data[7]);
    cinfo->X_density = (GETJOCTET(data[8]) << 8) + GETJOCTET(data[9]);
    cinfo->Y_density = (GETJOCTET(data[10]) << 8) + GETJOCTET(data[11]);
    /* Check version.
     * Major version must be 1 or 2, anything else signals an incompatible
     * change.
     * (We used to treat this as an error, but now it's a nonfatal warning,
     * because some bozo at Hijaak couldn't read the spec.)
     * Minor version should be 0..2, but process anyway if newer.
     */
    if (cinfo->JFIF_major_version != 1 && cinfo->JFIF_major_version != 2)
      WARNMS2(cinfo, JWRN_JFIF_MAJOR,
          cinfo->JFIF_major_version, cinfo->JFIF_minor_version);
    /* Generate trace messages */
    TRACEMS5(cinfo, 1, JTRC_JFIF,
         cinfo->JFIF_major_version, cinfo->JFIF_minor_version,
         cinfo->X_density, cinfo->Y_density, cinfo->density_unit);
    /* Validate thumbnail dimensions and issue appropriate messages */
    if (GETJOCTET(data[12]) | GETJOCTET(data[13]))
      TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL,
           GETJOCTET(data[12]), GETJOCTET(data[13]));
    totallen -= APP0_DATA_LEN;
    if (totallen !=
    ((INT32)GETJOCTET(data[12]) * (INT32)GETJOCTET(data[13]) * (INT32) 3))
      TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) totallen);
  } else if (datalen >= 6 &&
      GETJOCTET(data[0]) == 0x4A &&
      GETJOCTET(data[1]) == 0x46 &&
      GETJOCTET(data[2]) == 0x58 &&
      GETJOCTET(data[3]) == 0x58 &&
      GETJOCTET(data[4]) == 0) {
    /* Found JFIF "JFXX" extension APP0 marker */
    /* The library doesn't actually do anything with these,
     * but we try to produce a helpful trace message.
     */
    switch (GETJOCTET(data[5])) {
    case 0x10:
      TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int) totallen);
      break;
    case 0x11:
      TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int) totallen);
      break;
    case 0x13:
      TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int) totallen);
      break;
    default:
      TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION,
           GETJOCTET(data[5]), (int) totallen);
    }
  } else {
    /* Start of APP0 does not match "JFIF" or "JFXX", or too short */
    TRACEMS1(cinfo, 1, JTRC_APP0, (int) totallen);
  }
}

Referenced by get_interesting_appn().

examine_app14()

examine_app14	(	j_decompress_ptr	cinfo,
		JOCTET FAR *	data,
		unsigned int	datalen,
		INT32	remaining
	)

Definition at line 795 of file jdmarker.c.

{
  unsigned int version, flags0, flags1, transform;
 
  if (datalen >= APP14_DATA_LEN &&
      GETJOCTET(data[0]) == 0x41 &&
      GETJOCTET(data[1]) == 0x64 &&
      GETJOCTET(data[2]) == 0x6F &&
      GETJOCTET(data[3]) == 0x62 &&
      GETJOCTET(data[4]) == 0x65) {
    /* Found Adobe APP14 marker */
    version = (GETJOCTET(data[5]) << 8) + GETJOCTET(data[6]);
    flags0 = (GETJOCTET(data[7]) << 8) + GETJOCTET(data[8]);
    flags1 = (GETJOCTET(data[9]) << 8) + GETJOCTET(data[10]);
    transform = GETJOCTET(data[11]);
    TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform);
    cinfo->saw_Adobe_marker = TRUE;
    cinfo->Adobe_transform = (UINT8) transform;
  } else {
    /* Start of APP14 does not match "Adobe", or too short */
    TRACEMS1(cinfo, 1, JTRC_APP14, (int) (datalen + remaining));
  }
}

Referenced by get_interesting_appn().

first_marker()

first_marker

(

j_decompress_ptr

cinfo

)

Definition at line 1054 of file jdmarker.c.

{
  int c, c2;
  INPUT_VARS(cinfo);
 
  INPUT_BYTE(cinfo, c, return FALSE);
  INPUT_BYTE(cinfo, c2, return FALSE);
  if (c != 0xFF || c2 != (int) M_SOI)
    ERREXIT2(cinfo, JERR_NO_SOI, c, c2);
 
  cinfo->unread_marker = c2;
 
  INPUT_SYNC(cinfo);
  return TRUE;
}

get_dht()

get_dht

(

j_decompress_ptr

cinfo

)

Definition at line 459 of file jdmarker.c.

{
  INT32 length;
  UINT8 bits[17];
  UINT8 huffval[256];
  int i, index, count;
  JHUFF_TBL **htblptr;
  INPUT_VARS(cinfo);
 
  INPUT_2BYTES(cinfo, length, return FALSE);
  length -= 2;
  
  while (length > 16) {
    INPUT_BYTE(cinfo, index, return FALSE);
 
    TRACEMS1(cinfo, 1, JTRC_DHT, index);
      
    bits[0] = 0;
    count = 0;
    for (i = 1; i <= 16; i++) {
      INPUT_BYTE(cinfo, bits[i], return FALSE);
      count += bits[i];
    }
 
    length -= 1 + 16;
 
    TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
         bits[1], bits[2], bits[3], bits[4],
         bits[5], bits[6], bits[7], bits[8]);
    TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
         bits[9], bits[10], bits[11], bits[12],
         bits[13], bits[14], bits[15], bits[16]);
 
    /* Here we just do minimal validation of the counts to avoid walking
     * off the end of our table space.  jdhuff.c will check more carefully.
     */
    if (count > 256 || ((INT32) count) > length)
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
 
    for (i = 0; i < count; i++)
      INPUT_BYTE(cinfo, huffval[i], return FALSE);
 
    length -= count;
 
    if (index & 0x10) {     /* AC table definition */
      index -= 0x10;
      htblptr = &cinfo->ac_huff_tbl_ptrs[index];
    } else {            /* DC table definition */
      htblptr = &cinfo->dc_huff_tbl_ptrs[index];
    }
 
    if (index < 0 || index >= NUM_HUFF_TBLS)
      ERREXIT1(cinfo, JERR_DHT_INDEX, index);
 
    if (*htblptr == NULL)
      *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
  
    MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
    if (count > 0)
      MEMCOPY((*htblptr)->huffval, huffval, count * SIZEOF(UINT8));
  }
 
  if (length != 0)
    ERREXIT(cinfo, JERR_BAD_LENGTH);
 
  INPUT_SYNC(cinfo);
  return TRUE;
}

Referenced by read_markers().

get_dqt()

get_dqt

(

j_decompress_ptr

cinfo

)

Definition at line 531 of file jdmarker.c.

{
  INT32 length, count, i;
  int n, prec;
  unsigned int tmp;
  JQUANT_TBL *quant_ptr;
  const int *natural_order;
  INPUT_VARS(cinfo);
 
  INPUT_2BYTES(cinfo, length, return FALSE);
  length -= 2;
 
  while (length > 0) {
    length--;
    INPUT_BYTE(cinfo, n, return FALSE);
    prec = n >> 4;
    n &= 0x0F;
 
    TRACEMS2(cinfo, 1, JTRC_DQT, n, prec);
 
    if (n >= NUM_QUANT_TBLS)
      ERREXIT1(cinfo, JERR_DQT_INDEX, n);
      
    if (cinfo->quant_tbl_ptrs[n] == NULL)
      cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo);
    quant_ptr = cinfo->quant_tbl_ptrs[n];
 
    if (prec) {
      if (length < DCTSIZE2 * 2) {
    /* Initialize full table for safety. */
    for (i = 0; i < DCTSIZE2; i++) {
      quant_ptr->quantval[i] = 1;
    }
    count = length >> 1;
      } else
    count = DCTSIZE2;
    } else {
      if (length < DCTSIZE2) {
    /* Initialize full table for safety. */
    for (i = 0; i < DCTSIZE2; i++) {
      quant_ptr->quantval[i] = 1;
    }
    count = length;
      } else
    count = DCTSIZE2;
    }
 
    switch ((int) count) {
    case (2*2): natural_order = jpeg_natural_order2; break;
    case (3*3): natural_order = jpeg_natural_order3; break;
    case (4*4): natural_order = jpeg_natural_order4; break;
    case (5*5): natural_order = jpeg_natural_order5; break;
    case (6*6): natural_order = jpeg_natural_order6; break;
    case (7*7): natural_order = jpeg_natural_order7; break;
    default:    natural_order = jpeg_natural_order;
    }
 
    for (i = 0; i < count; i++) {
      if (prec)
    INPUT_2BYTES(cinfo, tmp, return FALSE);
      else
    INPUT_BYTE(cinfo, tmp, return FALSE);
      /* We convert the zigzag-order table to natural array order. */
      quant_ptr->quantval[natural_order[i]] = (UINT16) tmp;
    }
 
    if (cinfo->err->trace_level >= 2) {
      for (i = 0; i < DCTSIZE2; i += 8) {
    TRACEMS8(cinfo, 2, JTRC_QUANTVALS,
         quant_ptr->quantval[i],   quant_ptr->quantval[i+1],
         quant_ptr->quantval[i+2], quant_ptr->quantval[i+3],
         quant_ptr->quantval[i+4], quant_ptr->quantval[i+5],
         quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]);
      }
    }
 
    length -= count;
    if (prec) length -= count;
  }
 
  if (length != 0)
    ERREXIT(cinfo, JERR_BAD_LENGTH);
 
  INPUT_SYNC(cinfo);
  return TRUE;
}

Referenced by read_markers().

get_dri()

get_dri

(

j_decompress_ptr

cinfo

)

Definition at line 621 of file jdmarker.c.

{
  INT32 length;
  unsigned int tmp;
  INPUT_VARS(cinfo);
 
  INPUT_2BYTES(cinfo, length, return FALSE);
  
  if (length != 4)
    ERREXIT(cinfo, JERR_BAD_LENGTH);
 
  INPUT_2BYTES(cinfo, tmp, return FALSE);
 
  TRACEMS1(cinfo, 1, JTRC_DRI, tmp);
 
  cinfo->restart_interval = tmp;
 
  INPUT_SYNC(cinfo);
  return TRUE;
}

Referenced by read_markers().

get_interesting_appn()

get_interesting_appn

(

j_decompress_ptr

cinfo

)

Definition at line 826 of file jdmarker.c.

{
  INT32 length;
  JOCTET b[APPN_DATA_LEN];
  unsigned int i, numtoread;
  INPUT_VARS(cinfo);
 
  INPUT_2BYTES(cinfo, length, return FALSE);
  length -= 2;
 
  /* get the interesting part of the marker data */
  if (length >= APPN_DATA_LEN)
    numtoread = APPN_DATA_LEN;
  else if (length > 0)
    numtoread = (unsigned int) length;
  else
    numtoread = 0;
  for (i = 0; i < numtoread; i++)
    INPUT_BYTE(cinfo, b[i], return FALSE);
  length -= numtoread;
 
  /* process it */
  switch (cinfo->unread_marker) {
  case M_APP0:
    examine_app0(cinfo, (JOCTET FAR *) b, numtoread, length);
    break;
  case M_APP14:
    examine_app14(cinfo, (JOCTET FAR *) b, numtoread, length);
    break;
  default:
    /* can't get here unless jpeg_save_markers chooses wrong processor */
    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
  }
 
  /* skip any remaining data -- could be lots */
  INPUT_SYNC(cinfo);
  if (length > 0)
    (*cinfo->src->skip_input_data) (cinfo, (long) length);
 
  return TRUE;
}

Referenced by jinit_marker_reader().

get_lse()

get_lse

(

j_decompress_ptr

cinfo

)

Definition at line 645 of file jdmarker.c.

{
  INT32 length;
  unsigned int tmp;
  int cid;
  INPUT_VARS(cinfo);
 
  if (! cinfo->marker->saw_SOF)
    ERREXITS(cinfo, JERR_SOF_BEFORE, "LSE");
 
  if (cinfo->num_components < 3) goto bad;
 
  INPUT_2BYTES(cinfo, length, return FALSE);
 
  if (length != 24)
    ERREXIT(cinfo, JERR_BAD_LENGTH);
 
  INPUT_BYTE(cinfo, tmp, return FALSE);
  if (tmp != 0x0D)  /* ID inverse transform specification */
    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
  INPUT_2BYTES(cinfo, tmp, return FALSE);
  if (tmp != MAXJSAMPLE) goto bad;      /* MAXTRANS */
  INPUT_BYTE(cinfo, tmp, return FALSE);
  if (tmp != 3) goto bad;           /* Nt=3 */
  INPUT_BYTE(cinfo, cid, return FALSE);
  if (cid != cinfo->comp_info[1].component_id) goto bad;
  INPUT_BYTE(cinfo, cid, return FALSE);
  if (cid != cinfo->comp_info[0].component_id) goto bad;
  INPUT_BYTE(cinfo, cid, return FALSE);
  if (cid != cinfo->comp_info[2].component_id) goto bad;
  INPUT_BYTE(cinfo, tmp, return FALSE);
  if (tmp != 0x80) goto bad;        /* F1: CENTER1=1, NORM1=0 */
  INPUT_2BYTES(cinfo, tmp, return FALSE);
  if (tmp != 0) goto bad;           /* A(1,1)=0 */
  INPUT_2BYTES(cinfo, tmp, return FALSE);
  if (tmp != 0) goto bad;           /* A(1,2)=0 */
  INPUT_BYTE(cinfo, tmp, return FALSE);
  if (tmp != 0) goto bad;       /* F2: CENTER2=0, NORM2=0 */
  INPUT_2BYTES(cinfo, tmp, return FALSE);
  if (tmp != 1) goto bad;           /* A(2,1)=1 */
  INPUT_2BYTES(cinfo, tmp, return FALSE);
  if (tmp != 0) goto bad;           /* A(2,2)=0 */
  INPUT_BYTE(cinfo, tmp, return FALSE);
  if (tmp != 0) goto bad;       /* F3: CENTER3=0, NORM3=0 */
  INPUT_2BYTES(cinfo, tmp, return FALSE);
  if (tmp != 1) goto bad;           /* A(3,1)=1 */
  INPUT_2BYTES(cinfo, tmp, return FALSE);
  if (tmp != 0) {               /* A(3,2)=0 */
    bad:
    ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
  }
 
  /* OK, valid transform that we can handle. */
  cinfo->color_transform = JCT_SUBTRACT_GREEN;
 
  INPUT_SYNC(cinfo);
  return TRUE;
}

Referenced by read_markers().

get_sof()

get_sof	(	j_decompress_ptr	cinfo,
		boolean	is_baseline,
		boolean	is_prog,
		boolean	is_arith
	)

Definition at line 240 of file jdmarker.c.

{
  INT32 length;
  int c, ci, i;
  jpeg_component_info * compptr;
  INPUT_VARS(cinfo);
 
  cinfo->is_baseline = is_baseline;
  cinfo->progressive_mode = is_prog;
  cinfo->arith_code = is_arith;
 
  INPUT_2BYTES(cinfo, length, return FALSE);
 
  INPUT_BYTE(cinfo, cinfo->data_precision, return FALSE);
  INPUT_2BYTES(cinfo, cinfo->image_height, return FALSE);
  INPUT_2BYTES(cinfo, cinfo->image_width, return FALSE);
  INPUT_BYTE(cinfo, cinfo->num_components, return FALSE);
 
  length -= 8;
 
  TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker,
       (int) cinfo->image_width, (int) cinfo->image_height,
       cinfo->num_components);
 
  if (cinfo->marker->saw_SOF)
    ERREXIT(cinfo, JERR_SOF_DUPLICATE);
 
  /* We don't support files in which the image height is initially specified */
  /* as 0 and is later redefined by DNL.  As long as we have to check that,  */
  /* might as well have a general sanity check. */
  if (cinfo->image_height <= 0 || cinfo->image_width <= 0 ||
      cinfo->num_components <= 0)
    ERREXIT(cinfo, JERR_EMPTY_IMAGE);
 
  if (length != (cinfo->num_components * 3))
    ERREXIT(cinfo, JERR_BAD_LENGTH);
 
  if (cinfo->comp_info == NULL) /* do only once, even if suspend */
    cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small)
            ((j_common_ptr) cinfo, JPOOL_IMAGE,
             cinfo->num_components * SIZEOF(jpeg_component_info));
 
  for (ci = 0; ci < cinfo->num_components; ci++) {
    INPUT_BYTE(cinfo, c, return FALSE);
    /* Check to see whether component id has already been seen   */
    /* (in violation of the spec, but unfortunately seen in some */
    /* files).  If so, create "fake" component id equal to the   */
    /* max id seen so far + 1. */
    for (i = 0, compptr = cinfo->comp_info; i < ci; i++, compptr++) {
      if (c == compptr->component_id) {
    compptr = cinfo->comp_info;
    c = compptr->component_id;
    compptr++;
    for (i = 1; i < ci; i++, compptr++) {
      if (compptr->component_id > c) c = compptr->component_id;
    }
    c++;
    break;
      }
    }
    compptr->component_id = c;
    compptr->component_index = ci;
    INPUT_BYTE(cinfo, c, return FALSE);
    compptr->h_samp_factor = (c >> 4) & 15;
    compptr->v_samp_factor = (c     ) & 15;
    INPUT_BYTE(cinfo, compptr->quant_tbl_no, return FALSE);
 
    TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT,
         compptr->component_id, compptr->h_samp_factor,
         compptr->v_samp_factor, compptr->quant_tbl_no);
  }
 
  cinfo->marker->saw_SOF = TRUE;
 
  INPUT_SYNC(cinfo);
  return TRUE;
}

Referenced by read_markers().

get_soi()

get_soi

(

j_decompress_ptr

cinfo

)

Definition at line 199 of file jdmarker.c.

{
  int i;
  
  TRACEMS(cinfo, 1, JTRC_SOI);
 
  if (cinfo->marker->saw_SOI)
    ERREXIT(cinfo, JERR_SOI_DUPLICATE);
 
  /* Reset all parameters that are defined to be reset by SOI */
 
  for (i = 0; i < NUM_ARITH_TBLS; i++) {
    cinfo->arith_dc_L[i] = 0;
    cinfo->arith_dc_U[i] = 1;
    cinfo->arith_ac_K[i] = 5;
  }
  cinfo->restart_interval = 0;
 
  /* Set initial assumptions for colorspace etc */
 
  cinfo->jpeg_color_space = JCS_UNKNOWN;
  cinfo->color_transform = JCT_NONE;
  cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */
 
  cinfo->saw_JFIF_marker = FALSE;
  cinfo->JFIF_major_version = 1; /* set default JFIF APP0 values */
  cinfo->JFIF_minor_version = 1;
  cinfo->density_unit = 0;
  cinfo->X_density = 1;
  cinfo->Y_density = 1;
  cinfo->saw_Adobe_marker = FALSE;
  cinfo->Adobe_transform = 0;
 
  cinfo->marker->saw_SOI = TRUE;
 
  return TRUE;
}

Referenced by read_markers().

get_sos()

get_sos

(

j_decompress_ptr

cinfo

)

Definition at line 322 of file jdmarker.c.

{
  INT32 length;
  int c, ci, i, n;
  jpeg_component_info * compptr;
  INPUT_VARS(cinfo);
 
  if (! cinfo->marker->saw_SOF)
    ERREXITS(cinfo, JERR_SOF_BEFORE, "SOS");
 
  INPUT_2BYTES(cinfo, length, return FALSE);
 
  INPUT_BYTE(cinfo, n, return FALSE); /* Number of components */
 
  TRACEMS1(cinfo, 1, JTRC_SOS, n);
 
  if (length != (n * 2 + 6) || n > MAX_COMPS_IN_SCAN ||
      (n == 0 && !cinfo->progressive_mode))
      /* pseudo SOS marker only allowed in progressive mode */
    ERREXIT(cinfo, JERR_BAD_LENGTH);
 
  cinfo->comps_in_scan = n;
 
  /* Collect the component-spec parameters */
 
  for (i = 0; i < n; i++) {
    INPUT_BYTE(cinfo, c, return FALSE);
 
    /* Detect the case where component id's are not unique, and, if so, */
    /* create a fake component id using the same logic as in get_sof.   */
    /* Note:  This also ensures that all of the SOF components are      */
    /* referenced in the single scan case, which prevents access to     */
    /* uninitialized memory in later decoding stages. */
    for (ci = 0; ci < i; ci++) {
      if (c == cinfo->cur_comp_info[ci]->component_id) {
    c = cinfo->cur_comp_info[0]->component_id;
    for (ci = 1; ci < i; ci++) {
      compptr = cinfo->cur_comp_info[ci];
      if (compptr->component_id > c) c = compptr->component_id;
    }
    c++;
    break;
      }
    }
 
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
     ci++, compptr++) {
      if (c == compptr->component_id)
    goto id_found;
    }
 
    ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, c);
 
  id_found:
 
    cinfo->cur_comp_info[i] = compptr;
    INPUT_BYTE(cinfo, c, return FALSE);
    compptr->dc_tbl_no = (c >> 4) & 15;
    compptr->ac_tbl_no = (c     ) & 15;
 
    TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, compptr->component_id,
         compptr->dc_tbl_no, compptr->ac_tbl_no);
  }
 
  /* Collect the additional scan parameters Ss, Se, Ah/Al. */
  INPUT_BYTE(cinfo, c, return FALSE);
  cinfo->Ss = c;
  INPUT_BYTE(cinfo, c, return FALSE);
  cinfo->Se = c;
  INPUT_BYTE(cinfo, c, return FALSE);
  cinfo->Ah = (c >> 4) & 15;
  cinfo->Al = (c     ) & 15;
 
  TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se,
       cinfo->Ah, cinfo->Al);
 
  /* Prepare to scan data & restart markers */
  cinfo->marker->next_restart_num = 0;
 
  /* Count another (non-pseudo) SOS marker */
  if (n) cinfo->input_scan_number++;
 
  INPUT_SYNC(cinfo);
  return TRUE;
}

Referenced by read_markers().

jinit_marker_reader()

jinit_marker_reader

(

j_decompress_ptr

cinfo

)

Definition at line 1408 of file jdmarker.c.

{
  my_marker_ptr marker;
  int i;
 
  /* Create subobject in permanent pool */
  marker = (my_marker_ptr) (*cinfo->mem->alloc_small)
    ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_marker_reader));
  cinfo->marker = &marker->pub;
  /* Initialize public method pointers */
  marker->pub.reset_marker_reader = reset_marker_reader;
  marker->pub.read_markers = read_markers;
  marker->pub.read_restart_marker = read_restart_marker;
  /* Initialize COM/APPn processing.
   * By default, we examine and then discard APP0 and APP14,
   * but simply discard COM and all other APPn.
   */
  marker->process_COM = skip_variable;
  marker->length_limit_COM = 0;
  for (i = 0; i < 16; i++) {
    marker->process_APPn[i] = skip_variable;
    marker->length_limit_APPn[i] = 0;
  }
  marker->process_APPn[0] = get_interesting_appn;
  marker->process_APPn[14] = get_interesting_appn;
  /* Reset marker processing state */
  reset_marker_reader(cinfo);
}

Referenced by jpeg_CreateDecompress().

jpeg_resync_to_restart()

jpeg_resync_to_restart	(	j_decompress_ptr	cinfo,
		int	desired
	)

Definition at line 1338 of file jdmarker.c.

{
  int marker = cinfo->unread_marker;
  int action = 1;
  
  /* Always put up a warning. */
  WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired);
  
  /* Outer loop handles repeated decision after scanning forward. */
  for (;;) {
    if (marker < (int) M_SOF0)
      action = 2;       /* invalid marker */
    else if (marker < (int) M_RST0 || marker > (int) M_RST7)
      action = 3;       /* valid non-restart marker */
    else {
      if (marker == ((int) M_RST0 + ((desired+1) & 7)) ||
      marker == ((int) M_RST0 + ((desired+2) & 7)))
    action = 3;     /* one of the next two expected restarts */
      else if (marker == ((int) M_RST0 + ((desired-1) & 7)) ||
           marker == ((int) M_RST0 + ((desired-2) & 7)))
    action = 2;     /* a prior restart, so advance */
      else
    action = 1;     /* desired restart or too far away */
    }
    TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action);
    switch (action) {
    case 1:
      /* Discard marker and let entropy decoder resume processing. */
      cinfo->unread_marker = 0;
      return TRUE;
    case 2:
      /* Scan to the next marker, and repeat the decision loop. */
      if (! next_marker(cinfo))
    return FALSE;
      marker = cinfo->unread_marker;
      break;
    case 3:
      /* Return without advancing past this marker. */
      /* Entropy decoder will be forced to process an empty segment. */
      return TRUE;
    }
  } /* end loop */
}

Referenced by jpeg_mem_src(), and jpeg_stdio_src().

jpeg_set_marker_processor()

jpeg_set_marker_processor	(	j_decompress_ptr	cinfo,
		int	marker_code,
		jpeg_marker_parser_method	routine
	)

Definition at line 1494 of file jdmarker.c.

{
  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
 
  if (marker_code == (int) M_COM)
    marker->process_COM = routine;
  else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15)
    marker->process_APPn[marker_code - (int) M_APP0] = routine;
  else
    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
}

Referenced by main().

next_marker()

next_marker

(

j_decompress_ptr

cinfo

)

Definition at line 1007 of file jdmarker.c.

{
  int c;
  INPUT_VARS(cinfo);
 
  for (;;) {
    INPUT_BYTE(cinfo, c, return FALSE);
    /* Skip any non-FF bytes.
     * This may look a bit inefficient, but it will not occur in a valid file.
     * We sync after each discarded byte so that a suspending data source
     * can discard the byte from its buffer.
     */
    while (c != 0xFF) {
      cinfo->marker->discarded_bytes++;
      INPUT_SYNC(cinfo);
      INPUT_BYTE(cinfo, c, return FALSE);
    }
    /* This loop swallows any duplicate FF bytes.  Extra FFs are legal as
     * pad bytes, so don't count them in discarded_bytes.  We assume there
     * will not be so many consecutive FF bytes as to overflow a suspending
     * data source's input buffer.
     */
    do {
      INPUT_BYTE(cinfo, c, return FALSE);
    } while (c == 0xFF);
    if (c != 0)
      break;            /* found a valid marker, exit loop */
    /* Reach here if we found a stuffed-zero data sequence (FF/00).
     * Discard it and loop back to try again.
     */
    cinfo->marker->discarded_bytes += 2;
    INPUT_SYNC(cinfo);
  }
 
  if (cinfo->marker->discarded_bytes != 0) {
    WARNMS2(cinfo, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c);
    cinfo->marker->discarded_bytes = 0;
  }
 
  cinfo->unread_marker = c;
 
  INPUT_SYNC(cinfo);
  return TRUE;
}

read_markers()

read_markers

(

j_decompress_ptr

cinfo

)

Definition at line 1090 of file jdmarker.c.

{
  /* Outer loop repeats once for each marker. */
  for (;;) {
    /* Collect the marker proper, unless we already did. */
    /* NB: first_marker() enforces the requirement that SOI appear first. */
    if (cinfo->unread_marker == 0) {
      if (! cinfo->marker->saw_SOI) {
    if (! first_marker(cinfo))
      return JPEG_SUSPENDED;
      } else {
    if (! next_marker(cinfo))
      return JPEG_SUSPENDED;
      }
    }
    /* At this point cinfo->unread_marker contains the marker code and the
     * input point is just past the marker proper, but before any parameters.
     * A suspension will cause us to return with this state still true.
     */
    switch (cinfo->unread_marker) {
    case M_SOI:
      if (! get_soi(cinfo))
    return JPEG_SUSPENDED;
      break;
 
    case M_SOF0:        /* Baseline */
      if (! get_sof(cinfo, TRUE, FALSE, FALSE))
    return JPEG_SUSPENDED;
      break;
 
    case M_SOF1:        /* Extended sequential, Huffman */
      if (! get_sof(cinfo, FALSE, FALSE, FALSE))
    return JPEG_SUSPENDED;
      break;
 
    case M_SOF2:        /* Progressive, Huffman */
      if (! get_sof(cinfo, FALSE, TRUE, FALSE))
    return JPEG_SUSPENDED;
      break;
 
    case M_SOF9:        /* Extended sequential, arithmetic */
      if (! get_sof(cinfo, FALSE, FALSE, TRUE))
    return JPEG_SUSPENDED;
      break;
 
    case M_SOF10:       /* Progressive, arithmetic */
      if (! get_sof(cinfo, FALSE, TRUE, TRUE))
    return JPEG_SUSPENDED;
      break;
 
    /* Currently unsupported SOFn types */
    case M_SOF3:        /* Lossless, Huffman */
    case M_SOF5:        /* Differential sequential, Huffman */
    case M_SOF6:        /* Differential progressive, Huffman */
    case M_SOF7:        /* Differential lossless, Huffman */
    case M_JPG:         /* Reserved for JPEG extensions */
    case M_SOF11:       /* Lossless, arithmetic */
    case M_SOF13:       /* Differential sequential, arithmetic */
    case M_SOF14:       /* Differential progressive, arithmetic */
    case M_SOF15:       /* Differential lossless, arithmetic */
      ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker);
      break;
 
    case M_SOS:
      if (! get_sos(cinfo))
    return JPEG_SUSPENDED;
      cinfo->unread_marker = 0; /* processed the marker */
      return JPEG_REACHED_SOS;
 
    case M_EOI:
      TRACEMS(cinfo, 1, JTRC_EOI);
      cinfo->unread_marker = 0; /* processed the marker */
      return JPEG_REACHED_EOI;
 
    case M_DAC:
      if (! get_dac(cinfo))
    return JPEG_SUSPENDED;
      break;
 
    case M_DHT:
      if (! get_dht(cinfo))
    return JPEG_SUSPENDED;
      break;
 
    case M_DQT:
      if (! get_dqt(cinfo))
    return JPEG_SUSPENDED;
      break;
 
    case M_DRI:
      if (! get_dri(cinfo))
    return JPEG_SUSPENDED;
      break;
 
    case M_JPG8:
      if (! get_lse(cinfo))
    return JPEG_SUSPENDED;
      break;
 
    case M_APP0:
    case M_APP1:
    case M_APP2:
    case M_APP3:
    case M_APP4:
    case M_APP5:
    case M_APP6:
    case M_APP7:
    case M_APP8:
    case M_APP9:
    case M_APP10:
    case M_APP11:
    case M_APP12:
    case M_APP13:
    case M_APP14:
    case M_APP15:
      if (! (*((my_marker_ptr) cinfo->marker)->process_APPn[
        cinfo->unread_marker - (int) M_APP0]) (cinfo))
    return JPEG_SUSPENDED;
      break;
 
    case M_COM:
      if (! (*((my_marker_ptr) cinfo->marker)->process_COM) (cinfo))
    return JPEG_SUSPENDED;
      break;
 
    case M_RST0:        /* these are all parameterless */
    case M_RST1:
    case M_RST2:
    case M_RST3:
    case M_RST4:
    case M_RST5:
    case M_RST6:
    case M_RST7:
    case M_TEM:
      TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker);
      break;
 
    case M_DNL:         /* Ignore DNL ... perhaps the wrong thing */
      if (! skip_variable(cinfo))
    return JPEG_SUSPENDED;
      break;
 
    default:            /* must be DHP, EXP, JPGn, or RESn */
      /* For now, we treat the reserved markers as fatal errors since they are
       * likely to be used to signal incompatible JPEG Part 3 extensions.
       * Once the JPEG 3 version-number marker is well defined, this code
       * ought to change!
       */
      ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
    }
    /* Successfully processed marker, so reset state variable */
    cinfo->unread_marker = 0;
  } /* end loop */
}

Referenced by jinit_marker_reader().

read_restart_marker()

read_restart_marker

(

j_decompress_ptr

cinfo

)

Definition at line 1259 of file jdmarker.c.

{
  /* Obtain a marker unless we already did. */
  /* Note that next_marker will complain if it skips any data. */
  if (cinfo->unread_marker == 0) {
    if (! next_marker(cinfo))
      return FALSE;
  }
 
  if (cinfo->unread_marker ==
      ((int) M_RST0 + cinfo->marker->next_restart_num)) {
    /* Normal case --- swallow the marker and let entropy decoder continue */
    TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num);
    cinfo->unread_marker = 0;
  } else {
    /* Uh-oh, the restart markers have been messed up. */
    /* Let the data source manager determine how to resync. */
    if (! (*cinfo->src->resync_to_restart) (cinfo,
                        cinfo->marker->next_restart_num))
      return FALSE;
  }
 
  /* Update next-restart state */
  cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7;
 
  return TRUE;
}

Referenced by jinit_marker_reader().

reset_marker_reader()

reset_marker_reader

(

j_decompress_ptr

cinfo

)

Definition at line 1388 of file jdmarker.c.

{
  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
 
  cinfo->comp_info = NULL;      /* until allocated by get_sof */
  cinfo->input_scan_number = 0;     /* no SOS seen yet */
  cinfo->unread_marker = 0;     /* no pending marker */
  marker->pub.saw_SOI = FALSE;      /* set internal state too */
  marker->pub.saw_SOF = FALSE;
  marker->pub.discarded_bytes = 0;
  marker->cur_marker = NULL;
}

Referenced by jinit_marker_reader().

skip_variable()

skip_variable

(

j_decompress_ptr

cinfo

)

Definition at line 978 of file jdmarker.c.

{
  INT32 length;
  INPUT_VARS(cinfo);
 
  INPUT_2BYTES(cinfo, length, return FALSE);
  length -= 2;
  
  TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length);
 
  INPUT_SYNC(cinfo);        /* do before skip_input_data */
  if (length > 0)
    (*cinfo->src->skip_input_data) (cinfo, (long) length);
 
  return TRUE;
}