ReactOS 0.4.15-dev-8207-gd73a838
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_readermy_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:
bytes_in_buffer--; \
V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \
MAKE_BYTE_AVAIL(cinfo,action); \
bytes_in_buffer--; \
V += GETJOCTET(*next_input_byte++); )
const WCHAR * action
Definition: action.c:7479
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define MAKE_BYTE_AVAIL(cinfo, action)
Definition: jdmarker.c:140
#define MAKESTMT(stuff)
Definition: jerror.h:248
#define GETJOCTET(value)
Definition: jmorecfg.h:171

Definition at line 158 of file jdmarker.c.

◆ INPUT_BYTE

#define INPUT_BYTE (   cinfo,
  V,
  action 
)
Value:
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
GLenum src
Definition: glext.h:6340
char JOCTET
Definition: jmorecfg.h:167
size_t bytes_in_buffer
Definition: jpeglib.h:786
const JOCTET * next_input_byte
Definition: jpeglib.h:785

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

Definition at line 109 of file jdmarker.c.

Enumeration Type Documentation

◆ 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.

21 { /* JPEG marker codes */
22 M_SOF0 = 0xc0,
23 M_SOF1 = 0xc1,
24 M_SOF2 = 0xc2,
25 M_SOF3 = 0xc3,
26
27 M_SOF5 = 0xc5,
28 M_SOF6 = 0xc6,
29 M_SOF7 = 0xc7,
30
31 M_JPG = 0xc8,
32 M_SOF9 = 0xc9,
33 M_SOF10 = 0xca,
34 M_SOF11 = 0xcb,
35
36 M_SOF13 = 0xcd,
37 M_SOF14 = 0xce,
38 M_SOF15 = 0xcf,
39
40 M_DHT = 0xc4,
41
42 M_DAC = 0xcc,
43
44 M_RST0 = 0xd0,
45 M_RST1 = 0xd1,
46 M_RST2 = 0xd2,
47 M_RST3 = 0xd3,
48 M_RST4 = 0xd4,
49 M_RST5 = 0xd5,
50 M_RST6 = 0xd6,
51 M_RST7 = 0xd7,
52
53 M_SOI = 0xd8,
54 M_EOI = 0xd9,
55 M_SOS = 0xda,
56 M_DQT = 0xdb,
57 M_DNL = 0xdc,
58 M_DRI = 0xdd,
59 M_DHP = 0xde,
60 M_EXP = 0xdf,
61
62 M_APP0 = 0xe0,
63 M_APP1 = 0xe1,
64 M_APP2 = 0xe2,
65 M_APP3 = 0xe3,
66 M_APP4 = 0xe4,
67 M_APP5 = 0xe5,
68 M_APP6 = 0xe6,
69 M_APP7 = 0xe7,
70 M_APP8 = 0xe8,
71 M_APP9 = 0xe9,
72 M_APP10 = 0xea,
73 M_APP11 = 0xeb,
74 M_APP12 = 0xec,
75 M_APP13 = 0xed,
76 M_APP14 = 0xee,
77 M_APP15 = 0xef,
78
79 M_JPG0 = 0xf0,
80 M_JPG8 = 0xf8,
81 M_JPG13 = 0xfd,
82 M_COM = 0xfe,
83
84 M_TEM = 0x01,
85
86 M_ERROR = 0x100
JPEG_MARKER
Definition: jdmarker.c:21
@ M_RST4
Definition: jdmarker.c:48
@ M_COM
Definition: jdmarker.c:82
@ M_RST5
Definition: jdmarker.c:49
@ M_DNL
Definition: jdmarker.c:57
@ M_SOF14
Definition: jdmarker.c:37
@ M_APP3
Definition: jdmarker.c:65
@ M_SOF7
Definition: jdmarker.c:29
@ M_EOI
Definition: jdmarker.c:54
@ M_APP11
Definition: jdmarker.c:73
@ M_JPG8
Definition: jdmarker.c:80
@ M_APP1
Definition: jdmarker.c:63
@ M_APP12
Definition: jdmarker.c:74
@ M_APP2
Definition: jdmarker.c:64
@ M_APP13
Definition: jdmarker.c:75
@ M_RST3
Definition: jdmarker.c:47
@ M_APP9
Definition: jdmarker.c:71
@ M_DQT
Definition: jdmarker.c:56
@ M_DHT
Definition: jdmarker.c:40
@ M_SOF3
Definition: jdmarker.c:25
@ M_SOF2
Definition: jdmarker.c:24
@ M_APP14
Definition: jdmarker.c:76
@ M_DAC
Definition: jdmarker.c:42
@ M_SOF6
Definition: jdmarker.c:28
@ M_APP6
Definition: jdmarker.c:68
@ M_RST0
Definition: jdmarker.c:44
@ M_APP8
Definition: jdmarker.c:70
@ M_SOF15
Definition: jdmarker.c:38
@ M_SOI
Definition: jdmarker.c:53
@ M_RST7
Definition: jdmarker.c:51
@ M_DRI
Definition: jdmarker.c:58
@ M_SOF9
Definition: jdmarker.c:32
@ M_JPG
Definition: jdmarker.c:31
@ M_APP10
Definition: jdmarker.c:72
@ M_SOF10
Definition: jdmarker.c:33
@ M_SOF11
Definition: jdmarker.c:34
@ M_TEM
Definition: jdmarker.c:84
@ M_EXP
Definition: jdmarker.c:60
@ M_SOF13
Definition: jdmarker.c:36
@ M_JPG0
Definition: jdmarker.c:79
@ M_RST6
Definition: jdmarker.c:50
@ M_APP4
Definition: jdmarker.c:66
@ M_APP5
Definition: jdmarker.c:67
@ M_SOF1
Definition: jdmarker.c:23
@ M_SOS
Definition: jdmarker.c:55
@ M_APP7
Definition: jdmarker.c:69
@ M_SOF0
Definition: jdmarker.c:22
@ M_APP0
Definition: jdmarker.c:62
@ M_APP15
Definition: jdmarker.c:77
@ M_RST2
Definition: jdmarker.c:46
@ M_SOF5
Definition: jdmarker.c:27
@ M_RST1
Definition: jdmarker.c:45
@ M_JPG13
Definition: jdmarker.c:81
@ M_ERROR
Definition: jdmarker.c:86
@ M_DHP
Definition: jdmarker.c:59

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.

725{
726 INT32 totallen = (INT32) datalen + remaining;
727
728 if (datalen >= APP0_DATA_LEN &&
729 GETJOCTET(data[0]) == 0x4A &&
730 GETJOCTET(data[1]) == 0x46 &&
731 GETJOCTET(data[2]) == 0x49 &&
732 GETJOCTET(data[3]) == 0x46 &&
733 GETJOCTET(data[4]) == 0) {
734 /* Found JFIF APP0 marker: save info */
735 cinfo->saw_JFIF_marker = TRUE;
736 cinfo->JFIF_major_version = GETJOCTET(data[5]);
737 cinfo->JFIF_minor_version = GETJOCTET(data[6]);
738 cinfo->density_unit = GETJOCTET(data[7]);
739 cinfo->X_density = (GETJOCTET(data[8]) << 8) + GETJOCTET(data[9]);
740 cinfo->Y_density = (GETJOCTET(data[10]) << 8) + GETJOCTET(data[11]);
741 /* Check version.
742 * Major version must be 1 or 2, anything else signals an incompatible
743 * change.
744 * (We used to treat this as an error, but now it's a nonfatal warning,
745 * because some bozo at Hijaak couldn't read the spec.)
746 * Minor version should be 0..2, but process anyway if newer.
747 */
748 if (cinfo->JFIF_major_version != 1 && cinfo->JFIF_major_version != 2)
749 WARNMS2(cinfo, JWRN_JFIF_MAJOR,
751 /* Generate trace messages */
752 TRACEMS5(cinfo, 1, JTRC_JFIF,
754 cinfo->X_density, cinfo->Y_density, cinfo->density_unit);
755 /* Validate thumbnail dimensions and issue appropriate messages */
756 if (GETJOCTET(data[12]) | GETJOCTET(data[13]))
757 TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL,
758 GETJOCTET(data[12]), GETJOCTET(data[13]));
759 totallen -= APP0_DATA_LEN;
760 if (totallen !=
761 ((INT32)GETJOCTET(data[12]) * (INT32)GETJOCTET(data[13]) * (INT32) 3))
762 TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) totallen);
763 } else if (datalen >= 6 &&
764 GETJOCTET(data[0]) == 0x4A &&
765 GETJOCTET(data[1]) == 0x46 &&
766 GETJOCTET(data[2]) == 0x58 &&
767 GETJOCTET(data[3]) == 0x58 &&
768 GETJOCTET(data[4]) == 0) {
769 /* Found JFIF "JFXX" extension APP0 marker */
770 /* The library doesn't actually do anything with these,
771 * but we try to produce a helpful trace message.
772 */
773 switch (GETJOCTET(data[5])) {
774 case 0x10:
775 TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int) totallen);
776 break;
777 case 0x11:
778 TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int) totallen);
779 break;
780 case 0x13:
781 TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int) totallen);
782 break;
783 default:
784 TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION,
785 GETJOCTET(data[5]), (int) totallen);
786 }
787 } else {
788 /* Start of APP0 does not match "JFIF" or "JFXX", or too short */
789 TRACEMS1(cinfo, 1, JTRC_APP0, (int) totallen);
790 }
791}
signed int INT32
#define TRUE
Definition: types.h:120
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define APP0_DATA_LEN
Definition: jdmarker.c:713
#define WARNMS2(cinfo, code, p1, p2)
Definition: jerror.h:258
#define TRACEMS1(cinfo, lvl, code, p1)
Definition: jerror.h:268
#define TRACEMS5(cinfo, lvl, code, p1, p2, p3, p4, p5)
Definition: jerror.h:287
#define TRACEMS2(cinfo, lvl, code, p1, p2)
Definition: jerror.h:272
int const JOCTET unsigned int datalen
Definition: jpeglib.h:1031
boolean saw_JFIF_marker
Definition: jpeglib.h:599

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.

