Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * JPEG 2000 common defines, structures and functions
  3.  * Copyright (c) 2007 Kamil Nowosad
  4.  * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
  5.  *
  6.  * This file is part of FFmpeg.
  7.  *
  8.  * FFmpeg is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Lesser General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2.1 of the License, or (at your option) any later version.
  12.  *
  13.  * FFmpeg is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Lesser General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public
  19.  * License along with FFmpeg; if not, write to the Free Software
  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21.  */
  22.  
  23. #ifndef AVCODEC_JPEG2000_H
  24. #define AVCODEC_JPEG2000_H
  25.  
  26. /**
  27.  * @file
  28.  * JPEG 2000 structures and defines common
  29.  * to encoder and decoder
  30.  */
  31.  
  32. #include <stdint.h>
  33.  
  34. #include "avcodec.h"
  35. #include "mqc.h"
  36. #include "jpeg2000dwt.h"
  37.  
  38. enum Jpeg2000Markers {
  39.     JPEG2000_SOC = 0xff4f, // start of codestream
  40.     JPEG2000_SIZ = 0xff51, // image and tile size
  41.     JPEG2000_COD,          // coding style default
  42.     JPEG2000_COC,          // coding style component
  43.     JPEG2000_TLM = 0xff55, // packed packet headers, tile-part header
  44.     JPEG2000_PLM = 0xff57, // tile-part lengths
  45.     JPEG2000_PLT,          // packet length, main header
  46.     JPEG2000_QCD = 0xff5c, // quantization default
  47.     JPEG2000_QCC,          // quantization component
  48.     JPEG2000_RGN,          // region of interest
  49.     JPEG2000_POC,          // progression order change
  50.     JPEG2000_PPM,          // packet length, tile-part header
  51.     JPEG2000_PPT,          // packed packet headers, main header
  52.     JPEG2000_CRG = 0xff63, // component registration
  53.     JPEG2000_COM,          // comment
  54.     JPEG2000_SOT = 0xff90, // start of tile-part
  55.     JPEG2000_SOP,          // start of packet
  56.     JPEG2000_EPH,          // end of packet header
  57.     JPEG2000_SOD,          // start of data
  58.     JPEG2000_EOC = 0xffd9, // end of codestream
  59. };
  60.  
  61. enum Jpeg2000Quantsty { // quantization style
  62.     JPEG2000_QSTY_NONE, // no quantization
  63.     JPEG2000_QSTY_SI,   // scalar derived
  64.     JPEG2000_QSTY_SE    // scalar expounded
  65. };
  66.  
  67. #define JPEG2000_MAX_CBLKW 64
  68. #define JPEG2000_MAX_CBLKH 64
  69.  
  70.  
  71. #define JPEG2000_MAX_DECLEVELS 32
  72. #define JPEG2000_MAX_RESLEVELS (JPEG2000_MAX_DECLEVELS + 1)
  73.  
  74. // T1 flags
  75. // flags determining significance of neighbor coefficients
  76. #define JPEG2000_T1_SIG_N  0x0001
  77. #define JPEG2000_T1_SIG_E  0x0002
  78. #define JPEG2000_T1_SIG_W  0x0004
  79. #define JPEG2000_T1_SIG_S  0x0008
  80. #define JPEG2000_T1_SIG_NE 0x0010
  81. #define JPEG2000_T1_SIG_NW 0x0020
  82. #define JPEG2000_T1_SIG_SE 0x0040
  83. #define JPEG2000_T1_SIG_SW 0x0080
  84. #define JPEG2000_T1_SIG_NB (JPEG2000_T1_SIG_N  | JPEG2000_T1_SIG_E  |   \
  85.                             JPEG2000_T1_SIG_S  | JPEG2000_T1_SIG_W  |   \
  86.                             JPEG2000_T1_SIG_NE | JPEG2000_T1_SIG_NW |   \
  87.                             JPEG2000_T1_SIG_SE | JPEG2000_T1_SIG_SW)
  88. // flags determining sign bit of neighbor coefficients
  89. #define JPEG2000_T1_SGN_N  0x0100
  90. #define JPEG2000_T1_SGN_S  0x0200
  91. #define JPEG2000_T1_SGN_W  0x0400
  92. #define JPEG2000_T1_SGN_E  0x0800
  93.  
  94. #define JPEG2000_T1_VIS    0x1000
  95. #define JPEG2000_T1_SIG    0x2000
  96. #define JPEG2000_T1_REF    0x4000
  97.  
  98. #define JPEG2000_T1_SGN    0x8000
  99.  
  100. // Codeblock coding styles
  101. #define JPEG2000_CBLK_BYPASS    0x01 // Selective arithmetic coding bypass
  102. #define JPEG2000_CBLK_RESET     0x02 // Reset context probabilities
  103. #define JPEG2000_CBLK_TERMALL   0x04 // Terminate after each coding pass
  104. #define JPEG2000_CBLK_VSC       0x08 // Vertical stripe causal context formation
  105. #define JPEG2000_CBLK_PREDTERM  0x10 // Predictable termination
  106. #define JPEG2000_CBLK_SEGSYM    0x20 // Segmentation symbols present
  107.  
  108. // Coding styles
  109. #define JPEG2000_CSTY_PREC      0x01 // Precincts defined in coding style
  110. #define JPEG2000_CSTY_SOP       0x02 // SOP marker present
  111. #define JPEG2000_CSTY_EPH       0x04 // EPH marker present
  112.  
  113. // Progression orders
  114. #define JPEG2000_PGOD_LRCP      0x00  // Layer-resolution level-component-position progression
  115. #define JPEG2000_PGOD_RLCP      0x01  // Resolution level-layer-component-position progression
  116. #define JPEG2000_PGOD_RPCL      0x02  // Resolution level-position-component-layer progression
  117. #define JPEG2000_PGOD_PCRL      0x03  // Position-component-resolution level-layer progression
  118. #define JPEG2000_PGOD_CPRL      0x04  // Component-position-resolution level-layer progression
  119.  
  120. typedef struct Jpeg2000T1Context {
  121.     int data[JPEG2000_MAX_CBLKW][JPEG2000_MAX_CBLKH];
  122.     int flags[JPEG2000_MAX_CBLKW + 2][JPEG2000_MAX_CBLKH + 2];
  123.     MqcState mqc;
  124. } Jpeg2000T1Context;
  125.  
  126. typedef struct Jpeg2000TgtNode {
  127.     uint8_t val;
  128.     uint8_t vis;
  129.     struct Jpeg2000TgtNode *parent;
  130. } Jpeg2000TgtNode;
  131.  
  132. typedef struct Jpeg2000CodingStyle {
  133.     int nreslevels;           // number of resolution levels
  134.     int nreslevels2decode;    // number of resolution levels to decode
  135.     uint8_t log2_cblk_width,
  136.             log2_cblk_height; // exponent of codeblock size
  137.     uint8_t transform;        // DWT type
  138.     uint8_t csty;             // coding style
  139.     uint8_t nlayers;          // number of layers
  140.     uint8_t mct;              // multiple component transformation
  141.     uint8_t cblk_style;       // codeblock coding style
  142.     uint8_t prog_order;       // progression order
  143.     uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS];  // precincts size according resolution levels
  144.     uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]; // TODO: initialize prec_size array with 0?
  145. } Jpeg2000CodingStyle;
  146.  
  147. typedef struct Jpeg2000QuantStyle {
  148.     uint8_t expn[JPEG2000_MAX_DECLEVELS * 3];  // quantization exponent
  149.     uint16_t mant[JPEG2000_MAX_DECLEVELS * 3]; // quantization mantissa
  150.     uint8_t quantsty;      // quantization style
  151.     uint8_t nguardbits;    // number of guard bits
  152. } Jpeg2000QuantStyle;
  153.  
  154. typedef struct Jpeg2000Pass {
  155.     uint16_t rate;
  156.     int64_t disto;
  157. } Jpeg2000Pass;
  158.  
  159. typedef struct Jpeg2000Cblk {
  160.     uint8_t npasses;
  161.     uint8_t ninclpasses; // number coding of passes included in codestream
  162.     uint8_t nonzerobits;
  163.     uint16_t length;
  164.     uint16_t lengthinc;
  165.     uint8_t lblock;
  166.     uint8_t zero;
  167.     uint8_t data[8192];
  168.     Jpeg2000Pass passes[100];
  169.     uint16_t coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
  170. } Jpeg2000Cblk; // code block
  171.  
  172. typedef struct Jpeg2000Prec {
  173.     uint16_t nb_codeblocks_width;
  174.     uint16_t nb_codeblocks_height;
  175.     Jpeg2000TgtNode *zerobits;
  176.     Jpeg2000TgtNode *cblkincl;
  177.     Jpeg2000Cblk *cblk;
  178.     uint16_t coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
  179. } Jpeg2000Prec; // precinct
  180.  
  181. typedef struct Jpeg2000Band {
  182.     uint16_t coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
  183.     uint16_t log2_cblk_width, log2_cblk_height;
  184.     int i_stepsize; // quantization stepsize
  185.     float f_stepsize; // quantization stepsize
  186.     Jpeg2000Prec *prec;
  187. } Jpeg2000Band; // subband
  188.  
  189. typedef struct Jpeg2000ResLevel {
  190.     uint8_t nbands;
  191.     uint16_t coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
  192.     uint16_t num_precincts_x, num_precincts_y; // number of precincts in x/y direction
  193.     uint8_t log2_prec_width, log2_prec_height; // exponent of precinct size
  194.     Jpeg2000Band *band;
  195. } Jpeg2000ResLevel; // resolution level
  196.  
  197. typedef struct Jpeg2000Component {
  198.     Jpeg2000ResLevel *reslevel;
  199.     DWTContext dwt;
  200.     float *f_data;
  201.     int *i_data;
  202.     uint16_t coord[2][2];   // border coordinates {{x0, x1}, {y0, y1}} -- can be reduced with lowres option
  203.     uint16_t coord_o[2][2]; // border coordinates {{x0, x1}, {y0, y1}} -- original values from jpeg2000 headers
  204. } Jpeg2000Component;
  205.  
  206. /* misc tools */
  207. static inline int ff_jpeg2000_ceildivpow2(int a, int b)
  208. {
  209.     return (a + (1 << b) - 1) >> b;
  210. }
  211.  
  212. static inline int ff_jpeg2000_ceildiv(int a, int b)
  213. {
  214.     return (a + b - 1) / b;
  215. }
  216.  
  217. /* TIER-1 routines */
  218.  
  219. /* Set up lookup tables used in TIER-1. */
  220. void ff_jpeg2000_init_tier1_luts(void);
  221.  
  222. /* Update significance of a coefficient at current position (x,y) and
  223.  * for neighbors. */
  224. void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1,
  225.                                   int x, int y, int negative);
  226.  
  227. extern uint8_t ff_jpeg2000_sigctxno_lut[256][4];
  228.  
  229. /* Get context label (number in range[0..8]) of a coefficient for significance
  230.  * propagation and cleanup coding passes. */
  231. static inline int ff_jpeg2000_getsigctxno(int flag, int bandno)
  232. {
  233.     return ff_jpeg2000_sigctxno_lut[flag & 255][bandno];
  234. }
  235.  
  236. static const uint8_t refctxno_lut[2][2] = { { 14, 15 }, { 16, 16 } };
  237.  
  238. /* Get context label (number in range[14..16]) of a coefficient for magnitude
  239.  * refinement pass. */
  240. static inline int ff_jpeg2000_getrefctxno(int flag)
  241. {
  242.     return refctxno_lut[(flag >> 14) & 1][(flag & 255) != 0];
  243. }
  244.  
  245. extern uint8_t ff_jpeg2000_sgnctxno_lut[16][16];
  246. extern uint8_t ff_jpeg2000_xorbit_lut[16][16];
  247.  
  248. /* Get context label (number in range[9..13]) for sign decoding. */
  249. static inline int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)
  250. {
  251.     *xorbit = ff_jpeg2000_xorbit_lut[flag & 15][(flag >> 8) & 15];
  252.     return ff_jpeg2000_sgnctxno_lut[flag & 15][(flag >> 8) & 15];
  253. }
  254.  
  255. int ff_jpeg2000_init_component(Jpeg2000Component *comp,
  256.                                Jpeg2000CodingStyle *codsty,
  257.                                Jpeg2000QuantStyle *qntsty,
  258.                                int cbps, int dx, int dy,
  259.                                AVCodecContext *ctx);
  260.  
  261. void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty);
  262.  
  263. void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty);
  264.  
  265. #endif /* AVCODEC_JPEG2000_H */
  266.