libs/jpeg6/jpegint.h

   1 /*
   2
   3  * jpegint.h
   4
   5  *
   6
   7  * Copyright (C) 1991-1995, Thomas G. Lane.
   8
   9  * This file is part of the Independent JPEG Group's software.
  10
  11  * For conditions of distribution and use, see the accompanying README file.
  12
  13  *
  14
  15  * This file provides common declarations for the various JPEG modules.
  16
  17  * These declarations are considered internal to the JPEG library; most
  18
  19  * applications using the library shouldn't need to include this file.
  20
  21  */
  22
  23
  24
  25
  26
  27 /* Declarations for both compression & decompression */
  28
  29
  30
  31 typedef enum {                  /* Operating modes for buffer controllers */
  32
  33         JBUF_PASS_THRU,         /* Plain stripwise operation */
  34
  35         /* Remaining modes require a full-image buffer to have been created */
  36
  37         JBUF_SAVE_SOURCE,       /* Run source subobject only, save output */
  38
  39         JBUF_CRANK_DEST,        /* Run dest subobject only, using saved data */
  40
  41         JBUF_SAVE_AND_PASS      /* Run both subobjects, save output */
  42
  43 } J_BUF_MODE;
  44
  45
  46
  47 /* Values of global_state field (jdapi.c has some dependencies on ordering!) */
  48
  49 #define CSTATE_START    100     /* after create_compress */
  50
  51 #define CSTATE_SCANNING 101     /* start_compress done, write_scanlines OK */
  52
  53 #define CSTATE_RAW_OK   102     /* start_compress done, write_raw_data OK */
  54
  55 #define CSTATE_WRCOEFS  103     /* jpeg_write_coefficients done */
  56
  57 #define DSTATE_START    200     /* after create_decompress */
  58
  59 #define DSTATE_INHEADER 201     /* reading header markers, no SOS yet */
  60
  61 #define DSTATE_READY    202     /* found SOS, ready for start_decompress */
  62
  63 #define DSTATE_PRELOAD  203     /* reading multiscan file in start_decompress*/
  64
  65 #define DSTATE_PRESCAN  204     /* performing dummy pass for 2-pass quant */
  66
  67 #define DSTATE_SCANNING 205     /* start_decompress done, read_scanlines OK */
  68
  69 #define DSTATE_RAW_OK   206     /* start_decompress done, read_raw_data OK */
  70
  71 #define DSTATE_BUFIMAGE 207     /* expecting jpeg_start_output */
  72
  73 #define DSTATE_BUFPOST  208     /* looking for SOS/EOI in jpeg_finish_output */
  74
  75 #define DSTATE_RDCOEFS  209     /* reading file in jpeg_read_coefficients */
  76
  77 #define DSTATE_STOPPING 210     /* looking for EOI in jpeg_finish_decompress */
  78
  79
  80
  81
  82
  83 /* Declarations for compression modules */
  84
  85
  86
  87 /* Master control module */
  88
  89 struct jpeg_comp_master {
  90
  91   JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
  92
  93   JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
  94
  95   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
  96
  97
  98
  99   /* State variables made visible to other modules */
 100
 101   boolean call_pass_startup;    /* True if pass_startup must be called */
 102
 103   boolean is_last_pass;         /* True during last pass */
 104
 105 };
 106
 107
 108
 109 /* Main buffer control (downsampled-data buffer) */
 110
 111 struct jpeg_c_main_controller {
 112
 113   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
 114
 115   JMETHOD(void, process_data, (j_compress_ptr cinfo,
 116
 117                                JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
 118
 119                                JDIMENSION in_rows_avail));
 120
 121 };
 122
 123
 124
 125 /* Compression preprocessing (downsampling input buffer control) */
 126
 127 struct jpeg_c_prep_controller {
 128
 129   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
 130
 131   JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
 132
 133                                    JSAMPARRAY input_buf,
 134
 135                                    JDIMENSION *in_row_ctr,
 136
 137                                    JDIMENSION in_rows_avail,
 138
 139                                    JSAMPIMAGE output_buf,
 140
 141                                    JDIMENSION *out_row_group_ctr,
 142
 143                                    JDIMENSION out_row_groups_avail));
 144
 145 };
 146
 147
 148
 149 /* Coefficient buffer control */
 150
 151 struct jpeg_c_coef_controller {
 152
 153   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
 154
 155   JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
 156
 157                                    JSAMPIMAGE input_buf));
 158
 159 };
 160
 161
 162
 163 /* Colorspace conversion */
 164
 165 struct jpeg_color_converter {
 166
 167   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
 168
 169   JMETHOD(void, color_convert, (j_compress_ptr cinfo,
 170
 171                                 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
 172
 173                                 JDIMENSION output_row, int num_rows));
 174
 175 };
 176
 177
 178
 179 /* Downsampling */
 180
 181 struct jpeg_downsampler {
 182
 183   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
 184
 185   JMETHOD(void, downsample, (j_compress_ptr cinfo,
 186
 187                              JSAMPIMAGE input_buf, JDIMENSION in_row_index,
 188
 189                              JSAMPIMAGE output_buf,
 190
 191                              JDIMENSION out_row_group_index));
 192
 193
 194
 195   boolean need_context_rows;    /* TRUE if need rows above & below */
 196
 197 };
 198
 199
 200
 201 /* Forward DCT (also controls coefficient quantization) */
 202
 203 struct jpeg_forward_dct {
 204
 205   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
 206
 207   /* perhaps this should be an array??? */
 208
 209   JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
 210
 211                               jpeg_component_info * compptr,
 212
 213                               JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
 214
 215                               JDIMENSION start_row, JDIMENSION start_col,
 216
 217                               JDIMENSION num_blocks));
 218
 219 };
 220
 221
 222
 223 /* Entropy encoding */
 224
 225 struct jpeg_entropy_encoder {
 226
 227   JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
 228
 229   JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
 230
 231   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
 232
 233 };
 234
 235
 236
 237 /* Marker writing */
 238
 239 struct jpeg_marker_writer {
 240
 241   /* write_any_marker is exported for use by applications */
 242
 243   /* Probably only COM and APPn markers should be written */
 244
 245   JMETHOD(void, write_any_marker, (j_compress_ptr cinfo, int marker,
 246
 247                                    const JOCTET *dataptr, unsigned int datalen));
 248
 249   JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
 250
 251   JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
 252
 253   JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
 254
 255   JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
 256
 257   JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
 258
 259 };
 260
 261
 262
 263
 264
 265 /* Declarations for decompression modules */
 266
 267
 268
 269 /* Master control module */
 270
 271 struct jpeg_decomp_master {
 272
 273   JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
 274
 275   JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
 276
 277
 278
 279   /* State variables made visible to other modules */
 280
 281   boolean is_dummy_pass;        /* True during 1st pass for 2-pass quant */
 282
 283 };
 284
 285
 286
 287 /* Input control module */
 288
 289 struct jpeg_input_controller {
 290
 291   JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
 292
 293   JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
 294
 295   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
 296
 297   JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
 298
 299
 300
 301   /* State variables made visible to other modules */
 302
 303   boolean has_multiple_scans;   /* True if file has multiple scans */
 304
 305   boolean eoi_reached;          /* True when EOI has been consumed */
 306
 307 };
 308
 309
 310
 311 /* Main buffer control (downsampled-data buffer) */
 312
 313 struct jpeg_d_main_controller {
 314
 315   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
 316
 317   JMETHOD(void, process_data, (j_decompress_ptr cinfo,
 318
 319                                JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
 320
 321                                JDIMENSION out_rows_avail));
 322
 323 };
 324
 325
 326
 327 /* Coefficient buffer control */
 328
 329 struct jpeg_d_coef_controller {
 330
 331   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
 332
 333   JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
 334
 335   JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
 336
 337   JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
 338
 339                                  JSAMPIMAGE output_buf));
 340
 341   /* Pointer to array of coefficient virtual arrays, or NULL if none */
 342
 343   jvirt_barray_ptr *coef_arrays;
 344
 345 };
 346
 347
 348
 349 /* Decompression postprocessing (color quantization buffer control) */
 350
 351 struct jpeg_d_post_controller {
 352
 353   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
 354
 355   JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
 356
 357                                     JSAMPIMAGE input_buf,
 358
 359                                     JDIMENSION *in_row_group_ctr,
 360
 361                                     JDIMENSION in_row_groups_avail,
 362
 363                                     JSAMPARRAY output_buf,
 364
 365                                     JDIMENSION *out_row_ctr,
 366
 367                                     JDIMENSION out_rows_avail));
 368
 369 };
 370
 371
 372
 373 /* Marker reading & parsing */
 374
 375 struct jpeg_marker_reader {
 376
 377   JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
 378
 379   /* Read markers until SOS or EOI.
 380
 381    * Returns same codes as are defined for jpeg_consume_input:
 382
 383    * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
 384
 385    */
 386
 387   JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
 388
 389   /* Read a restart marker --- exported for use by entropy decoder only */
 390
 391   jpeg_marker_parser_method read_restart_marker;
 392
 393   /* Application-overridable marker processing methods */
 394
 395   jpeg_marker_parser_method process_COM;
 396
 397   jpeg_marker_parser_method process_APPn[16];
 398
 399
 400
 401   /* State of marker reader --- nominally internal, but applications
 402
 403    * supplying COM or APPn handlers might like to know the state.
 404
 405    */
 406
 407   boolean saw_SOI;              /* found SOI? */
 408
 409   boolean saw_SOF;              /* found SOF? */
 410
 411   int next_restart_num;         /* next restart number expected (0-7) */
 412
 413   unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */
 414
 415 };
 416
 417
 418
 419 /* Entropy decoding */
 420
 421 struct jpeg_entropy_decoder {
 422
 423   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
 424
 425   JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
 426
 427                                 JBLOCKROW *MCU_data));
 428
 429 };
 430
 431
 432
 433 /* Inverse DCT (also performs dequantization) */
 434
 435 typedef JMETHOD(void, inverse_DCT_method_ptr,
 436
 437                 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 438
 439                  JCOEFPTR coef_block,
 440
 441                  JSAMPARRAY output_buf, JDIMENSION output_col));
 442
 443
 444
 445 struct jpeg_inverse_dct {
 446
 447   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
 448
 449   /* It is useful to allow each component to have a separate IDCT method. */
 450
 451   inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
 452
 453 };
 454
 455
 456
 457 /* Upsampling (note that upsampler must also call color converter) */
 458
 459 struct jpeg_upsampler {
 460
 461   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
 462
 463   JMETHOD(void, upsample, (j_decompress_ptr cinfo,
 464
 465                            JSAMPIMAGE input_buf,
 466
 467                            JDIMENSION *in_row_group_ctr,
 468
 469                            JDIMENSION in_row_groups_avail,
 470
 471                            JSAMPARRAY output_buf,
 472
 473                            JDIMENSION *out_row_ctr,
 474
 475                            JDIMENSION out_rows_avail));
 476
 477
 478
 479   boolean need_context_rows;    /* TRUE if need rows above & below */
 480
 481 };
 482
 483
 484
 485 /* Colorspace conversion */
 486
 487 struct jpeg_color_deconverter {
 488
 489   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
 490
 491   JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
 492
 493                                 JSAMPIMAGE input_buf, JDIMENSION input_row,
 494
 495                                 JSAMPARRAY output_buf, int num_rows));
 496
 497 };
 498
 499
 500
 501 /* Color quantization or color precision reduction */
 502
 503 struct jpeg_color_quantizer {
 504
 505   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
 506
 507   JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
 508
 509                                  JSAMPARRAY input_buf, JSAMPARRAY output_buf,
 510
 511                                  int num_rows));
 512
 513   JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
 514
 515   JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
 516
 517 };
 518
 519
 520
 521
 522
 523 /* Miscellaneous useful macros */
 524
 525
 526
 527 #undef MAX
 528
 529 #define MAX(a,b)        ((a) > (b) ? (a) : (b))
 530
 531 #undef MIN
 532
 533 #define MIN(a,b)        ((a) < (b) ? (a) : (b))
 534
 535
 536
 537
 538
 539 /* We assume that right shift corresponds to signed division by 2 with
 540
 541  * rounding towards minus infinity.  This is correct for typical "arithmetic
 542
 543  * shift" instructions that shift in copies of the sign bit.  But some
 544
 545  * C compilers implement >> with an unsigned shift.  For these machines you
 546
 547  * must define RIGHT_SHIFT_IS_UNSIGNED.
 548
 549  * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
 550
 551  * It is only applied with constant shift counts.  SHIFT_TEMPS must be
 552
 553  * included in the variables of any routine using RIGHT_SHIFT.
 554
 555  */
 556
 557
 558
 559 #ifdef RIGHT_SHIFT_IS_UNSIGNED
 560
 561 #define SHIFT_TEMPS     INT32 shift_temp;
 562
 563 #define RIGHT_SHIFT(x,shft)  \
 564
 565         ((shift_temp = (x)) < 0 ? \
 566
 567          (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
 568
 569          (shift_temp >> (shft)))
 570
 571 #else
 572
 573 #define SHIFT_TEMPS
 574
 575 #define RIGHT_SHIFT(x,shft)     ((x) >> (shft))
 576
 577 #endif
 578
 579
 580
 581
 582
 583 /* Short forms of external names for systems with brain-damaged linkers. */
 584
 585
 586
 587 #ifdef NEED_SHORT_EXTERNAL_NAMES
 588
 589 #define jinit_compress_master   jICompress
 590
 591 #define jinit_c_master_control  jICMaster
 592
 593 #define jinit_c_main_controller jICMainC
 594
 595 #define jinit_c_prep_controller jICPrepC
 596
 597 #define jinit_c_coef_controller jICCoefC
 598
 599 #define jinit_color_converter   jICColor
 600
 601 #define jinit_downsampler       jIDownsampler
 602
 603 #define jinit_forward_dct       jIFDCT
 604
 605 #define jinit_huff_encoder      jIHEncoder
 606
 607 #define jinit_phuff_encoder     jIPHEncoder
 608
 609 #define jinit_marker_writer     jIMWriter
 610
 611 #define jinit_master_decompress jIDMaster
 612
 613 #define jinit_d_main_controller jIDMainC
 614
 615 #define jinit_d_coef_controller jIDCoefC
 616
 617 #define jinit_d_post_controller jIDPostC
 618
 619 #define jinit_input_controller  jIInCtlr
 620
 621 #define jinit_marker_reader     jIMReader
 622
 623 #define jinit_huff_decoder      jIHDecoder
 624
 625 #define jinit_phuff_decoder     jIPHDecoder
 626
 627 #define jinit_inverse_dct       jIIDCT
 628
 629 #define jinit_upsampler         jIUpsampler
 630
 631 #define jinit_color_deconverter jIDColor
 632
 633 #define jinit_1pass_quantizer   jI1Quant
 634
 635 #define jinit_2pass_quantizer   jI2Quant
 636
 637 #define jinit_merged_upsampler  jIMUpsampler
 638
 639 #define jinit_memory_mgr        jIMemMgr
 640
 641 #define jdiv_round_up           jDivRound
 642
 643 #define jround_up               jRound
 644
 645 #define jcopy_sample_rows       jCopySamples
 646
 647 #define jcopy_block_row         jCopyBlocks
 648
 649 #define jzero_far               jZeroFar
 650
 651 #define jpeg_zigzag_order       jZIGTable
 652
 653 #define jpeg_natural_order      jZAGTable
 654
 655 #endif /* NEED_SHORT_EXTERNAL_NAMES */
 656
 657
 658
 659
 660
 661 /* Compression module initialization routines */
 662
 663 EXTERN void jinit_compress_master JPP((j_compress_ptr cinfo));
 664
 665 EXTERN void jinit_c_master_control JPP((j_compress_ptr cinfo,
 666
 667                                         boolean transcode_only));
 668
 669 EXTERN void jinit_c_main_controller JPP((j_compress_ptr cinfo,
 670
 671                                          boolean need_full_buffer));
 672
 673 EXTERN void jinit_c_prep_controller JPP((j_compress_ptr cinfo,
 674
 675                                          boolean need_full_buffer));
 676
 677 EXTERN void jinit_c_coef_controller JPP((j_compress_ptr cinfo,
 678
 679                                          boolean need_full_buffer));
 680
 681 EXTERN void jinit_color_converter JPP((j_compress_ptr cinfo));
 682
 683 EXTERN void jinit_downsampler JPP((j_compress_ptr cinfo));
 684
 685 EXTERN void jinit_forward_dct JPP((j_compress_ptr cinfo));
 686
 687 EXTERN void jinit_huff_encoder JPP((j_compress_ptr cinfo));
 688
 689 EXTERN void jinit_phuff_encoder JPP((j_compress_ptr cinfo));
 690
 691 EXTERN void jinit_marker_writer JPP((j_compress_ptr cinfo));
 692
 693 /* Decompression module initialization routines */
 694
 695 EXTERN void jinit_master_decompress JPP((j_decompress_ptr cinfo));
 696
 697 EXTERN void jinit_d_main_controller JPP((j_decompress_ptr cinfo,
 698
 699                                          boolean need_full_buffer));
 700
 701 EXTERN void jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
 702
 703                                          boolean need_full_buffer));
 704
 705 EXTERN void jinit_d_post_controller JPP((j_decompress_ptr cinfo,
 706
 707                                          boolean need_full_buffer));
 708
 709 EXTERN void jinit_input_controller JPP((j_decompress_ptr cinfo));
 710
 711 EXTERN void jinit_marker_reader JPP((j_decompress_ptr cinfo));
 712
 713 EXTERN void jinit_huff_decoder JPP((j_decompress_ptr cinfo));
 714
 715 EXTERN void jinit_phuff_decoder JPP((j_decompress_ptr cinfo));
 716
 717 EXTERN void jinit_inverse_dct JPP((j_decompress_ptr cinfo));
 718
 719 EXTERN void jinit_upsampler JPP((j_decompress_ptr cinfo));
 720
 721 EXTERN void jinit_color_deconverter JPP((j_decompress_ptr cinfo));
 722
 723 EXTERN void jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
 724
 725 EXTERN void jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
 726
 727 EXTERN void jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
 728
 729 /* Memory manager initialization */
 730
 731 EXTERN void jinit_memory_mgr JPP((j_common_ptr cinfo));
 732
 733
 734
 735 /* Utility routines in jutils.c */
 736
 737 EXTERN long jdiv_round_up JPP((long a, long b));
 738
 739 EXTERN long jround_up JPP((long a, long b));
 740
 741 EXTERN void jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
 742
 743                                    JSAMPARRAY output_array, int dest_row,
 744
 745                                    int num_rows, JDIMENSION num_cols));
 746
 747 EXTERN void jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
 748
 749                                  JDIMENSION num_blocks));
 750
 751 EXTERN void jzero_far JPP((void FAR * target, size_t bytestozero));
 752
 753 /* Constant tables in jutils.c */
 754
 755 extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
 756
 757 extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
 758
 759
 760
 761 /* Suppress undefined-structure complaints if necessary. */
 762
 763
 764
 765 #ifdef INCOMPLETE_TYPES_BROKEN
 766
 767 #ifndef AM_MEMORY_MANAGER       /* only jmemmgr.c defines these */
 768
 769 struct jvirt_sarray_control { long dummy; };
 770
 771 struct jvirt_barray_control { long dummy; };
 772
 773 #endif
 774
 775 #endif /* INCOMPLETE_TYPES_BROKEN */
 776