801{
802 unsigned int version, flags0, flags1, transform;
803
804 if (datalen >= APP14_DATA_LEN &&
805 GETJOCTET(data[0]) == 0x41 &&
806 GETJOCTET(data[1]) == 0x64 &&
807 GETJOCTET(data[2]) == 0x6F &&
808 GETJOCTET(data[3]) == 0x62 &&
809 GETJOCTET(data[4]) == 0x65) {
810 /* Found Adobe APP14 marker */
811 version = (GETJOCTET(data[5]) << 8) + GETJOCTET(data[6]);
812 flags0 = (GETJOCTET(data[7]) << 8) + GETJOCTET(data[8]);
813 flags1 = (GETJOCTET(data[9]) << 8) + GETJOCTET(data[10]);
814 transform = GETJOCTET(data[11]);
815 TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform);
816 cinfo->saw_Adobe_marker = TRUE;
818 } else {
819 /* Start of APP14 does not match "Adobe", or too short */
820 TRACEMS1(cinfo, 1, JTRC_APP14, (int) (datalen + remaining));
821 }
822}
unsigned char UINT8
static const WCHAR version[]
Definition: asmname.c:66
GLuint GLenum GLenum transform
Definition: glext.h:9407
#define APP14_DATA_LEN
Definition: jdmarker.c:714
#define TRACEMS4(cinfo, lvl, code, p1, p2, p3, p4)
Definition: jerror.h:282
boolean saw_Adobe_marker
Definition: jpeglib.h:606

Referenced by get_interesting_appn().

◆ first_marker()

first_marker ( j_decompress_ptr  cinfo)

Definition at line 1054 of file jdmarker.c.

1061{
1062 int c, c2;
1063 INPUT_VARS(cinfo);
1064
1065 INPUT_BYTE(cinfo, c, return FALSE);
1066 INPUT_BYTE(cinfo, c2, return FALSE);
1067 if (c != 0xFF || c2 != (int) M_SOI)
1068 ERREXIT2(cinfo, JERR_NO_SOI, c, c2);
1069
1070 cinfo->unread_marker = c2;
1071
1072 INPUT_SYNC(cinfo);
1073 return TRUE;
1074}
#define FALSE
Definition: types.h:117
const GLubyte * c
Definition: glext.h:8905
#define INPUT_BYTE(cinfo, V, action)
Definition: jdmarker.c:150
#define INPUT_VARS(cinfo)
Definition: jdmarker.c:121
#define INPUT_SYNC(cinfo)
Definition: jdmarker.c:127
#define ERREXIT2(cinfo, code, p1, p2)
Definition: jerror.h:216
#define c
Definition: ke_i.h:80

