src/gdcmjasper/src/libjasper/jpc/jpc_cs.h

   1 /*
   2  * Copyright (c) 1999-2000 Image Power, Inc. and the University of
   3  *   British Columbia.
   4  * Copyright (c) 2001-2002 Michael David Adams.
   5  * All rights reserved.
   6  */
   7
   8 /* __START_OF_JASPER_LICENSE__
   9  *
  10  * JasPer License Version 2.0
  11  *
  12  * Copyright (c) 1999-2000 Image Power, Inc.
  13  * Copyright (c) 1999-2000 The University of British Columbia
  14  * Copyright (c) 2001-2003 Michael David Adams
  15  *
  16  * All rights reserved.
  17  *
  18  * Permission is hereby granted, free of charge, to any person (the
  19  * "User") obtaining a copy of this software and associated documentation
  20  * files (the "Software"), to deal in the Software without restriction,
  21  * including without limitation the rights to use, copy, modify, merge,
  22  * publish, distribute, and/or sell copies of the Software, and to permit
  23  * persons to whom the Software is furnished to do so, subject to the
  24  * following conditions:
  25  *
  26  * 1.  The above copyright notices and this permission notice (which
  27  * includes the disclaimer below) shall be included in all copies or
  28  * substantial portions of the Software.
  29  *
  30  * 2.  The name of a copyright holder shall not be used to endorse or
  31  * promote products derived from the Software without specific prior
  32  * written permission.
  33  *
  34  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
  35  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  36  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
  37  * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
  38  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  39  * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO
  40  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
  41  * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
  42  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  43  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  44  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE
  45  * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
  46  * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
  47  * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
  48  * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
  49  * PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS
  50  * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
  51  * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE
  52  * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
  53  * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
  54  * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
  55  * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
  56  * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
  57  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
  58  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
  59  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
  60  *
  61  * __END_OF_JASPER_LICENSE__
  62  */
  63
  64 /*
  65  * JPEG-2000 Code Stream Library
  66  *
  67  * $Id: jpc_cs.h,v 1.1 2005/05/22 18:33:04 malaterre Exp $
  68  */
  69
  70 #ifndef JPC_CS_H
  71 #define JPC_CS_H
  72
  73 /******************************************************************************\
  74 * Includes.
  75 \******************************************************************************/
  76
  77 #include "jasper/jas_image.h"
  78 #include "jasper/jas_stream.h"
  79
  80 #include "jpc_cod.h"
  81
  82 /******************************************************************************\
  83 * Constants and Types.
  84 \******************************************************************************/
  85
  86 /* The maximum number of resolution levels. */
  87 #define  JPC_MAXRLVLS  33
  88
  89 /* The maximum number of bands. */
  90 #define  JPC_MAXBANDS  (3 * JPC_MAXRLVLS + 1)
  91
  92 /* The maximum number of layers. */
  93 #define JPC_MAXLYRS  16384
  94
  95 /**************************************\
  96 * Code stream.
  97 \**************************************/
  98
  99 /*
 100  * Code stream states.
 101  */
 102
 103 /* Initial. */
 104 #define  JPC_CS_INIT  0
 105 /* Main header. */
 106 #define  JPC_CS_MHDR  1
 107 /* Tile-part header. */
 108 #define  JPC_CS_THDR  2
 109 /* Main trailer. */
 110 #define  JPC_CS_MTLR  3
 111 /* Tile-part data. */
 112 #define  JPC_CS_TDATA  4
 113
 114 /*
 115  * Unfortunately, the code stream syntax was not designed in such a way that
 116  * any given marker segment can be correctly decoded without additional state
 117  * derived from previously decoded marker segments.
 118  * For example, a RGN/COC/QCC marker segment cannot be decoded unless the
 119  * number of components is known.
 120  */
 121
 122 /*
 123  * Code stream state information.
 124  */
 125
 126 typedef struct {
 127
 128   /* The number of components. */
 129   uint_fast16_t numcomps;
 130
 131 } jpc_cstate_t;
 132
 133 /**************************************\
 134 * SOT marker segment parameters.
 135 \**************************************/
 136
 137 typedef struct {
 138
 139   /* The tile number. */
 140   uint_fast16_t tileno;
 141
 142   /* The combined length of the marker segment and its auxilary data
 143     (i.e., packet data). */
 144   uint_fast32_t len;
 145
 146   /* The tile-part instance. */
 147   uint_fast8_t partno;
 148
 149   /* The number of tile-parts. */
 150   uint_fast8_t numparts;
 151
 152 } jpc_sot_t;
 153
 154 /**************************************\
 155 * SIZ marker segment parameters.
 156 \**************************************/
 157
 158 /* Per component information. */
 159
 160 typedef struct {
 161
 162   /* The precision of the samples. */
 163   uint_fast8_t prec;
 164
 165   /* The signedness of the samples. */
 166   uint_fast8_t sgnd;
 167
 168   /* The horizontal separation of samples with respect to the reference
 169     grid. */
 170   uint_fast8_t hsamp;
 171
 172   /* The vertical separation of samples with respect to the reference
 173     grid. */
 174   uint_fast8_t vsamp;
 175
 176 } jpc_sizcomp_t;
 177
 178 /* SIZ marker segment parameters. */
 179
 180 typedef struct {
 181
 182   /* The code stream capabilities. */
 183   uint_fast16_t caps;
 184
 185   /* The width of the image in units of the reference grid. */
 186   uint_fast32_t width;
 187
 188   /* The height of the image in units of the reference grid. */
 189   uint_fast32_t height;
 190
 191   /* The horizontal offset from the origin of the reference grid to the
 192     left side of the image area. */
 193   uint_fast32_t xoff;
 194
 195   /* The vertical offset from the origin of the reference grid to the
 196     top side of the image area. */
 197   uint_fast32_t yoff;
 198
 199   /* The nominal width of a tile in units of the reference grid. */
 200   uint_fast32_t tilewidth;
 201
 202   /* The nominal height of a tile in units of the reference grid. */
 203   uint_fast32_t tileheight;
 204
 205   /* The horizontal offset from the origin of the reference grid to the
 206     left side of the first tile. */
 207   uint_fast32_t tilexoff;
 208
 209   /* The vertical offset from the origin of the reference grid to the
 210     top side of the first tile. */
 211   uint_fast32_t tileyoff;
 212
 213   /* The number of components. */
 214   uint_fast16_t numcomps;
 215
 216   /* The per-component information. */
 217   jpc_sizcomp_t *comps;
 218
 219 } jpc_siz_t;
 220
 221 /**************************************\
 222 * COD marker segment parameters.
 223 \**************************************/
 224
 225 /*
 226  * Coding style constants.
 227  */
 228
 229 /* Precincts may be used. */
 230 #define  JPC_COX_PRT  0x01
 231 /* SOP marker segments may be used. */
 232 #define  JPC_COD_SOP  0x02
 233 /* EPH marker segments may be used. */
 234 #define  JPC_COD_EPH  0x04
 235
 236 /*
 237  * Progression order constants.
 238  */
 239
 240 /* Layer-resolution-component-precinct progressive
 241   (i.e., progressive by fidelity). */
 242 #define  JPC_COD_LRCPPRG  0
 243 /* Resolution-layer-component-precinct progressive
 244   (i.e., progressive by resolution). */
 245 #define  JPC_COD_RLCPPRG  1
 246 /* Resolution-precinct-component-layer progressive. */
 247 #define  JPC_COD_RPCLPRG  2
 248 /* Precinct-component-resolution-layer progressive. */
 249 #define  JPC_COD_PCRLPRG  3
 250 /* Component-position-resolution-layer progressive. */
 251 #define  JPC_COD_CPRLPRG  4
 252
 253 /*
 254  * Code block style constants.
 255  */
 256
 257 #define  JPC_COX_LAZY  0x01 /* Selective arithmetic coding bypass. */
 258 #define  JPC_COX_RESET  0x02 /* Reset context probabilities. */
 259 #define  JPC_COX_TERMALL  0x04 /* Terminate all coding passes. */
 260 #define  JPC_COX_VSC    0x08 /* Vertical stripe causal context formation. */
 261 #define  JPC_COX_PTERM  0x10 /* Predictable termination. */
 262 #define  JPC_COX_SEGSYM  0x20 /* Use segmentation symbols. */
 263
 264 /* Transform constants. */
 265 #define  JPC_COX_INS  0x00 /* Irreversible 9/7. */
 266 #define  JPC_COX_RFT  0x01 /* Reversible 5/3. */
 267
 268 /* Multicomponent transform constants. */
 269 #define  JPC_COD_NOMCT  0x00 /* No multicomponent transform. */
 270 #define  JPC_COD_MCT    0x01 /* Multicomponent transform. */
 271
 272 /* Get the code block size value from the code block size exponent. */
 273 #define  JPC_COX_CBLKSIZEEXPN(x)    ((x) - 2)
 274 /* Get the code block size exponent from the code block size value. */
 275 #define  JPC_COX_GETCBLKSIZEEXPN(x)  ((x) + 2)
 276
 277 /* Per resolution-level information. */
 278
 279 typedef struct {
 280
 281   /* The packet partition width. */
 282   uint_fast8_t parwidthval;
 283
 284   /* The packet partition height. */
 285   uint_fast8_t parheightval;
 286
 287 } jpc_coxrlvl_t;
 288
 289 /* Per component information. */
 290
 291 typedef struct {
 292
 293   /* The coding style. */
 294   uint_fast8_t csty;
 295
 296   /* The number of decomposition levels. */
 297   uint_fast8_t numdlvls;
 298
 299   /* The nominal code block width specifier. */
 300   uint_fast8_t cblkwidthval;
 301
 302   /* The nominal code block height specifier. */
 303   uint_fast8_t cblkheightval;
 304
 305   /* The style of coding passes. */
 306   uint_fast8_t cblksty;
 307
 308   /* The QMFB employed. */
 309   uint_fast8_t qmfbid;
 310
 311   /* The number of resolution levels. */
 312   int numrlvls;
 313
 314   /* The per-resolution-level information. */
 315   jpc_coxrlvl_t rlvls[JPC_MAXRLVLS];
 316
 317 } jpc_coxcp_t;
 318
 319 /* COD marker segment parameters. */
 320
 321 typedef struct {
 322
 323   /* The general coding style. */
 324   uint_fast8_t csty;
 325
 326   /* The progression order. */
 327   uint_fast8_t prg;
 328
 329   /* The number of layers. */
 330   uint_fast16_t numlyrs;
 331
 332   /* The multicomponent transform. */
 333   uint_fast8_t mctrans;
 334
 335   /* Component-related parameters. */
 336   jpc_coxcp_t compparms;
 337
 338 } jpc_cod_t;
 339
 340 /* COC marker segment parameters. */
 341
 342 typedef struct {
 343
 344   /* The component number. */
 345   uint_fast16_t compno;
 346
 347   /* Component-related parameters. */
 348   jpc_coxcp_t compparms;
 349
 350 } jpc_coc_t;
 351
 352 /**************************************\
 353 * RGN marker segment parameters.
 354 \**************************************/
 355
 356 /* The maxshift ROI style. */
 357 #define  JPC_RGN_MAXSHIFT  0x00
 358
 359 typedef struct {
 360
 361   /* The component to which the marker applies. */
 362   uint_fast16_t compno;
 363
 364   /* The ROI style. */
 365   uint_fast8_t roisty;
 366
 367   /* The ROI shift value. */
 368   uint_fast8_t roishift;
 369
 370 } jpc_rgn_t;
 371
 372 /**************************************\
 373 * QCD/QCC marker segment parameters.
 374 \**************************************/
 375
 376 /*
 377  * Quantization style constants.
 378  */
 379
 380 #define  JPC_QCX_NOQNT  0 /* No quantization. */
 381 #define  JPC_QCX_SIQNT  1 /* Scalar quantization, implicit. */
 382 #define  JPC_QCX_SEQNT  2 /* Scalar quantization, explicit. */
 383
 384 /*
 385  * Stepsize manipulation macros.
 386  */
 387
 388 #define  JPC_QCX_GETEXPN(x)  ((x) >> 11)
 389 #define  JPC_QCX_GETMANT(x)  ((x) & 0x07ff)
 390 #define  JPC_QCX_EXPN(x)    (assert(!((x) & (~0x1f))), (((x) & 0x1f) << 11))
 391 #define  JPC_QCX_MANT(x)    (assert(!((x) & (~0x7ff))), ((x) & 0x7ff))
 392
 393 /* Per component information. */
 394
 395 typedef struct {
 396
 397   /* The quantization style. */
 398   uint_fast8_t qntsty;
 399
 400   /* The number of step sizes. */
 401   int numstepsizes;
 402
 403   /* The step sizes. */
 404   uint_fast16_t *stepsizes;
 405
 406   /* The number of guard bits. */
 407   uint_fast8_t numguard;
 408
 409 } jpc_qcxcp_t;
 410
 411 /* QCC marker segment parameters. */
 412
 413 typedef struct {
 414
 415   /* The component associated with this marker segment. */
 416   uint_fast16_t compno;
 417
 418   /* The parameters. */
 419   jpc_qcxcp_t compparms;
 420
 421 } jpc_qcc_t;
 422
 423 /* QCD marker segment parameters. */
 424
 425 typedef struct {
 426
 427   /* The parameters. */
 428   jpc_qcxcp_t compparms;
 429
 430 } jpc_qcd_t;
 431
 432 /**************************************\
 433 * POD marker segment parameters.
 434 \**************************************/
 435
 436 typedef struct {
 437
 438   /* The progression order. */
 439   uint_fast8_t prgord;
 440
 441   /* The lower bound (inclusive) on the resolution level for the
 442     progression order volume. */
 443   uint_fast8_t rlvlnostart;
 444
 445   /* The upper bound (exclusive) on the resolution level for the
 446     progression order volume. */
 447   uint_fast8_t rlvlnoend;
 448
 449   /* The lower bound (inclusive) on the component for the progression
 450     order volume. */
 451   uint_fast16_t compnostart;
 452
 453   /* The upper bound (exclusive) on the component for the progression
 454     order volume. */
 455   uint_fast16_t compnoend;
 456
 457   /* The upper bound (exclusive) on the layer for the progression
 458     order volume. */
 459   uint_fast16_t lyrnoend;
 460
 461 } jpc_pocpchg_t;
 462
 463 /* An alias for the above type. */
 464 typedef jpc_pocpchg_t jpc_pchg_t;
 465
 466 /* POC marker segment parameters. */
 467
 468 typedef struct {
 469
 470   /* The number of progression order changes. */
 471   int numpchgs;
 472
 473   /* The per-progression-order-change information. */
 474   jpc_pocpchg_t *pchgs;
 475
 476 } jpc_poc_t;
 477
 478 /**************************************\
 479 * PPM/PPT marker segment parameters.
 480 \**************************************/
 481
 482 /* PPM marker segment parameters. */
 483
 484 typedef struct {
 485
 486   /* The index. */
 487   uint_fast8_t ind;
 488
 489   /* The length. */
 490   uint_fast16_t len;
 491
 492   /* The data. */
 493   uchar *data;
 494
 495 } jpc_ppm_t;
 496
 497 /* PPT marker segment parameters. */
 498
 499 typedef struct {
 500
 501   /* The index. */
 502   uint_fast8_t ind;
 503
 504   /* The length. */
 505   uint_fast32_t len;
 506
 507   /* The data. */
 508   unsigned char *data;
 509
 510 } jpc_ppt_t;
 511
 512 /**************************************\
 513 * COM marker segment parameters.
 514 \**************************************/
 515
 516 /*
 517  * Registration IDs.
 518  */
 519
 520 #define  JPC_COM_BIN    0x00
 521 #define  JPC_COM_LATIN  0x01
 522
 523 typedef struct {
 524
 525   /* The registration ID. */
 526   uint_fast16_t regid;
 527
 528   /* The length of the data in bytes. */
 529   uint_fast16_t len;
 530
 531   /* The data. */
 532   uchar *data;
 533
 534 } jpc_com_t;
 535
 536 /**************************************\
 537 * SOP marker segment parameters.
 538 \**************************************/
 539
 540 typedef struct {
 541
 542   /* The sequence number. */
 543   uint_fast16_t seqno;
 544
 545 } jpc_sop_t;
 546
 547 /**************************************\
 548 * CRG marker segment parameters.
 549 \**************************************/
 550
 551 /* Per component information. */
 552
 553 typedef struct {
 554
 555   /* The horizontal offset. */
 556   uint_fast16_t hoff;
 557
 558   /* The vertical offset. */
 559   uint_fast16_t voff;
 560
 561 } jpc_crgcomp_t;
 562
 563 typedef struct {
 564
 565   /* The number of components. */
 566   int numcomps;
 567
 568   /* Per component information. */
 569   jpc_crgcomp_t *comps;
 570
 571 } jpc_crg_t;
 572
 573 /**************************************\
 574 * Marker segment parameters for unknown marker type.
 575 \**************************************/
 576
 577 typedef struct {
 578
 579   /* The data. */
 580   uchar *data;
 581
 582   /* The length. */
 583   uint_fast16_t len;
 584
 585 } jpc_unk_t;
 586
 587 /**************************************\
 588 * Generic marker segment parameters.
 589 \**************************************/
 590
 591 typedef union {
 592   int soc;  /* unused */
 593   jpc_sot_t sot;
 594   int sod;  /* unused */
 595   int eoc;  /* unused */
 596   jpc_siz_t siz;
 597   jpc_cod_t cod;
 598   jpc_coc_t coc;
 599   jpc_rgn_t rgn;
 600   jpc_qcd_t qcd;
 601   jpc_qcc_t qcc;
 602   jpc_poc_t poc;
 603   /* jpc_plm_t plm; */
 604   /* jpc_plt_t plt; */
 605   jpc_ppm_t ppm;
 606   jpc_ppt_t ppt;
 607   jpc_sop_t sop;
 608   int eph;  /* unused */
 609   jpc_com_t com;
 610   jpc_crg_t crg;
 611   jpc_unk_t unk;
 612 } jpc_msparms_t;
 613
 614 /**************************************\
 615 * Marker segment.
 616 \**************************************/
 617
 618 /* Marker segment IDs. */
 619
 620 /* The smallest valid marker value. */
 621 #define  JPC_MS_MIN  0xff00
 622
 623 /* The largest valid marker value. */
 624 #define  JPC_MS_MAX  0xffff
 625
 626 /* The minimum marker value that cannot occur within packet data. */
 627 #define  JPC_MS_INMIN  0xff80
 628 /* The maximum marker value that cannot occur within packet data. */
 629 #define  JPC_MS_INMAX  0xffff
 630
 631 /* Delimiting marker segments. */
 632 #define  JPC_MS_SOC  0xff4f /* Start of code stream (SOC). */
 633 #define  JPC_MS_SOT  0xff90 /* Start of tile-part (SOT). */
 634 #define  JPC_MS_SOD  0xff93 /* Start of data (SOD). */
 635 #define  JPC_MS_EOC  0xffd9 /* End of code stream (EOC). */
 636
 637 /* Fixed information marker segments. */
 638 #define  JPC_MS_SIZ  0xff51 /* Image and tile size (SIZ). */
 639
 640 /* Functional marker segments. */
 641 #define  JPC_MS_COD  0xff52 /* Coding style default (COD). */
 642 #define JPC_MS_COC  0xff53 /* Coding style component (COC). */
 643 #define  JPC_MS_RGN  0xff5e /* Region of interest (RGN). */
 644 #define JPC_MS_QCD  0xff5c /* Quantization default (QCD). */
 645 #define JPC_MS_QCC  0xff5d /* Quantization component (QCC). */
 646 #define JPC_MS_POC  0xff5f /* Progression order default (POC). */
 647
 648 /* Pointer marker segments. */
 649 #define  JPC_MS_TLM  0xff55 /* Tile-part lengths, main header (TLM). */
 650 #define  JPC_MS_PLM  0xff57 /* Packet length, main header (PLM). */
 651 #define  JPC_MS_PLT  0xff58 /* Packet length, tile-part header (PLT). */
 652 #define  JPC_MS_PPM  0xff60 /* Packed packet headers, main header (PPM). */
 653 #define  JPC_MS_PPT  0xff61 /* Packet packet headers, tile-part header (PPT). */
 654
 655 /* In bit stream marker segments. */
 656 #define  JPC_MS_SOP  0xff91  /* Start of packet (SOP). */
 657 #define  JPC_MS_EPH  0xff92  /* End of packet header (EPH). */
 658
 659 /* Informational marker segments. */
 660 #define  JPC_MS_CRG  0xff63 /* Component registration (CRG). */
 661 #define JPC_MS_COM  0xff64 /* Comment (COM). */
 662
 663 /* Forward declaration. */
 664 struct jpc_msops_s;
 665
 666 /* Generic marker segment class. */
 667
 668 typedef struct {
 669
 670   /* The type of marker segment. */
 671   uint_fast16_t id;
 672
 673   /* The length of the marker segment. */
 674   uint_fast16_t len;
 675
 676   /* The starting offset within the stream. */
 677   uint_fast32_t off;
 678
 679   /* The parameters of the marker segment. */
 680   jpc_msparms_t parms;
 681
 682   /* The marker segment operations. */
 683   struct jpc_msops_s *ops;
 684
 685 } jpc_ms_t;
 686
 687 /* Marker segment operations (which depend on the marker segment type). */
 688
 689 typedef struct jpc_msops_s {
 690
 691   /* Destroy the marker segment parameters. */
 692   void (*destroyparms)(jpc_ms_t *ms);
 693
 694   /* Get the marker segment parameters from a stream. */
 695   int (*getparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
 696
 697   /* Put the marker segment parameters to a stream. */
 698   int (*putparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
 699
 700   /* Dump the marker segment parameters (for debugging). */
 701   int (*dumpparms)(jpc_ms_t *ms, FILE *out);
 702
 703 } jpc_msops_t;
 704
 705 /******************************************************************************\
 706 * Macros/Functions.
 707 \******************************************************************************/
 708
 709 /* Create a code-stream state object. */
 710 jpc_cstate_t *jpc_cstate_create(void);
 711
 712 /* Destroy a code-stream state object. */
 713 void jpc_cstate_destroy(jpc_cstate_t *cstate);
 714
 715 /* Create a marker segment. */
 716 jpc_ms_t *jpc_ms_create(int type);
 717
 718 /* Destroy a marker segment. */
 719 void jpc_ms_destroy(jpc_ms_t *ms);
 720
 721 /* Does a marker segment have parameters? */
 722 #define  JPC_MS_HASPARMS(x) \
 723   (!((x) == JPC_MS_SOC || (x) == JPC_MS_SOD || (x) == JPC_MS_EOC || \
 724     (x) == JPC_MS_EPH || ((x) >= 0xff30 && (x) <= 0xff3f)))
 725
 726 /* Get the marker segment type. */
 727 #define  jpc_ms_gettype(ms) \
 728   ((ms)->id)
 729
 730 /* Read a marker segment from a stream. */
 731 jpc_ms_t *jpc_getms(jas_stream_t *in, jpc_cstate_t *cstate);
 732
 733 /* Write a marker segment to a stream. */
 734 int jpc_putms(jas_stream_t *out, jpc_cstate_t *cstate, jpc_ms_t *ms);
 735
 736 /* Copy code stream data from one stream to another. */
 737 int jpc_getdata(jas_stream_t *in, jas_stream_t *out, long n);
 738
 739 /* Copy code stream data from one stream to another. */
 740 int jpc_putdata(jas_stream_t *out, jas_stream_t *in, long n);
 741
 742 /* Dump a marker segment (for debugging). */
 743 void jpc_ms_dump(jpc_ms_t *ms, FILE *out);
 744
 745 /* Read a 8-bit unsigned integer from a stream. */
 746 int jpc_getuint8(jas_stream_t *in, uint_fast8_t *val);
 747
 748 /* Read a 16-bit unsigned integer from a stream. */
 749 int jpc_getuint16(jas_stream_t *in, uint_fast16_t *val);
 750
 751 /* Read a 32-bit unsigned integer from a stream. */
 752 int jpc_getuint32(jas_stream_t *in, uint_fast32_t *val);
 753
 754 /* Write a 8-bit unsigned integer to a stream. */
 755 int jpc_putuint8(jas_stream_t *out, uint_fast8_t val);
 756
 757 /* Write a 16-bit unsigned integer to a stream. */
 758 int jpc_putuint16(jas_stream_t *out, uint_fast16_t val);
 759
 760 /* Write a 32-bit unsigned integer to a stream. */
 761 int jpc_putuint32(jas_stream_t *out, uint_fast32_t val);
 762
 763 #endif