• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * jcmarker.c
3  *
4  * This file was part of the Independent JPEG Group's software:
5  * Copyright (C) 1991-1998, Thomas G. Lane.
6  * Modified 2003-2010 by Guido Vollbeding.
7  * libjpeg-turbo Modifications:
8  * Copyright (C) 2010, D. R. Commander.
9  * For conditions of distribution and use, see the accompanying README.ijg
10  * file.
11  *
12  * This file contains routines to write JPEG datastream markers.
13  */
14 
15 #define JPEG_INTERNALS
16 #include "jinclude.h"
17 #include "jpeglib.h"
18 #include "jpegcomp.h"
19 
20 
21 typedef enum {                  /* 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_JPG13 = 0xfd,
81   M_COM   = 0xfe,
82 
83   M_TEM   = 0x01,
84 
85   M_ERROR = 0x100
86 } JPEG_MARKER;
87 
88 
89 /* Private state */
90 
91 typedef struct {
92   struct jpeg_marker_writer pub; /* public fields */
93 
94   unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */
95 } my_marker_writer;
96 
97 typedef my_marker_writer *my_marker_ptr;
98 
99 
100 /*
101  * Basic output routines.
102  *
103  * Note that we do not support suspension while writing a marker.
104  * Therefore, an application using suspension must ensure that there is
105  * enough buffer space for the initial markers (typ. 600-700 bytes) before
106  * calling jpeg_start_compress, and enough space to write the trailing EOI
107  * (a few bytes) before calling jpeg_finish_compress.  Multipass compression
108  * modes are not supported at all with suspension, so those two are the only
109  * points where markers will be written.
110  */
111 
112 LOCAL(void)
emit_byte(j_compress_ptr cinfo,int val)113 emit_byte(j_compress_ptr cinfo, int val)
114 /* Emit a byte */
115 {
116   struct jpeg_destination_mgr *dest = cinfo->dest;
117 
118   *(dest->next_output_byte)++ = (JOCTET)val;
119   if (--dest->free_in_buffer == 0) {
120     if (!(*dest->empty_output_buffer) (cinfo))
121       ERREXIT(cinfo, JERR_CANT_SUSPEND);
122   }
123 }
124 
125 
126 LOCAL(void)
emit_marker(j_compress_ptr cinfo,JPEG_MARKER mark)127 emit_marker(j_compress_ptr cinfo, JPEG_MARKER mark)
128 /* Emit a marker code */
129 {
130   emit_byte(cinfo, 0xFF);
131   emit_byte(cinfo, (int)mark);
132 }
133 
134 
135 LOCAL(void)
emit_2bytes(j_compress_ptr cinfo,int value)136 emit_2bytes(j_compress_ptr cinfo, int value)
137 /* Emit a 2-byte integer; these are always MSB first in JPEG files */
138 {
139   emit_byte(cinfo, (value >> 8) & 0xFF);
140   emit_byte(cinfo, value & 0xFF);
141 }
142 
143 
144 /*
145  * Routines to write specific marker types.
146  */
147 
148 LOCAL(int)
emit_dqt(j_compress_ptr cinfo,int index)149 emit_dqt(j_compress_ptr cinfo, int index)
150 /* Emit a DQT marker */
151 /* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
152 {
153   JQUANT_TBL *qtbl = cinfo->quant_tbl_ptrs[index];
154   int prec;
155   int i;
156 
157   if (qtbl == NULL)
158     ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index);
159 
160   prec = 0;
161   for (i = 0; i < DCTSIZE2; i++) {
162     if (qtbl->quantval[i] > 255)
163       prec = 1;
164   }
165 
166   if (!qtbl->sent_table) {
167     emit_marker(cinfo, M_DQT);
168 
169     emit_2bytes(cinfo, prec ? DCTSIZE2 * 2 + 1 + 2 : DCTSIZE2 + 1 + 2);
170 
171     emit_byte(cinfo, index + (prec << 4));
172 
173     for (i = 0; i < DCTSIZE2; i++) {
174       /* The table entries must be emitted in zigzag order. */
175       unsigned int qval = qtbl->quantval[jpeg_natural_order[i]];
176       if (prec)
177         emit_byte(cinfo, (int)(qval >> 8));
178       emit_byte(cinfo, (int)(qval & 0xFF));
179     }
180 
181     qtbl->sent_table = TRUE;
182   }
183 
184   return prec;
185 }
186 
187 
188 LOCAL(void)
emit_dht(j_compress_ptr cinfo,int index,boolean is_ac)189 emit_dht(j_compress_ptr cinfo, int index, boolean is_ac)
190 /* Emit a DHT marker */
191 {
192   JHUFF_TBL *htbl;
193   int length, i;
194 
195   if (is_ac) {
196     htbl = cinfo->ac_huff_tbl_ptrs[index];
197     index += 0x10;              /* output index has AC bit set */
198   } else {
199     htbl = cinfo->dc_huff_tbl_ptrs[index];
200   }
201 
202   if (htbl == NULL)
203     ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index);
204 
205   if (!htbl->sent_table) {
206     emit_marker(cinfo, M_DHT);
207 
208     length = 0;
209     for (i = 1; i <= 16; i++)
210       length += htbl->bits[i];
211 
212     emit_2bytes(cinfo, length + 2 + 1 + 16);
213     emit_byte(cinfo, index);
214 
215     for (i = 1; i <= 16; i++)
216       emit_byte(cinfo, htbl->bits[i]);
217 
218     for (i = 0; i < length; i++)
219       emit_byte(cinfo, htbl->huffval[i]);
220 
221     htbl->sent_table = TRUE;
222   }
223 }
224 
225 
226 LOCAL(void)
emit_dac(j_compress_ptr cinfo)227 emit_dac(j_compress_ptr cinfo)
228 /* Emit a DAC marker */
229 /* Since the useful info is so small, we want to emit all the tables in */
230 /* one DAC marker.  Therefore this routine does its own scan of the table. */
231 {
232 #ifdef C_ARITH_CODING_SUPPORTED
233   char dc_in_use[NUM_ARITH_TBLS];
234   char ac_in_use[NUM_ARITH_TBLS];
235   int length, i;
236   jpeg_component_info *compptr;
237 
238   for (i = 0; i < NUM_ARITH_TBLS; i++)
239     dc_in_use[i] = ac_in_use[i] = 0;
240 
241   for (i = 0; i < cinfo->comps_in_scan; i++) {
242     compptr = cinfo->cur_comp_info[i];
243     /* DC needs no table for refinement scan */
244     if (cinfo->Ss == 0 && cinfo->Ah == 0)
245       dc_in_use[compptr->dc_tbl_no] = 1;
246     /* AC needs no table when not present */
247     if (cinfo->Se)
248       ac_in_use[compptr->ac_tbl_no] = 1;
249   }
250 
251   length = 0;
252   for (i = 0; i < NUM_ARITH_TBLS; i++)
253     length += dc_in_use[i] + ac_in_use[i];
254 
255   if (length) {
256     emit_marker(cinfo, M_DAC);
257 
258     emit_2bytes(cinfo, length * 2 + 2);
259 
260     for (i = 0; i < NUM_ARITH_TBLS; i++) {
261       if (dc_in_use[i]) {
262         emit_byte(cinfo, i);
263         emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i] << 4));
264       }
265       if (ac_in_use[i]) {
266         emit_byte(cinfo, i + 0x10);
267         emit_byte(cinfo, cinfo->arith_ac_K[i]);
268       }
269     }
270   }
271 #endif /* C_ARITH_CODING_SUPPORTED */
272 }
273 
274 
275 LOCAL(void)
emit_dri(j_compress_ptr cinfo)276 emit_dri(j_compress_ptr cinfo)
277 /* Emit a DRI marker */
278 {
279   emit_marker(cinfo, M_DRI);
280 
281   emit_2bytes(cinfo, 4);        /* fixed length */
282 
283   emit_2bytes(cinfo, (int)cinfo->restart_interval);
284 }
285 
286 
287 LOCAL(void)
emit_sof(j_compress_ptr cinfo,JPEG_MARKER code)288 emit_sof(j_compress_ptr cinfo, JPEG_MARKER code)
289 /* Emit a SOF marker */
290 {
291   int ci;
292   jpeg_component_info *compptr;
293 
294   emit_marker(cinfo, code);
295 
296   emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */
297 
298   /* Make sure image isn't bigger than SOF field can handle */
299   if ((long)cinfo->_jpeg_height > 65535L || (long)cinfo->_jpeg_width > 65535L)
300     ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int)65535);
301 
302   emit_byte(cinfo, cinfo->data_precision);
303   emit_2bytes(cinfo, (int)cinfo->_jpeg_height);
304   emit_2bytes(cinfo, (int)cinfo->_jpeg_width);
305 
306   emit_byte(cinfo, cinfo->num_components);
307 
308   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
309        ci++, compptr++) {
310     emit_byte(cinfo, compptr->component_id);
311     emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor);
312     emit_byte(cinfo, compptr->quant_tbl_no);
313   }
314 }
315 
316 
317 LOCAL(void)
emit_sos(j_compress_ptr cinfo)318 emit_sos(j_compress_ptr cinfo)
319 /* Emit a SOS marker */
320 {
321   int i, td, ta;
322   jpeg_component_info *compptr;
323 
324   emit_marker(cinfo, M_SOS);
325 
326   emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */
327 
328   emit_byte(cinfo, cinfo->comps_in_scan);
329 
330   for (i = 0; i < cinfo->comps_in_scan; i++) {
331     compptr = cinfo->cur_comp_info[i];
332     emit_byte(cinfo, compptr->component_id);
333 
334     /* We emit 0 for unused field(s); this is recommended by the P&M text
335      * but does not seem to be specified in the standard.
336      */
337 
338     /* DC needs no table for refinement scan */
339     td = cinfo->Ss == 0 && cinfo->Ah == 0 ? compptr->dc_tbl_no : 0;
340     /* AC needs no table when not present */
341     ta = cinfo->Se ? compptr->ac_tbl_no : 0;
342 
343     emit_byte(cinfo, (td << 4) + ta);
344   }
345 
346   emit_byte(cinfo, cinfo->Ss);
347   emit_byte(cinfo, cinfo->Se);
348   emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al);
349 }
350 
351 
352 LOCAL(void)
emit_jfif_app0(j_compress_ptr cinfo)353 emit_jfif_app0(j_compress_ptr cinfo)
354 /* Emit a JFIF-compliant APP0 marker */
355 {
356   /*
357    * Length of APP0 block       (2 bytes)
358    * Block ID                   (4 bytes - ASCII "JFIF")
359    * Zero byte                  (1 byte to terminate the ID string)
360    * Version Major, Minor       (2 bytes - major first)
361    * Units                      (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
362    * Xdpu                       (2 bytes - dots per unit horizontal)
363    * Ydpu                       (2 bytes - dots per unit vertical)
364    * Thumbnail X size           (1 byte)
365    * Thumbnail Y size           (1 byte)
366    */
367 
368   emit_marker(cinfo, M_APP0);
369 
370   emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
371 
372   emit_byte(cinfo, 0x4A);       /* Identifier: ASCII "JFIF" */
373   emit_byte(cinfo, 0x46);
374   emit_byte(cinfo, 0x49);
375   emit_byte(cinfo, 0x46);
376   emit_byte(cinfo, 0);
377   emit_byte(cinfo, cinfo->JFIF_major_version); /* Version fields */
378   emit_byte(cinfo, cinfo->JFIF_minor_version);
379   emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
380   emit_2bytes(cinfo, (int)cinfo->X_density);
381   emit_2bytes(cinfo, (int)cinfo->Y_density);
382   emit_byte(cinfo, 0);          /* No thumbnail image */
383   emit_byte(cinfo, 0);
384 }
385 
386 
387 LOCAL(void)
emit_adobe_app14(j_compress_ptr cinfo)388 emit_adobe_app14(j_compress_ptr cinfo)
389 /* Emit an Adobe APP14 marker */
390 {
391   /*
392    * Length of APP14 block      (2 bytes)
393    * Block ID                   (5 bytes - ASCII "Adobe")
394    * Version Number             (2 bytes - currently 100)
395    * Flags0                     (2 bytes - currently 0)
396    * Flags1                     (2 bytes - currently 0)
397    * Color transform            (1 byte)
398    *
399    * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
400    * now in circulation seem to use Version = 100, so that's what we write.
401    *
402    * We write the color transform byte as 1 if the JPEG color space is
403    * YCbCr, 2 if it's YCCK, 0 otherwise.  Adobe's definition has to do with
404    * whether the encoder performed a transformation, which is pretty useless.
405    */
406 
407   emit_marker(cinfo, M_APP14);
408 
409   emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
410 
411   emit_byte(cinfo, 0x41);       /* Identifier: ASCII "Adobe" */
412   emit_byte(cinfo, 0x64);
413   emit_byte(cinfo, 0x6F);
414   emit_byte(cinfo, 0x62);
415   emit_byte(cinfo, 0x65);
416   emit_2bytes(cinfo, 100);      /* Version */
417   emit_2bytes(cinfo, 0);        /* Flags0 */
418   emit_2bytes(cinfo, 0);        /* Flags1 */
419   switch (cinfo->jpeg_color_space) {
420   case JCS_YCbCr:
421     emit_byte(cinfo, 1);        /* Color transform = 1 */
422     break;
423   case JCS_YCCK:
424     emit_byte(cinfo, 2);        /* Color transform = 2 */
425     break;
426   default:
427     emit_byte(cinfo, 0);        /* Color transform = 0 */
428     break;
429   }
430 }
431 
432 
433 /*
434  * These routines allow writing an arbitrary marker with parameters.
435  * The only intended use is to emit COM or APPn markers after calling
436  * write_file_header and before calling write_frame_header.
437  * Other uses are not guaranteed to produce desirable results.
438  * Counting the parameter bytes properly is the caller's responsibility.
439  */
440 
441 METHODDEF(void)
write_marker_header(j_compress_ptr cinfo,int marker,unsigned int datalen)442 write_marker_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
443 /* Emit an arbitrary marker header */
444 {
445   if (datalen > (unsigned int)65533)            /* safety check */
446     ERREXIT(cinfo, JERR_BAD_LENGTH);
447 
448   emit_marker(cinfo, (JPEG_MARKER)marker);
449 
450   emit_2bytes(cinfo, (int)(datalen + 2));       /* total length */
451 }
452 
453 METHODDEF(void)
write_marker_byte(j_compress_ptr cinfo,int val)454 write_marker_byte(j_compress_ptr cinfo, int val)
455 /* Emit one byte of marker parameters following write_marker_header */
456 {
457   emit_byte(cinfo, val);
458 }
459 
460 
461 /*
462  * Write datastream header.
463  * This consists of an SOI and optional APPn markers.
464  * We recommend use of the JFIF marker, but not the Adobe marker,
465  * when using YCbCr or grayscale data.  The JFIF marker should NOT
466  * be used for any other JPEG colorspace.  The Adobe marker is helpful
467  * to distinguish RGB, CMYK, and YCCK colorspaces.
468  * Note that an application can write additional header markers after
469  * jpeg_start_compress returns.
470  */
471 
472 METHODDEF(void)
write_file_header(j_compress_ptr cinfo)473 write_file_header(j_compress_ptr cinfo)
474 {
475   my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
476 
477   emit_marker(cinfo, M_SOI);    /* first the SOI */
478 
479   /* SOI is defined to reset restart interval to 0 */
480   marker->last_restart_interval = 0;
481 
482   if (cinfo->write_JFIF_header) /* next an optional JFIF APP0 */
483     emit_jfif_app0(cinfo);
484   if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
485     emit_adobe_app14(cinfo);
486 }
487 
488 
489 /*
490  * Write frame header.
491  * This consists of DQT and SOFn markers.
492  * Note that we do not emit the SOF until we have emitted the DQT(s).
493  * This avoids compatibility problems with incorrect implementations that
494  * try to error-check the quant table numbers as soon as they see the SOF.
495  */
496 
497 METHODDEF(void)
write_frame_header(j_compress_ptr cinfo)498 write_frame_header(j_compress_ptr cinfo)
499 {
500   int ci, prec;
501   boolean is_baseline;
502   jpeg_component_info *compptr;
503 
504   /* Emit DQT for each quantization table.
505    * Note that emit_dqt() suppresses any duplicate tables.
506    */
507   prec = 0;
508   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
509        ci++, compptr++) {
510     prec += emit_dqt(cinfo, compptr->quant_tbl_no);
511   }
512   /* now prec is nonzero iff there are any 16-bit quant tables. */
513 
514   /* Check for a non-baseline specification.
515    * Note we assume that Huffman table numbers won't be changed later.
516    */
517   if (cinfo->arith_code || cinfo->progressive_mode ||
518       cinfo->data_precision != 8) {
519     is_baseline = FALSE;
520   } else {
521     is_baseline = TRUE;
522     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
523          ci++, compptr++) {
524       if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
525         is_baseline = FALSE;
526     }
527     if (prec && is_baseline) {
528       is_baseline = FALSE;
529       /* If it's baseline except for quantizer size, warn the user */
530       TRACEMS(cinfo, 0, JTRC_16BIT_TABLES);
531     }
532   }
533 
534   /* Emit the proper SOF marker */
535   if (cinfo->arith_code) {
536     if (cinfo->progressive_mode)
537       emit_sof(cinfo, M_SOF10); /* SOF code for progressive arithmetic */
538     else
539       emit_sof(cinfo, M_SOF9);  /* SOF code for sequential arithmetic */
540   } else {
541     if (cinfo->progressive_mode)
542       emit_sof(cinfo, M_SOF2);  /* SOF code for progressive Huffman */
543     else if (is_baseline)
544       emit_sof(cinfo, M_SOF0);  /* SOF code for baseline implementation */
545     else
546       emit_sof(cinfo, M_SOF1);  /* SOF code for non-baseline Huffman file */
547   }
548 }
549 
550 
551 /*
552  * Write scan header.
553  * This consists of DHT or DAC markers, optional DRI, and SOS.
554  * Compressed data will be written following the SOS.
555  */
556 
557 METHODDEF(void)
write_scan_header(j_compress_ptr cinfo)558 write_scan_header(j_compress_ptr cinfo)
559 {
560   my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
561   int i;
562   jpeg_component_info *compptr;
563 
564   if (cinfo->arith_code) {
565     /* Emit arith conditioning info.  We may have some duplication
566      * if the file has multiple scans, but it's so small it's hardly
567      * worth worrying about.
568      */
569     emit_dac(cinfo);
570   } else {
571     /* Emit Huffman tables.
572      * Note that emit_dht() suppresses any duplicate tables.
573      */
574     for (i = 0; i < cinfo->comps_in_scan; i++) {
575       compptr = cinfo->cur_comp_info[i];
576       /* DC needs no table for refinement scan */
577       if (cinfo->Ss == 0 && cinfo->Ah == 0)
578         emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
579       /* AC needs no table when not present */
580       if (cinfo->Se)
581         emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
582     }
583   }
584 
585   /* Emit DRI if required --- note that DRI value could change for each scan.
586    * We avoid wasting space with unnecessary DRIs, however.
587    */
588   if (cinfo->restart_interval != marker->last_restart_interval) {
589     emit_dri(cinfo);
590     marker->last_restart_interval = cinfo->restart_interval;
591   }
592 
593   emit_sos(cinfo);
594 }
595 
596 
597 /*
598  * Write datastream trailer.
599  */
600 
601 METHODDEF(void)
write_file_trailer(j_compress_ptr cinfo)602 write_file_trailer(j_compress_ptr cinfo)
603 {
604   emit_marker(cinfo, M_EOI);
605 }
606 
607 
608 /*
609  * Write an abbreviated table-specification datastream.
610  * This consists of SOI, DQT and DHT tables, and EOI.
611  * Any table that is defined and not marked sent_table = TRUE will be
612  * emitted.  Note that all tables will be marked sent_table = TRUE at exit.
613  */
614 
615 METHODDEF(void)
write_tables_only(j_compress_ptr cinfo)616 write_tables_only(j_compress_ptr cinfo)
617 {
618   int i;
619 
620   emit_marker(cinfo, M_SOI);
621 
622   for (i = 0; i < NUM_QUANT_TBLS; i++) {
623     if (cinfo->quant_tbl_ptrs[i] != NULL)
624       (void)emit_dqt(cinfo, i);
625   }
626 
627   if (!cinfo->arith_code) {
628     for (i = 0; i < NUM_HUFF_TBLS; i++) {
629       if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
630         emit_dht(cinfo, i, FALSE);
631       if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
632         emit_dht(cinfo, i, TRUE);
633     }
634   }
635 
636   emit_marker(cinfo, M_EOI);
637 }
638 
639 
640 /*
641  * Initialize the marker writer module.
642  */
643 
644 GLOBAL(void)
jinit_marker_writer(j_compress_ptr cinfo)645 jinit_marker_writer(j_compress_ptr cinfo)
646 {
647   my_marker_ptr marker;
648 
649   /* Create the subobject */
650   marker = (my_marker_ptr)
651     (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
652                                 sizeof(my_marker_writer));
653   cinfo->marker = (struct jpeg_marker_writer *)marker;
654   /* Initialize method pointers */
655   marker->pub.write_file_header = write_file_header;
656   marker->pub.write_frame_header = write_frame_header;
657   marker->pub.write_scan_header = write_scan_header;
658   marker->pub.write_file_trailer = write_file_trailer;
659   marker->pub.write_tables_only = write_tables_only;
660   marker->pub.write_marker_header = write_marker_header;
661   marker->pub.write_marker_byte = write_marker_byte;
662   /* Initialize private state */
663   marker->last_restart_interval = 0;
664 }
665