◆ get_dht()

get_dht ( j_decompress_ptr  cinfo)

Definition at line 459 of file jdmarker.c.

461{
463 UINT8 bits[17];
464 UINT8 huffval[256];
465 int i, index, count;
466 JHUFF_TBL **htblptr;
467 INPUT_VARS(cinfo);
468
469 INPUT_2BYTES(cinfo, length, return FALSE);
470 length -= 2;
471
472 while (length > 16) {
473 INPUT_BYTE(cinfo, index, return FALSE);
474
475 TRACEMS1(cinfo, 1, JTRC_DHT, index);
476
477 bits[0] = 0;
478 count = 0;
479 for (i = 1; i <= 16; i++) {
480 INPUT_BYTE(cinfo, bits[i], return FALSE);
481 count += bits[i];
482 }
483
484 length -= 1 + 16;
485
486 TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
487 bits[1], bits[2], bits[3], bits[4],
488 bits[5], bits[6], bits[7], bits[8]);
489 TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
490 bits[9], bits[10], bits[11], bits[12],
491 bits[13], bits[14], bits[15], bits[16]);
492
493 /* Here we just do minimal validation of the counts to avoid walking
494 * off the end of our table space. jdhuff.c will check more carefully.
495 */
496 if (count > 256 || ((INT32) count) > length)
497 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
498
499 for (i = 0; i < count; i++)
500 INPUT_BYTE(cinfo, huffval[i], return FALSE);
501
502 length -= count;
503
504 if (index & 0x10) { /* AC table definition */
505 index -= 0x10;
506 htblptr = &cinfo->ac_huff_tbl_ptrs[index];
507 } else { /* DC table definition */
508 htblptr = &cinfo->dc_huff_tbl_ptrs[index];
509 }
510
511 if (index < 0 || index >= NUM_HUFF_TBLS)
512 ERREXIT1(cinfo, JERR_DHT_INDEX, index);
513
514 if (*htblptr == NULL)
515 *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
516
517 MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
518 if (count > 0)
519 MEMCOPY((*htblptr)->huffval, huffval, count * SIZEOF(UINT8));
520 }
521
522 if (length != 0)
523 ERREXIT(cinfo, JERR_BAD_LENGTH);
524
525 INPUT_SYNC(cinfo);
526 return TRUE;
527}
#define index(s, c)
Definition: various.h:29
#define SIZEOF(_ar)
Definition: calc.h:97
#define NULL
Definition: types.h:112
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLuint index
Definition: glext.h:6031
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
jpeg_alloc_huff_table(j_common_ptr cinfo)
Definition: jcomapi.c:99
#define INPUT_2BYTES(cinfo, V, action)
Definition: jdmarker.c:158
#define TRACEMS8(cinfo, lvl, code, p1, p2, p3, p4, p5, p6, p7, p8)
Definition: jerror.h:293
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
#define MEMCOPY(dest, src, size)
Definition: jinclude.h:69
#define NUM_HUFF_TBLS
Definition: jpeglib.h:53
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]
Definition: jpeglib.h:573
JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]
Definition: jpeglib.h:574

Referenced by read_markers().

◆ get_dqt()

get_dqt ( j_decompress_ptr  cinfo)

Definition at line 531 of file jdmarker.c.

533{
535 int n, prec;
536 unsigned int tmp;
537 JQUANT_TBL *quant_ptr;
538 const int *natural_order;
539 INPUT_VARS(cinfo);
540
541 INPUT_2BYTES(cinfo, length, return FALSE);
542 length -= 2;
543
544 while (length > 0) {
545 length--;
546 INPUT_BYTE(cinfo, n, return FALSE);
547 prec = n >> 4;
548 n &= 0x0F;
549
550 TRACEMS2(cinfo, 1, JTRC_DQT, n, prec);
551
552 if (n >= NUM_QUANT_TBLS)
553 ERREXIT1(cinfo, JERR_DQT_INDEX, n);
554
555 if (cinfo->quant_tbl_ptrs[n] == NULL)
557 quant_ptr = cinfo->quant_tbl_ptrs[n];
558
559 if (prec) {
560 if (length < DCTSIZE2 * 2) {
561 /* Initialize full table for safety. */
562 for (i = 0; i < DCTSIZE2; i++) {
563 quant_ptr->quantval[i] = 1;
564 }
565 count = length >> 1;
566 } else
567 count = DCTSIZE2;
568 } else {
569 if (length < DCTSIZE2) {
570 /* Initialize full table for safety. */
571 for (i = 0; i < DCTSIZE2; i++) {
572 quant_ptr->quantval[i] = 1;
573 }
574 count = length;
575 } else
576 count = DCTSIZE2;
577 }
578
579 switch ((int) count) {
580 case (2*2): natural_order = jpeg_natural_order2; break;
581 case (3*3): natural_order = jpeg_natural_order3; break;
582 case (4*4): natural_order = jpeg_natural_order4; break;
583 case (5*5): natural_order = jpeg_natural_order5; break;
584 case (6*6): natural_order = jpeg_natural_order6; break;
585 case (7*7): natural_order = jpeg_natural_order7; break;
586 default: natural_order = jpeg_natural_order;
587 }
588
589 for (i = 0; i < count; i++) {
590 if (prec)
591 INPUT_2BYTES(cinfo, tmp, return FALSE);
592 else
593 INPUT_BYTE(cinfo, tmp, return FALSE);
594 /* We convert the zigzag-order table to natural array order. */
595 quant_ptr->quantval[natural_order[i]] = (UINT16) tmp;
596 }
597
598 if (cinfo->err->trace_level >= 2) {
599 for (i = 0; i < DCTSIZE2; i += 8) {
600 TRACEMS8(cinfo, 2, JTRC_QUANTVALS,
601 quant_ptr->quantval[i], quant_ptr->quantval[i+1],
602 quant_ptr->quantval[i+2], quant_ptr->quantval[i+3],
603 quant_ptr->quantval[i+4], quant_ptr->quantval[i+5],
604 quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]);
605 }
606 }
607
608 length -= count;
609 if (prec) length -= count;
610 }
611
612 if (length != 0)
613 ERREXIT(cinfo, JERR_BAD_LENGTH);
614
615 INPUT_SYNC(cinfo);
616 return TRUE;
617}
unsigned short UINT16
GLdouble n
Definition: glext.h:7729
jpeg_alloc_quant_table(j_common_ptr cinfo)
Definition: jcomapi.c:87
#define NUM_QUANT_TBLS
Definition: jpeglib.h:52
#define DCTSIZE2
Definition: jpeglib.h:51
const int jpeg_natural_order4[4 *4+16]
Definition: jutils.c:98
const int jpeg_natural_order[DCTSIZE2+16]
Definition: jutils.c:54
const int jpeg_natural_order2[2 *2+16]
Definition: jutils.c:112
const int jpeg_natural_order5[5 *5+16]
Definition: jutils.c:89
const int jpeg_natural_order7[7 *7+16]
Definition: jutils.c:67
const int jpeg_natural_order6[6 *6+16]
Definition: jutils.c:79
const int jpeg_natural_order3[3 *3+16]
Definition: jutils.c:105
UINT16 quantval[DCTSIZE2]
Definition: jpeglib.h:97
JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]
Definition: jpeglib.h:570

