ReactOS  0.4.15-dev-1054-gd029a62
jcmarker.c
Go to the documentation of this file.
1 /*
2  * jcmarker.c
3  *
4  * Copyright (C) 1991-1998, Thomas G. Lane.
5  * Modified 2003-2019 by Guido Vollbeding.
6  * This file is part of the Independent JPEG Group's software.
7  * For conditions of distribution and use, see the accompanying README file.
8  *
9  * This file contains routines to write JPEG datastream markers.
10  */
11 
12 #define JPEG_INTERNALS
13 #include "jinclude.h"
14 #include "jpeglib.h"
15 
16 
17 typedef enum { /* JPEG marker codes */
18  M_SOF0 = 0xc0,
19  M_SOF1 = 0xc1,
20  M_SOF2 = 0xc2,
21  M_SOF3 = 0xc3,
22 
23  M_SOF5 = 0xc5,
24  M_SOF6 = 0xc6,
25  M_SOF7 = 0xc7,
26 
27  M_JPG = 0xc8,
28  M_SOF9 = 0xc9,
29  M_SOF10 = 0xca,
30  M_SOF11 = 0xcb,
31 
32  M_SOF13 = 0xcd,
33  M_SOF14 = 0xce,
34  M_SOF15 = 0xcf,
35 
36  M_DHT = 0xc4,
37 
38  M_DAC = 0xcc,
39 
40  M_RST0 = 0xd0,
41  M_RST1 = 0xd1,
42  M_RST2 = 0xd2,
43  M_RST3 = 0xd3,
44  M_RST4 = 0xd4,
45  M_RST5 = 0xd5,
46  M_RST6 = 0xd6,
47  M_RST7 = 0xd7,
48 
49  M_SOI = 0xd8,
50  M_EOI = 0xd9,
51  M_SOS = 0xda,
52  M_DQT = 0xdb,
53  M_DNL = 0xdc,
54  M_DRI = 0xdd,
55  M_DHP = 0xde,
56  M_EXP = 0xdf,
57 
58  M_APP0 = 0xe0,
59  M_APP1 = 0xe1,
60  M_APP2 = 0xe2,
61  M_APP3 = 0xe3,
62  M_APP4 = 0xe4,
63  M_APP5 = 0xe5,
64  M_APP6 = 0xe6,
65  M_APP7 = 0xe7,
66  M_APP8 = 0xe8,
67  M_APP9 = 0xe9,
68  M_APP10 = 0xea,
69  M_APP11 = 0xeb,
70  M_APP12 = 0xec,
71  M_APP13 = 0xed,
72  M_APP14 = 0xee,
73  M_APP15 = 0xef,
74 
75  M_JPG0 = 0xf0,
76  M_JPG8 = 0xf8,
77  M_JPG13 = 0xfd,
78  M_COM = 0xfe,
79 
80  M_TEM = 0x01,
81 
82  M_ERROR = 0x100
83 } JPEG_MARKER;
84 
85 
86 /* Private state */
87 
88 typedef struct {
89  struct jpeg_marker_writer pub; /* public fields */
90 
91  unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */
93 
95 
96 
97 /*
98  * Basic output routines.
99  *
100  * Note that we do not support suspension while writing a marker.
101  * Therefore, an application using suspension must ensure that there is
102  * enough buffer space for the initial markers (typ. 600-700 bytes) before
103  * calling jpeg_start_compress, and enough space to write the trailing EOI
104  * (a few bytes) before calling jpeg_finish_compress. Multipass compression
105  * modes are not supported at all with suspension, so those two are the only
106  * points where markers will be written.
107  */
108 
109 LOCAL(void)
111 /* Emit a byte */
112 {
113  struct jpeg_destination_mgr * dest = cinfo->dest;
114 
115  *(dest->next_output_byte)++ = (JOCTET) val;
116  if (--dest->free_in_buffer == 0) {
117  if (! (*dest->empty_output_buffer) (cinfo))
118  ERREXIT(cinfo, JERR_CANT_SUSPEND);
119  }
120 }
121 
122 
123 LOCAL(void)
125 /* Emit a marker code */
126 {
127  emit_byte(cinfo, 0xFF);
128  emit_byte(cinfo, (int) mark);
129 }
130 
131 
132 LOCAL(void)
134 /* Emit a 2-byte integer; these are always MSB first in JPEG files */
135 {
136  emit_byte(cinfo, (value >> 8) & 0xFF);
137  emit_byte(cinfo, value & 0xFF);
138 }
139 
140 
141 /*
142  * Routines to write specific marker types.
143  */
144 
145 LOCAL(int)
147 /* Emit a DQT marker */
148 /* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
149 {
150  JQUANT_TBL * qtbl = cinfo->quant_tbl_ptrs[index];
151  int prec;
152  int i;
153 
154  if (qtbl == NULL)
155  ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index);
156 
157  prec = 0;
158  for (i = 0; i <= cinfo->lim_Se; i++) {
159  if (qtbl->quantval[cinfo->natural_order[i]] > 255)
160  prec = 1;
161  }
162 
163  if (! qtbl->sent_table) {
164  emit_marker(cinfo, M_DQT);
165 
166  emit_2bytes(cinfo,
167  prec ? cinfo->lim_Se * 2 + 2 + 1 + 2 : cinfo->lim_Se + 1 + 1 + 2);
168 
169  emit_byte(cinfo, index + (prec<<4));
170 
171  for (i = 0; i <= cinfo->lim_Se; i++) {
172  /* The table entries must be emitted in zigzag order. */
173  unsigned int qval = qtbl->quantval[cinfo->natural_order[i]];
174  if (prec)
175  emit_byte(cinfo, (int) (qval >> 8));
176  emit_byte(cinfo, (int) (qval & 0xFF));
177  }
178 
179  qtbl->sent_table = TRUE;
180  }
181 
182  return prec;
183 }
184 
185 
186 LOCAL(void)
187 emit_dht (j_compress_ptr cinfo, int index, boolean is_ac)
188 /* Emit a DHT marker */
189 {
190  JHUFF_TBL * htbl;
191  int length, i;
192 
193  if (is_ac) {
194  htbl = cinfo->ac_huff_tbl_ptrs[index];
195  index += 0x10; /* output index has AC bit set */
196  } else {
197  htbl = cinfo->dc_huff_tbl_ptrs[index];
198  }
199 
200  if (htbl == NULL)
201  ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index);
202 
203  if (! htbl->sent_table) {
204  emit_marker(cinfo, M_DHT);
205 
206  length = 0;
207  for (i = 1; i <= 16; i++)
208  length += htbl->bits[i];
209 
210  emit_2bytes(cinfo, length + 2 + 1 + 16);
211  emit_byte(cinfo, index);
212 
213  for (i = 1; i <= 16; i++)
214  emit_byte(cinfo, htbl->bits[i]);
215 
216  for (i = 0; i < length; i++)
217  emit_byte(cinfo, htbl->huffval[i]);
218 
219  htbl->sent_table = TRUE;
220  }
221 }
222 
223 
224 LOCAL(void)
226 /* Emit a DAC marker */
227 /* Since the useful info is so small, we want to emit all the tables in */
228 /* one DAC marker. Therefore this routine does its own scan of the table. */
229 {
230 #ifdef C_ARITH_CODING_SUPPORTED
231  char dc_in_use[NUM_ARITH_TBLS];
232  char ac_in_use[NUM_ARITH_TBLS];
233  int length, i;
235 
236  for (i = 0; i < NUM_ARITH_TBLS; i++)
237  dc_in_use[i] = ac_in_use[i] = 0;
238 
239  for (i = 0; i < cinfo->comps_in_scan; i++) {
240  compptr = cinfo->cur_comp_info[i];
241  /* DC needs no table for refinement scan */
242  if (cinfo->Ss == 0 && cinfo->Ah == 0)
243  dc_in_use[compptr->dc_tbl_no] = 1;
244  /* AC needs no table when not present */
245  if (cinfo->Se)
246  ac_in_use[compptr->ac_tbl_no] = 1;
247  }
248 
249  length = 0;
250  for (i = 0; i < NUM_ARITH_TBLS; i++)
251  length += dc_in_use[i] + ac_in_use[i];
252 
253  if (length) {
254  emit_marker(cinfo, M_DAC);
255 
256  emit_2bytes(cinfo, length*2 + 2);
257 
258  for (i = 0; i < NUM_ARITH_TBLS; i++) {
259  if (dc_in_use[i]) {
260  emit_byte(cinfo, i);
261  emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4));
262  }
263  if (ac_in_use[i]) {
264  emit_byte(cinfo, i + 0x10);
265  emit_byte(cinfo, cinfo->arith_ac_K[i]);
266  }
267  }
268  }
269 #endif /* C_ARITH_CODING_SUPPORTED */
270 }
271 
272 
273 LOCAL(void)
275 /* Emit a DRI marker */
276 {
277  emit_marker(cinfo, M_DRI);
278 
279  emit_2bytes(cinfo, 4); /* fixed length */
280 
281  emit_2bytes(cinfo, (int) cinfo->restart_interval);
282 }
283 
284 
285 LOCAL(void)
287 /* Emit an LSE inverse color transform specification marker */
288 {
289  /* Support only 1 transform */
290  if (cinfo->color_transform != JCT_SUBTRACT_GREEN ||
291  cinfo->num_components < 3)
292  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
293 
294  emit_marker(cinfo, M_JPG8);
295 
296  emit_2bytes(cinfo, 24); /* fixed length */
297 
298  emit_byte(cinfo, 0x0D); /* ID inverse transform specification */
299  emit_2bytes(cinfo, MAXJSAMPLE); /* MAXTRANS */
300  emit_byte(cinfo, 3); /* Nt=3 */
301  emit_byte(cinfo, cinfo->comp_info[1].component_id);
302  emit_byte(cinfo, cinfo->comp_info[0].component_id);
303  emit_byte(cinfo, cinfo->comp_info[2].component_id);
304  emit_byte(cinfo, 0x80); /* F1: CENTER1=1, NORM1=0 */
305  emit_2bytes(cinfo, 0); /* A(1,1)=0 */
306  emit_2bytes(cinfo, 0); /* A(1,2)=0 */
307  emit_byte(cinfo, 0); /* F2: CENTER2=0, NORM2=0 */
308  emit_2bytes(cinfo, 1); /* A(2,1)=1 */
309  emit_2bytes(cinfo, 0); /* A(2,2)=0 */
310  emit_byte(cinfo, 0); /* F3: CENTER3=0, NORM3=0 */
311  emit_2bytes(cinfo, 1); /* A(3,1)=1 */
312  emit_2bytes(cinfo, 0); /* A(3,2)=0 */
313 }
314 
315 
316 LOCAL(void)
318 /* Emit a SOF marker */
319 {
320  int ci;
322 
323  emit_marker(cinfo, code);
324 
325  emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */
326 
327  /* Make sure image isn't bigger than SOF field can handle */
328  if ((long) cinfo->jpeg_height > 65535L ||
329  (long) cinfo->jpeg_width > 65535L)
330  ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) 65535);
331 
332  emit_byte(cinfo, cinfo->data_precision);
333  emit_2bytes(cinfo, (int) cinfo->jpeg_height);
334  emit_2bytes(cinfo, (int) cinfo->jpeg_width);
335 
336  emit_byte(cinfo, cinfo->num_components);
337 
338  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
339  ci++, compptr++) {
340  emit_byte(cinfo, compptr->component_id);
342  emit_byte(cinfo, compptr->quant_tbl_no);
343  }
344 }
345 
346 
347 LOCAL(void)
349 /* Emit a SOS marker */
350 {
351  int i, td, ta;
353 
354  emit_marker(cinfo, M_SOS);
355 
356  emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */
357 
358  emit_byte(cinfo, cinfo->comps_in_scan);
359 
360  for (i = 0; i < cinfo->comps_in_scan; i++) {
361  compptr = cinfo->cur_comp_info[i];
362  emit_byte(cinfo, compptr->component_id);
363 
364  /* We emit 0 for unused field(s); this is recommended by the P&M text
365  * but does not seem to be specified in the standard.
366  */
367 
368  /* DC needs no table for refinement scan */
369  td = cinfo->Ss == 0 && cinfo->Ah == 0 ? compptr->dc_tbl_no : 0;
370  /* AC needs no table when not present */
371  ta = cinfo->Se ? compptr->ac_tbl_no : 0;
372 
373  emit_byte(cinfo, (td << 4) + ta);
374  }
375 
376  emit_byte(cinfo, cinfo->Ss);
377  emit_byte(cinfo, cinfo->Se);
378  emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al);
379 }
380 
381 
382 LOCAL(void)
384 /* Emit a pseudo SOS marker */
385 {
386  emit_marker(cinfo, M_SOS);
387 
388  emit_2bytes(cinfo, 2 + 1 + 3); /* length */
389 
390  emit_byte(cinfo, 0); /* Ns */
391 
392  emit_byte(cinfo, 0); /* Ss */
393  emit_byte(cinfo, cinfo->block_size * cinfo->block_size - 1); /* Se */
394  emit_byte(cinfo, 0); /* Ah/Al */
395 }
396 
397 
398 LOCAL(void)
400 /* Emit a JFIF-compliant APP0 marker */
401 {
402  /*
403  * Length of APP0 block (2 bytes)
404  * Block ID (4 bytes - ASCII "JFIF")
405  * Zero byte (1 byte to terminate the ID string)
406  * Version Major, Minor (2 bytes - major first)
407  * Units (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
408  * Xdpu (2 bytes - dots per unit horizontal)
409  * Ydpu (2 bytes - dots per unit vertical)
410  * Thumbnail X size (1 byte)
411  * Thumbnail Y size (1 byte)
412  */
413 
414  emit_marker(cinfo, M_APP0);
415 
416  emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
417 
418  emit_byte(cinfo, 0x4A); /* Identifier: ASCII "JFIF" */
419  emit_byte(cinfo, 0x46);
420  emit_byte(cinfo, 0x49);
421  emit_byte(cinfo, 0x46);
422  emit_byte(cinfo, 0);
423  emit_byte(cinfo, cinfo->JFIF_major_version); /* Version fields */
424  emit_byte(cinfo, cinfo->JFIF_minor_version);
425  emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
426  emit_2bytes(cinfo, (int) cinfo->X_density);
427  emit_2bytes(cinfo, (int) cinfo->Y_density);
428  emit_byte(cinfo, 0); /* No thumbnail image */
429  emit_byte(cinfo, 0);
430 }
431 
432 
433 LOCAL(void)
435 /* Emit an Adobe APP14 marker */
436 {
437  /*
438  * Length of APP14 block (2 bytes)
439  * Block ID (5 bytes - ASCII "Adobe")
440  * Version Number (2 bytes - currently 100)
441  * Flags0 (2 bytes - currently 0)
442  * Flags1 (2 bytes - currently 0)
443  * Color transform (1 byte)
444  *
445  * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
446  * now in circulation seem to use Version = 100, so that's what we write.
447  *
448  * We write the color transform byte as 1 if the JPEG color space is
449  * YCbCr, 2 if it's YCCK, 0 otherwise. Adobe's definition has to do with
450  * whether the encoder performed a transformation, which is pretty useless.
451  */
452 
453  emit_marker(cinfo, M_APP14);
454 
455  emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
456 
457  emit_byte(cinfo, 0x41); /* Identifier: ASCII "Adobe" */
458  emit_byte(cinfo, 0x64);
459  emit_byte(cinfo, 0x6F);
460  emit_byte(cinfo, 0x62);
461  emit_byte(cinfo, 0x65);
462  emit_2bytes(cinfo, 100); /* Version */
463  emit_2bytes(cinfo, 0); /* Flags0 */
464  emit_2bytes(cinfo, 0); /* Flags1 */
465  switch (cinfo->jpeg_color_space) {
466  case JCS_YCbCr:
467  emit_byte(cinfo, 1); /* Color transform = 1 */
468  break;
469  case JCS_YCCK:
470  emit_byte(cinfo, 2); /* Color transform = 2 */
471  break;
472  default:
473  emit_byte(cinfo, 0); /* Color transform = 0 */
474  }
475 }
476 
477 
478 /*
479  * These routines allow writing an arbitrary marker with parameters.
480  * The only intended use is to emit COM or APPn markers after calling
481  * write_file_header and before calling write_frame_header.
482  * Other uses are not guaranteed to produce desirable results.
483  * Counting the parameter bytes properly is the caller's responsibility.
484  */
485 
486 METHODDEF(void)
488 /* Emit an arbitrary marker header */
489 {
490  if (datalen > (unsigned int) 65533) /* safety check */
491  ERREXIT(cinfo, JERR_BAD_LENGTH);
492 
493  emit_marker(cinfo, (JPEG_MARKER) marker);
494 
495  emit_2bytes(cinfo, (int) (datalen + 2)); /* total length */
496 }
497 
498 METHODDEF(void)
500 /* Emit one byte of marker parameters following write_marker_header */
501 {
502  emit_byte(cinfo, val);
503 }
504 
505 
506 /*
507  * Write datastream header.
508  * This consists of an SOI and optional APPn markers.
509  * We recommend use of the JFIF marker, but not the Adobe marker,
510  * when using YCbCr or grayscale data. The JFIF marker is also used
511  * for other standard JPEG colorspaces. The Adobe marker is helpful
512  * to distinguish RGB, CMYK, and YCCK colorspaces.
513  * Note that an application can write additional header markers after
514  * jpeg_start_compress returns.
515  */
516 
517 METHODDEF(void)
519 {
520  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
521 
522  emit_marker(cinfo, M_SOI); /* first the SOI */
523 
524  /* SOI is defined to reset restart interval to 0 */
525  marker->last_restart_interval = 0;
526 
527  if (cinfo->write_JFIF_header) /* next an optional JFIF APP0 */
528  emit_jfif_app0(cinfo);
529  if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
530  emit_adobe_app14(cinfo);
531 }
532 
533 
534 /*
535  * Write frame header.
536  * This consists of DQT and SOFn markers,
537  * a conditional LSE marker and a conditional pseudo SOS marker.
538  * Note that we do not emit the SOF until we have emitted the DQT(s).
539  * This avoids compatibility problems with incorrect implementations that
540  * try to error-check the quant table numbers as soon as they see the SOF.
541  */
542 
543 METHODDEF(void)
545 {
546  int ci, prec;
547  boolean is_baseline;
549 
550  /* Emit DQT for each quantization table.
551  * Note that emit_dqt() suppresses any duplicate tables.
552  */
553  prec = 0;
554  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
555  ci++, compptr++) {
556  prec += emit_dqt(cinfo, compptr->quant_tbl_no);
557  }
558  /* now prec is nonzero iff there are any 16-bit quant tables. */
559 
560  /* Check for a non-baseline specification.
561  * Note we assume that Huffman table numbers won't be changed later.
562  */
563  if (cinfo->arith_code || cinfo->progressive_mode ||
564  cinfo->data_precision != 8 || cinfo->block_size != DCTSIZE) {
565  is_baseline = FALSE;
566  } else {
567  is_baseline = TRUE;
568  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
569  ci++, compptr++) {
570  if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
571  is_baseline = FALSE;
572  }
573  if (prec && is_baseline) {
574  is_baseline = FALSE;
575  /* If it's baseline except for quantizer size, warn the user */
576  TRACEMS(cinfo, 0, JTRC_16BIT_TABLES);
577  }
578  }
579 
580  /* Emit the proper SOF marker */
581  if (cinfo->arith_code) {
582  if (cinfo->progressive_mode)
583  emit_sof(cinfo, M_SOF10); /* SOF code for progressive arithmetic */
584  else
585  emit_sof(cinfo, M_SOF9); /* SOF code for sequential arithmetic */
586  } else {
587  if (cinfo->progressive_mode)
588  emit_sof(cinfo, M_SOF2); /* SOF code for progressive Huffman */
589  else if (is_baseline)
590  emit_sof(cinfo, M_SOF0); /* SOF code for baseline implementation */
591  else
592  emit_sof(cinfo, M_SOF1); /* SOF code for non-baseline Huffman file */
593  }
594 
595  /* Check to emit LSE inverse color transform specification marker */
596  if (cinfo->color_transform)
597  emit_lse_ict(cinfo);
598 
599  /* Check to emit pseudo SOS marker */
600  if (cinfo->progressive_mode && cinfo->block_size != DCTSIZE)
601  emit_pseudo_sos(cinfo);
602 }
603 
604 
605 /*
606  * Write scan header.
607  * This consists of DHT or DAC markers, optional DRI, and SOS.
608  * Compressed data will be written following the SOS.
609  */
610 
611 METHODDEF(void)
613 {
614  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
615  int i;
617 
618  if (cinfo->arith_code) {
619  /* Emit arith conditioning info. We may have some duplication
620  * if the file has multiple scans, but it's so small it's hardly
621  * worth worrying about.
622  */
623  emit_dac(cinfo);
624  } else {
625  /* Emit Huffman tables.
626  * Note that emit_dht() suppresses any duplicate tables.
627  */
628  for (i = 0; i < cinfo->comps_in_scan; i++) {
629  compptr = cinfo->cur_comp_info[i];
630  /* DC needs no table for refinement scan */
631  if (cinfo->Ss == 0 && cinfo->Ah == 0)
632  emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
633  /* AC needs no table when not present */
634  if (cinfo->Se)
635  emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
636  }
637  }
638 
639  /* Emit DRI if required --- note that DRI value could change for each scan.
640  * We avoid wasting space with unnecessary DRIs, however.
641  */
642  if (cinfo->restart_interval != marker->last_restart_interval) {
643  emit_dri(cinfo);
644  marker->last_restart_interval = cinfo->restart_interval;
645  }
646 
647  emit_sos(cinfo);
648 }
649 
650 
651 /*
652  * Write datastream trailer.
653  */
654 
655 METHODDEF(void)
657 {
658  emit_marker(cinfo, M_EOI);
659 }
660 
661 
662 /*
663  * Write an abbreviated table-specification datastream.
664  * This consists of SOI, DQT and DHT tables, and EOI.
665  * Any table that is defined and not marked sent_table = TRUE will be
666  * emitted. Note that all tables will be marked sent_table = TRUE at exit.
667  */
668 
669 METHODDEF(void)
671 {
672  int i;
673 
674  emit_marker(cinfo, M_SOI);
675 
676  for (i = 0; i < NUM_QUANT_TBLS; i++) {
677  if (cinfo->quant_tbl_ptrs[i] != NULL)
678  (void) emit_dqt(cinfo, i);
679  }
680 
681  if (! cinfo->arith_code) {
682  for (i = 0; i < NUM_HUFF_TBLS; i++) {
683  if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
684  emit_dht(cinfo, i, FALSE);
685  if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
686  emit_dht(cinfo, i, TRUE);
687  }
688  }
689 
690  emit_marker(cinfo, M_EOI);
691 }
692 
693 
694 /*
695  * Initialize the marker writer module.
696  */
697 
698 GLOBAL(void)
700 {
702 
703  /* Create the subobject */
704  marker = (my_marker_ptr) (*cinfo->mem->alloc_small)
706  cinfo->marker = &marker->pub;
707  /* Initialize method pointers */
708  marker->pub.write_file_header = write_file_header;
709  marker->pub.write_frame_header = write_frame_header;
710  marker->pub.write_scan_header = write_scan_header;
711  marker->pub.write_file_trailer = write_file_trailer;
712  marker->pub.write_tables_only = write_tables_only;
713  marker->pub.write_marker_header = write_marker_header;
714  marker->pub.write_marker_byte = write_marker_byte;
715  /* Initialize private state */
716  marker->last_restart_interval = 0;
717 }
Definition: jcmarker.c:56
write_file_header(j_compress_ptr cinfo)
Definition: jcmarker.c:518
Definition: jcmarker.c:49
write_scan_header(j_compress_ptr cinfo)
Definition: jcmarker.c:612
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define NUM_QUANT_TBLS
Definition: jpeglib.h:52
emit_sos(j_compress_ptr cinfo)
Definition: jcmarker.c:348
UINT8 huffval[256]
Definition: jpeglib.h:113
#define TRUE
Definition: types.h:120
emit_pseudo_sos(j_compress_ptr cinfo)
Definition: jcmarker.c:383
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
UINT16 quantval[DCTSIZE2]
Definition: jpeglib.h:97
boolean sent_table
Definition: jpeglib.h:119
#define NUM_HUFF_TBLS
Definition: jpeglib.h:53
emit_jfif_app0(j_compress_ptr cinfo)
Definition: jcmarker.c:399
Definition: jcmarker.c:51
#define MAXJSAMPLE
Definition: jmorecfg.h:83
int const JOCTET unsigned int datalen
Definition: jpeglib.h:1030
emit_byte(j_compress_ptr cinfo, int val)
Definition: jcmarker.c:110
Definition: jcmarker.c:36
write_file_trailer(j_compress_ptr cinfo)
Definition: jcmarker.c:656
unsigned int last_restart_interval
Definition: jcmarker.c:91
emit_dqt(j_compress_ptr cinfo, int index)
Definition: jcmarker.c:146
jpeg_component_info * compptr
Definition: jdct.h:238
write_marker_byte(j_compress_ptr cinfo, int val)
Definition: jcmarker.c:499
UINT8 bits[17]
Definition: jpeglib.h:111
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
#define TRACEMS(cinfo, lvl, code)
Definition: jerror.h:265
#define SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
Definition: jcmarker.c:53
#define FALSE
Definition: types.h:117
smooth NULL
Definition: ftsmooth.c:416
int marker
Definition: jpeglib.h:1030
Definition: jcmarker.c:55
Definition: jcmarker.c:78
GLuint index
Definition: glext.h:6031
write_marker_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
Definition: jcmarker.c:487
#define LOCAL(type)
Definition: jmorecfg.h:289
GLuint GLfloat * val
Definition: glext.h:7180
emit_sof(j_compress_ptr cinfo, JPEG_MARKER code)
Definition: jcmarker.c:317
Definition: jcmarker.c:50
my_marker_writer * my_marker_ptr
Definition: jcmarker.c:94
emit_dri(j_compress_ptr cinfo)
Definition: jcmarker.c:274
if(!(yy_init))
Definition: macro.lex.yy.c:714
JPEG_MARKER
Definition: jcmarker.c:17
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
emit_adobe_app14(j_compress_ptr cinfo)
Definition: jcmarker.c:434
Definition: jcmarker.c:38
emit_lse_ict(j_compress_ptr cinfo)
Definition: jcmarker.c:286
Definition: jcmarker.c:80
#define index(s, c)
Definition: various.h:29
static const WCHAR L[]
Definition: oid.c:1250
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
emit_dht(j_compress_ptr cinfo, int index, boolean is_ac)
Definition: jcmarker.c:187
write_tables_only(j_compress_ptr cinfo)
Definition: jcmarker.c:670
Definition: inflate.c:139
#define GLOBAL(type)
Definition: jmorecfg.h:291
#define METHODDEF(type)
Definition: jmorecfg.h:287
boolean sent_table
Definition: jpeglib.h:103
write_frame_header(j_compress_ptr cinfo)
Definition: jcmarker.c:544
jinit_marker_writer(j_compress_ptr cinfo)
Definition: jcmarker.c:699
#define DCTSIZE
Definition: jpeglib.h:50
Definition: jcmarker.c:52
#define NUM_ARITH_TBLS
Definition: jpeglib.h:54
char JOCTET
Definition: jmorecfg.h:167
static char * dest
Definition: rtl.c:135
emit_marker(j_compress_ptr cinfo, JPEG_MARKER mark)
Definition: jcmarker.c:124
emit_dac(j_compress_ptr cinfo)
Definition: jcmarker.c:225
Definition: jcmarker.c:54
Definition: jcmarker.c:27
emit_2bytes(j_compress_ptr cinfo, int value)
Definition: jcmarker.c:133