Referenced by read_markers().

◆ get_dri()

get_dri ( j_decompress_ptr  cinfo)

Definition at line 621 of file jdmarker.c.

623{
625 unsigned int tmp;
626 INPUT_VARS(cinfo);
627
628 INPUT_2BYTES(cinfo, length, return FALSE);
629
630 if (length != 4)
631 ERREXIT(cinfo, JERR_BAD_LENGTH);
632
633 INPUT_2BYTES(cinfo, tmp, return FALSE);
634
635 TRACEMS1(cinfo, 1, JTRC_DRI, tmp);
636
637 cinfo->restart_interval = tmp;
638
639 INPUT_SYNC(cinfo);
640 return TRUE;
641}
unsigned int restart_interval
Definition: jpeglib.h:594

Referenced by read_markers().

◆ get_interesting_appn()

get_interesting_appn ( j_decompress_ptr  cinfo)

Definition at line 826 of file jdmarker.c.

828{
831 unsigned int i, numtoread;
832 INPUT_VARS(cinfo);
833
834 INPUT_2BYTES(cinfo, length, return FALSE);
835 length -= 2;
836
837 /* get the interesting part of the marker data */
838 if (length >= APPN_DATA_LEN)
839 numtoread = APPN_DATA_LEN;
840 else if (length > 0)
841 numtoread = (unsigned int) length;
842 else
843 numtoread = 0;
844 for (i = 0; i < numtoread; i++)
845 INPUT_BYTE(cinfo, b[i], return FALSE);
846 length -= numtoread;
847
848 /* process it */
849 switch (cinfo->unread_marker) {
850 case M_APP0:
851 examine_app0(cinfo, (JOCTET FAR *) b, numtoread, length);
852 break;
853 case M_APP14:
854 examine_app14(cinfo, (JOCTET FAR *) b, numtoread, length);
855 break;
856 default:
857 /* can't get here unless jpeg_save_markers chooses wrong processor */
858 ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
859 }
860
861 /* skip any remaining data -- could be lots */
862 INPUT_SYNC(cinfo);
863 if (length > 0)
864 (*cinfo->src->skip_input_data) (cinfo, (long) length);
865
866 return TRUE;
867}
#define FAR
Definition: zlib.h:34
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
examine_app0(j_decompress_ptr cinfo, JOCTET FAR *data, unsigned int datalen, INT32 remaining)
Definition: jdmarker.c:719
#define APPN_DATA_LEN
Definition: jdmarker.c:715
examine_app14(j_decompress_ptr cinfo, JOCTET FAR *data, unsigned int datalen, INT32 remaining)
Definition: jdmarker.c:795
struct jpeg_source_mgr * src
Definition: jpeglib.h:463

Referenced by jinit_marker_reader().

◆ get_lse()

get_lse ( j_decompress_ptr  cinfo)

Definition at line 645 of file jdmarker.c.

647{
649 unsigned int tmp;
650 int cid;
651 INPUT_VARS(cinfo);
652
653 if (! cinfo->marker->saw_SOF)
654 ERREXITS(cinfo, JERR_SOF_BEFORE, "LSE");
655
656 if (cinfo->num_components < 3) goto bad;
657
658 INPUT_2BYTES(cinfo, length, return FALSE);
659
660 if (length != 24)
661 ERREXIT(cinfo, JERR_BAD_LENGTH);
662
663 INPUT_BYTE(cinfo, tmp, return FALSE);
664 if (tmp != 0x0D) /* ID inverse transform specification */
665 ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
666 INPUT_2BYTES(cinfo, tmp, return FALSE);
667 if (tmp != MAXJSAMPLE) goto bad; /* MAXTRANS */
668 INPUT_BYTE(cinfo, tmp, return FALSE);
669 if (tmp != 3) goto bad; /* Nt=3 */
670 INPUT_BYTE(cinfo, cid, return FALSE);
671 if (cid != cinfo->comp_info[1].component_id) goto bad;
672 INPUT_BYTE(cinfo, cid, return FALSE);
673 if (cid != cinfo->comp_info[0].component_id) goto bad;
674 INPUT_BYTE(cinfo, cid, return FALSE);
675 if (cid != cinfo->comp_info[2].component_id) goto bad;
676 INPUT_BYTE(cinfo, tmp, return FALSE);
677 if (tmp != 0x80) goto bad; /* F1: CENTER1=1, NORM1=0 */
678 INPUT_2BYTES(cinfo, tmp, return FALSE);
679 if (tmp != 0) goto bad; /* A(1,1)=0 */
680 INPUT_2BYTES(cinfo, tmp, return FALSE);
681 if (tmp != 0) goto bad; /* A(1,2)=0 */
682 INPUT_BYTE(cinfo, tmp, return FALSE);
683 if (tmp != 0) goto bad; /* F2: CENTER2=0, NORM2=0 */
684 INPUT_2BYTES(cinfo, tmp, return FALSE);
685 if (tmp != 1) goto bad; /* A(2,1)=1 */
686 INPUT_2BYTES(cinfo, tmp, return FALSE);
687 if (tmp != 0) goto bad; /* A(2,2)=0 */
688 INPUT_BYTE(cinfo, tmp, return FALSE);
689 if (tmp != 0) goto bad; /* F3: CENTER3=0, NORM3=0 */
690 INPUT_2BYTES(cinfo, tmp, return FALSE);
691 if (tmp != 1) goto bad; /* A(3,1)=1 */
692 INPUT_2BYTES(cinfo, tmp, return FALSE);
693 if (tmp != 0) { /* A(3,2)=0 */
694 bad:
695 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
696 }
697
698 /* OK, valid transform that we can handle. */
700
701 INPUT_SYNC(cinfo);
702 return TRUE;
703}
#define ERREXITS(cinfo, code, str)
Definition: jerror.h:243
#define MAXJSAMPLE
Definition: jmorecfg.h:83
@ JCT_SUBTRACT_GREEN
Definition: jpeglib.h:235
static TfClientId cid
struct jpeg_marker_reader * marker
Definition: jpeglib.h:683
J_COLOR_TRANSFORM color_transform
Definition: jpeglib.h:609
jpeg_component_info * comp_info
Definition: jpeglib.h:583

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.

243{
245 int c, ci, i;
247 INPUT_VARS(cinfo);
248
249 cinfo->is_baseline = is_baseline;
250 cinfo->progressive_mode = is_prog;
251 cinfo->arith_code = is_arith;
252
253 INPUT_2BYTES(cinfo, length, return FALSE);
254
255 INPUT_BYTE(cinfo, cinfo->data_precision, return FALSE);
256 INPUT_2BYTES(cinfo, cinfo->image_height, return FALSE);
257 INPUT_2BYTES(cinfo, cinfo->image_width, return FALSE);
258 INPUT_BYTE(cinfo, cinfo->num_components, return FALSE);
259
260 length -= 8;
261
262 TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker,
263 (int) cinfo->image_width, (int) cinfo->image_height,
264 cinfo->num_components);
265
266 if (cinfo->marker->saw_SOF)
267 ERREXIT(cinfo, JERR_SOF_DUPLICATE);
268
269 /* We don't support files in which the image height is initially specified */
270 /* as 0 and is later redefined by DNL. As long as we have to check that, */
271 /* might as well have a general sanity check. */
272 if (cinfo->image_height <= 0 || cinfo->image_width <= 0 ||
273 cinfo->num_components <= 0)
274 ERREXIT(cinfo, JERR_EMPTY_IMAGE);
275
276 if (length != (cinfo->num_components * 3))
277 ERREXIT(cinfo, JERR_BAD_LENGTH);
278
279 if (cinfo->comp_info == NULL) /* do only once, even if suspend */
280 cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small)
281 ((j_common_ptr) cinfo, JPOOL_IMAGE,
283
284 for (ci = 0; ci < cinfo->num_components; ci++) {
285 INPUT_BYTE(cinfo, c, return FALSE);
286 /* Check to see whether component id has already been seen */
287 /* (in violation of the spec, but unfortunately seen in some */
288 /* files). If so, create "fake" component id equal to the */
289 /* max id seen so far + 1. */
290 for (i = 0, compptr = cinfo->comp_info; i < ci; i++, compptr++) {
291 if (c == compptr->component_id) {
292 compptr = cinfo->comp_info;
294 compptr++;
295 for (i = 1; i < ci; i++, compptr++) {
297 }
298 c++;
299 break;
300 }
301 }
304 INPUT_BYTE(cinfo, c, return FALSE);
305 compptr->h_samp_factor = (c >> 4) & 15;
306 compptr->v_samp_factor = (c ) & 15;
307 INPUT_BYTE(cinfo, compptr->quant_tbl_no, return FALSE);
308
309 TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT,
312 }
313
314 cinfo->marker->saw_SOF = TRUE;
315
316 INPUT_SYNC(cinfo);
317 return TRUE;
318}
jpeg_component_info * compptr
Definition: jdct.h:238
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
#define JPOOL_IMAGE
Definition: jpeglib.h:808
JDIMENSION image_width
Definition: jpeglib.h:468
boolean progressive_mode
Definition: jpeglib.h:587
JDIMENSION image_height
Definition: jpeglib.h:469

Referenced by read_markers().

◆ get_soi()

get_soi ( j_decompress_ptr  cinfo)

Definition at line 199 of file jdmarker.c.

201{
202 int i;
203
204 TRACEMS(cinfo, 1, JTRC_SOI);
205
206 if (cinfo->marker->saw_SOI)
207 ERREXIT(cinfo, JERR_SOI_DUPLICATE);
208
209 /* Reset all parameters that are defined to be reset by SOI */
210
211 for (i = 0; i < NUM_ARITH_TBLS; i++) {
212 cinfo->arith_dc_L[i] = 0;
213 cinfo->arith_dc_U[i] = 1;
214 cinfo->arith_ac_K[i] = 5;
215 }
216 cinfo->restart_interval = 0;
217
218 /* Set initial assumptions for colorspace etc */
219
221 cinfo->color_transform = JCT_NONE;
222 cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */
223
224 cinfo->saw_JFIF_marker = FALSE;
225 cinfo->JFIF_major_version = 1; /* set default JFIF APP0 values */
226 cinfo->JFIF_minor_version = 1;
227 cinfo->density_unit = 0;
228 cinfo->X_density = 1;
229 cinfo->Y_density = 1;
230 cinfo->saw_Adobe_marker = FALSE;
231 cinfo->Adobe_transform = 0;
232
233 cinfo->marker->saw_SOI = TRUE;
234
235 return TRUE;
236}
#define TRACEMS(cinfo, lvl, code)
Definition: jerror.h:265
@ JCT_NONE
Definition: jpeglib.h:234
#define NUM_ARITH_TBLS
Definition: jpeglib.h:54
@ JCS_UNKNOWN
Definition: jpeglib.h:221
boolean CCIR601_sampling
Definition: jpeglib.h:612
UINT8 arith_dc_L[NUM_ARITH_TBLS]
Definition: jpeglib.h:590
J_COLOR_SPACE jpeg_color_space
Definition: jpeglib.h:471
UINT8 arith_ac_K[NUM_ARITH_TBLS]
Definition: jpeglib.h:592
UINT8 arith_dc_U[NUM_ARITH_TBLS]
Definition: jpeglib.h:591

Referenced by read_markers().

◆ get_sos()

get_sos ( j_decompress_ptr  cinfo)

Definition at line 322 of file jdmarker.c.

324{
326 int c, ci, i, n;
328 INPUT_VARS(cinfo);
329
330 if (! cinfo->marker->saw_SOF)
331 ERREXITS(cinfo, JERR_SOF_BEFORE, "SOS");
332
333 INPUT_2BYTES(cinfo, length, return FALSE);
334
335 INPUT_BYTE(cinfo, n, return FALSE); /* Number of components */
336
337 TRACEMS1(cinfo, 1, JTRC_SOS, n);
338
339 if (length != (n * 2 + 6) || n > MAX_COMPS_IN_SCAN ||
340 (n == 0 && !cinfo->progressive_mode))
341 /* pseudo SOS marker only allowed in progressive mode */
342 ERREXIT(cinfo, JERR_BAD_LENGTH);
343
344 cinfo->comps_in_scan = n;
345
346 /* Collect the component-spec parameters */
347
348 for (i = 0; i < n; i++) {
349 INPUT_BYTE(cinfo, c, return FALSE);
350
351 /* Detect the case where component id's are not unique, and, if so, */
352 /* create a fake component id using the same logic as in get_sof. */
353 /* Note: This also ensures that all of the SOF components are */
354 /* referenced in the single scan case, which prevents access to */
355 /* uninitialized memory in later decoding stages. */
356 for (ci = 0; ci < i; ci++) {
357 if (c == cinfo->cur_comp_info[ci]->component_id) {
358 c = cinfo->cur_comp_info[0]->component_id;
359 for (ci = 1; ci < i; ci++) {
360 compptr = cinfo->cur_comp_info[ci];
362 }
363 c++;
364 break;
365 }
366 }
367
368 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
369 ci++, compptr++) {
370 if (c == compptr->component_id)
371 goto id_found;
372 }
373
374 ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, c);
375
376 id_found:
377
378 cinfo->cur_comp_info[i] = compptr;
379 INPUT_BYTE(cinfo, c, return FALSE);
380 compptr->dc_tbl_no = (c >> 4) & 15;
381 compptr->ac_tbl_no = (c ) & 15;
382
383 TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, compptr->component_id,
385 }
386
387 /* Collect the additional scan parameters Ss, Se, Ah/Al. */
388 INPUT_BYTE(cinfo, c, return FALSE);
389 cinfo->Ss = c;
390 INPUT_BYTE(cinfo, c, return FALSE);
391 cinfo->Se = c;
392 INPUT_BYTE(cinfo, c, return FALSE);
393 cinfo->Ah = (c >> 4) & 15;
394 cinfo->Al = (c ) & 15;
395
396 TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se,
397 cinfo->Ah, cinfo->Al);
398
399 /* Prepare to scan data & restart markers */
400 cinfo->marker->next_restart_num = 0;
401
402 /* Count another (non-pseudo) SOS marker */
403 if (n) cinfo->input_scan_number++;
404
405 INPUT_SYNC(cinfo);
406 return TRUE;
407}
#define TRACEMS3(cinfo, lvl, code, p1, p2, p3)
Definition: jerror.h:277
#define MAX_COMPS_IN_SCAN
Definition: jpeglib.h:55
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:650

Referenced by read_markers().

◆ jinit_marker_reader()

jinit_marker_reader ( j_decompress_ptr  cinfo)

Definition at line 1408 of file jdmarker.c.

1409{
1411 int i;
1412
1413 /* Create subobject in permanent pool */
1414 marker = (my_marker_ptr) (*cinfo->mem->alloc_small)
1416 cinfo->marker = &marker->pub;
1417 /* Initialize public method pointers */
1418 marker->pub.reset_marker_reader = reset_marker_reader;
1419 marker->pub.read_markers = read_markers;
1420 marker->pub.read_restart_marker = read_restart_marker;
1421 /* Initialize COM/APPn processing.
1422 * By default, we examine and then discard APP0 and APP14,
1423 * but simply discard COM and all other APPn.
1424 */
1425 marker->process_COM = skip_variable;
1426 marker->length_limit_COM = 0;
1427 for (i = 0; i < 16; i++) {
1428 marker->process_APPn[i] = skip_variable;
1429 marker->length_limit_APPn[i] = 0;
1430 }
1431 marker->process_APPn[0] = get_interesting_appn;
1432 marker->process_APPn[14] = get_interesting_appn;
1433 /* Reset marker processing state */
1434 reset_marker_reader(cinfo);
1435}
reset_marker_reader(j_decompress_ptr cinfo)
Definition: jdmarker.c:1388
read_restart_marker(j_decompress_ptr cinfo)
Definition: jdmarker.c:1259
my_marker_reader * my_marker_ptr
Definition: jdmarker.c:109
read_markers(j_decompress_ptr cinfo)
Definition: jdmarker.c:1090
get_interesting_appn(j_decompress_ptr cinfo)
Definition: jdmarker.c:826
int marker
Definition: jpeglib.h:1030
#define JPOOL_PERMANENT
Definition: jpeglib.h:807
static void skip_variable(void)
Definition: rdjpgcom.c:199

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.

1339{
1340 int marker = cinfo->unread_marker;
1341 int action = 1;
1342
1343 /* Always put up a warning. */
1344 WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired);
1345
1346 /* Outer loop handles repeated decision after scanning forward. */
1347 for (;;) {
1348 if (marker < (int) M_SOF0)
1349 action = 2; /* invalid marker */
1350 else if (marker < (int) M_RST0 || marker > (int) M_RST7)
1351 action = 3; /* valid non-restart marker */
1352 else {
1353 if (marker == ((int) M_RST0 + ((desired+1) & 7)) ||
1354 marker == ((int) M_RST0 + ((desired+2) & 7)))
1355 action = 3; /* one of the next two expected restarts */
1356 else if (marker == ((int) M_RST0 + ((desired-1) & 7)) ||
1357 marker == ((int) M_RST0 + ((desired-2) & 7)))
1358 action = 2; /* a prior restart, so advance */
1359 else
1360 action = 1; /* desired restart or too far away */
1361 }
1362 TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action);
1363 switch (action) {
1364 case 1:
1365 /* Discard marker and let entropy decoder resume processing. */
1366 cinfo->unread_marker = 0;
1367 return TRUE;
1368 case 2:
1369 /* Scan to the next marker, and repeat the decision loop. */
1370 if (! next_marker(cinfo))
1371 return FALSE;
1372 marker = cinfo->unread_marker;
1373 break;
1374 case 3:
1375 /* Return without advancing past this marker. */
1376 /* Entropy decoder will be forced to process an empty segment. */
1377 return TRUE;
1378 }
1379 } /* end loop */
1380}
int desired
Definition: jpeglib.h:1119
static int next_marker(void)
Definition: rdjpgcom.c:142

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.

1496{
1498
1499 if (marker_code == (int) M_COM)
1500 marker->process_COM = routine;
1501 else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15)
1502 marker->process_APPn[marker_code - (int) M_APP0] = routine;
1503 else
1504 ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
1505}
int marker_code
Definition: jpeglib.h:1087
int jpeg_marker_parser_method routine
Definition: jpeglib.h:1093
if(dx< 0)
Definition: linetemp.h:194

Referenced by main().

◆ next_marker()

next_marker ( j_decompress_ptr  cinfo)

Definition at line 1007 of file jdmarker.c.

1008{
1009 int c;
1010 INPUT_VARS(cinfo);
1011
1012 for (;;) {
1013 INPUT_BYTE(cinfo, c, return FALSE);
1014 /* Skip any non-FF bytes.
1015 * This may look a bit inefficient, but it will not occur in a valid file.
1016 * We sync after each discarded byte so that a suspending data source
1017 * can discard the byte from its buffer.
1018 */
1019 while (c != 0xFF) {
1020 cinfo->marker->discarded_bytes++;
1021 INPUT_SYNC(cinfo);
1022 INPUT_BYTE(cinfo, c, return FALSE);
1023 }
1024 /* This loop swallows any duplicate FF bytes. Extra FFs are legal as
1025 * pad bytes, so don't count them in discarded_bytes. We assume there
1026 * will not be so many consecutive FF bytes as to overflow a suspending
1027 * data source's input buffer.
1028 */
1029 do {
1030 INPUT_BYTE(cinfo, c, return FALSE);
1031 } while (c == 0xFF);
1032 if (c != 0)
1033 break; /* found a valid marker, exit loop */
1034 /* Reach here if we found a stuffed-zero data sequence (FF/00).
1035 * Discard it and loop back to try again.
1036 */
1037 cinfo->marker->discarded_bytes += 2;
1038 INPUT_SYNC(cinfo);
1039 }
1040
1041 if (cinfo->marker->discarded_bytes != 0) {
1042 WARNMS2(cinfo, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c);
1043 cinfo->marker->discarded_bytes = 0;
1044 }
1045
1046 cinfo->unread_marker = c;
1047
1048 INPUT_SYNC(cinfo);
1049 return TRUE;
1050}

◆ read_markers()

read_markers ( j_decompress_ptr  cinfo)

Definition at line 1090 of file jdmarker.c.

1091{
1092 /* Outer loop repeats once for each marker. */
1093 for (;;) {
1094 /* Collect the marker proper, unless we already did. */
1095 /* NB: first_marker() enforces the requirement that SOI appear first. */
1096 if (cinfo->unread_marker == 0) {
1097 if (! cinfo->marker->saw_SOI) {
1098 if (! first_marker(cinfo))
1099 return JPEG_SUSPENDED;
1100 } else {
1101 if (! next_marker(cinfo))
1102 return JPEG_SUSPENDED;
1103 }
1104 }
1105 /* At this point cinfo->unread_marker contains the marker code and the
1106 * input point is just past the marker proper, but before any parameters.
1107 * A suspension will cause us to return with this state still true.
1108 */
1109 switch (cinfo->unread_marker) {
1110 case M_SOI:
1111 if (! get_soi(cinfo))
1112 return JPEG_SUSPENDED;
1113 break;
1114
1115 case M_SOF0: /* Baseline */
1116 if (! get_sof(cinfo, TRUE, FALSE, FALSE))
1117 return JPEG_SUSPENDED;
1118 break;
1119
1120 case M_SOF1: /* Extended sequential, Huffman */
1121 if (! get_sof(cinfo, FALSE, FALSE, FALSE))
1122 return JPEG_SUSPENDED;
1123 break;
1124
1125 case M_SOF2: /* Progressive, Huffman */
1126 if (! get_sof(cinfo, FALSE, TRUE, FALSE))
1127 return JPEG_SUSPENDED;
1128 break;
1129
1130 case M_SOF9: /* Extended sequential, arithmetic */
1131 if (! get_sof(cinfo, FALSE, FALSE, TRUE))
1132 return JPEG_SUSPENDED;
1133 break;
1134
1135 case M_SOF10: /* Progressive, arithmetic */
1136 if (! get_sof(cinfo, FALSE, TRUE, TRUE))
1137 return JPEG_SUSPENDED;
1138 break;
1139
1140 /* Currently unsupported SOFn types */
1141 case M_SOF3: /* Lossless, Huffman */
1142 case M_SOF5: /* Differential sequential, Huffman */
1143 case M_SOF6: /* Differential progressive, Huffman */
1144 case M_SOF7: /* Differential lossless, Huffman */
1145 case M_JPG: /* Reserved for JPEG extensions */
1146 case M_SOF11: /* Lossless, arithmetic */
1147 case M_SOF13: /* Differential sequential, arithmetic */
1148 case M_SOF14: /* Differential progressive, arithmetic */
1149 case M_SOF15: /* Differential lossless, arithmetic */
1150 ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker);
1151 break;
1152
1153 case M_SOS:
1154 if (! get_sos(cinfo))
1155 return JPEG_SUSPENDED;
1156 cinfo->unread_marker = 0; /* processed the marker */
1157 return JPEG_REACHED_SOS;
1158
1159 case M_EOI:
1160 TRACEMS(cinfo, 1, JTRC_EOI);
1161 cinfo->unread_marker = 0; /* processed the marker */
1162 return JPEG_REACHED_EOI;
1163
1164 case M_DAC:
1165 if (! get_dac(cinfo))
1166 return JPEG_SUSPENDED;
1167 break;
1168
1169 case M_DHT:
1170 if (! get_dht(cinfo))
1171 return JPEG_SUSPENDED;
1172 break;
1173
1174 case M_DQT:
1175 if (! get_dqt(cinfo))
1176 return JPEG_SUSPENDED;
1177 break;
1178
1179 case M_DRI:
1180 if (! get_dri(cinfo))
1181 return JPEG_SUSPENDED;
1182 break;
1183
1184 case M_JPG8:
1185 if (! get_lse(cinfo))
1186 return JPEG_SUSPENDED;
1187 break;
1188
1189 case M_APP0:
1190 case M_APP1:
1191 case M_APP2:
1192 case M_APP3:
1193 case M_APP4:
1194 case M_APP5:
1195 case M_APP6:
1196 case M_APP7:
1197 case M_APP8:
1198 case M_APP9:
1199 case M_APP10:
1200 case M_APP11:
1201 case M_APP12:
1202 case M_APP13:
1203 case M_APP14:
1204 case M_APP15:
1205 if (! (*((my_marker_ptr) cinfo->marker)->process_APPn[
1206 cinfo->unread_marker - (int) M_APP0]) (cinfo))
1207 return JPEG_SUSPENDED;
1208 break;
1209
1210 case M_COM:
1211 if (! (*((my_marker_ptr) cinfo->marker)->process_COM) (cinfo))
1212 return JPEG_SUSPENDED;
1213 break;
1214
1215 case M_RST0: /* these are all parameterless */
1216 case M_RST1:
1217 case M_RST2:
1218 case M_RST3:
1219 case M_RST4:
1220 case M_RST5:
1221 case M_RST6:
1222 case M_RST7:
1223 case M_TEM:
1224 TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker);
1225 break;
1226
1227 case M_DNL: /* Ignore DNL ... perhaps the wrong thing */
1228 if (! skip_variable(cinfo))
1229 return JPEG_SUSPENDED;
1230 break;
1231
1232 default: /* must be DHP, EXP, JPGn, or RESn */
1233 /* For now, we treat the reserved markers as fatal errors since they are
1234 * likely to be used to signal incompatible JPEG Part 3 extensions.
1235 * Once the JPEG 3 version-number marker is well defined, this code
1236 * ought to change!
1237 */
1238 ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
1239 }
1240 /* Successfully processed marker, so reset state variable */
1241 cinfo->unread_marker = 0;
1242 } /* end loop */
1243}
get_sof(j_decompress_ptr cinfo, boolean is_baseline, boolean is_prog, boolean is_arith)
Definition: jdmarker.c:240
get_lse(j_decompress_ptr cinfo)
Definition: jdmarker.c:645
get_dri(j_decompress_ptr cinfo)
Definition: jdmarker.c:621
get_dht(j_decompress_ptr cinfo)
Definition: jdmarker.c:459
get_dqt(j_decompress_ptr cinfo)
Definition: jdmarker.c:531
get_sos(j_decompress_ptr cinfo)
Definition: jdmarker.c:322
#define get_dac(cinfo)
Definition: jdmarker.c:453
get_soi(j_decompress_ptr cinfo)
Definition: jdmarker.c:199
#define JPEG_REACHED_SOS
Definition: jpeglib.h:1076
#define JPEG_REACHED_EOI
Definition: jpeglib.h:1077
#define JPEG_SUSPENDED
Definition: jpeglib.h:1045
static int first_marker(void)
Definition: rdjpgcom.c:177

Referenced by jinit_marker_reader().

◆ read_restart_marker()

read_restart_marker ( j_decompress_ptr  cinfo)

Definition at line 1259 of file jdmarker.c.

1260{
1261 /* Obtain a marker unless we already did. */
1262 /* Note that next_marker will complain if it skips any data. */
1263 if (cinfo->unread_marker == 0) {
1264 if (! next_marker(cinfo))
1265 return FALSE;
1266 }
1267
1268 if (cinfo->unread_marker ==
1269 ((int) M_RST0 + cinfo->marker->next_restart_num)) {
1270 /* Normal case --- swallow the marker and let entropy decoder continue */
1271 TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num);
1272 cinfo->unread_marker = 0;
1273 } else {
1274 /* Uh-oh, the restart markers have been messed up. */
1275 /* Let the data source manager determine how to resync. */
1276 if (! (*cinfo->src->resync_to_restart) (cinfo,
1277 cinfo->marker->next_restart_num))
1278 return FALSE;
1279 }
1280
1281 /* Update next-restart state */
1282 cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7;
1283
1284 return TRUE;
1285}

Referenced by jinit_marker_reader().

◆ reset_marker_reader()

reset_marker_reader ( j_decompress_ptr  cinfo)

Definition at line 1388 of file jdmarker.c.

1389{
1391
1392 cinfo->comp_info = NULL; /* until allocated by get_sof */
1393 cinfo->input_scan_number = 0; /* no SOS seen yet */
1394 cinfo->unread_marker = 0; /* no pending marker */
1395 marker->pub.saw_SOI = FALSE; /* set internal state too */
1396 marker->pub.saw_SOF = FALSE;
1397 marker->pub.discarded_bytes = 0;
1398 marker->cur_marker = NULL;
1399}

Referenced by jinit_marker_reader().

◆ skip_variable()

skip_variable ( j_decompress_ptr  cinfo)

Definition at line 978 of file jdmarker.c.

980{
982 INPUT_VARS(cinfo);
983
984 INPUT_2BYTES(cinfo, length, return FALSE);
985 length -= 2;
986
987 TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length);
988
989 INPUT_SYNC(cinfo); /* do before skip_input_data */
990 if (length > 0)
991 (*cinfo->src->skip_input_data) (cinfo, (long) length);
992
993 return TRUE;
994}