LCOV - code coverage report
Current view: top level - libavcodec - jpeg2000.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 15 24 62.5 %
Date: 2017-12-14 08:27:08 Functions: 6 6 100.0 %

          Line data    Source code
       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             : #define JPEG2000_SOP_FIXED_BYTES 0xFF910004
      62             : #define JPEG2000_SOP_BYTE_LENGTH 6
      63             : 
      64             : enum Jpeg2000Quantsty { // quantization style
      65             :     JPEG2000_QSTY_NONE, // no quantization
      66             :     JPEG2000_QSTY_SI,   // scalar derived
      67             :     JPEG2000_QSTY_SE    // scalar expounded
      68             : };
      69             : 
      70             : #define JPEG2000_MAX_DECLEVELS 33
      71             : #define JPEG2000_MAX_RESLEVELS (JPEG2000_MAX_DECLEVELS + 1)
      72             : 
      73             : #define JPEG2000_MAX_PASSES 100
      74             : 
      75             : // T1 flags
      76             : // flags determining significance of neighbor coefficients
      77             : #define JPEG2000_T1_SIG_N  0x0001
      78             : #define JPEG2000_T1_SIG_E  0x0002
      79             : #define JPEG2000_T1_SIG_W  0x0004
      80             : #define JPEG2000_T1_SIG_S  0x0008
      81             : #define JPEG2000_T1_SIG_NE 0x0010
      82             : #define JPEG2000_T1_SIG_NW 0x0020
      83             : #define JPEG2000_T1_SIG_SE 0x0040
      84             : #define JPEG2000_T1_SIG_SW 0x0080
      85             : #define JPEG2000_T1_SIG_NB (JPEG2000_T1_SIG_N  | JPEG2000_T1_SIG_E  |   \
      86             :                             JPEG2000_T1_SIG_S  | JPEG2000_T1_SIG_W  |   \
      87             :                             JPEG2000_T1_SIG_NE | JPEG2000_T1_SIG_NW |   \
      88             :                             JPEG2000_T1_SIG_SE | JPEG2000_T1_SIG_SW)
      89             : // flags determining sign bit of neighbor coefficients
      90             : #define JPEG2000_T1_SGN_N  0x0100
      91             : #define JPEG2000_T1_SGN_S  0x0200
      92             : #define JPEG2000_T1_SGN_W  0x0400
      93             : #define JPEG2000_T1_SGN_E  0x0800
      94             : 
      95             : #define JPEG2000_T1_VIS    0x1000
      96             : #define JPEG2000_T1_SIG    0x2000
      97             : #define JPEG2000_T1_REF    0x4000
      98             : 
      99             : #define JPEG2000_T1_SGN    0x8000
     100             : 
     101             : // Codeblock coding styles
     102             : #define JPEG2000_CBLK_BYPASS    0x01 // Selective arithmetic coding bypass
     103             : #define JPEG2000_CBLK_RESET     0x02 // Reset context probabilities
     104             : #define JPEG2000_CBLK_TERMALL   0x04 // Terminate after each coding pass
     105             : #define JPEG2000_CBLK_VSC       0x08 // Vertical stripe causal context formation
     106             : #define JPEG2000_CBLK_PREDTERM  0x10 // Predictable termination
     107             : #define JPEG2000_CBLK_SEGSYM    0x20 // Segmentation symbols present
     108             : 
     109             : // Coding styles
     110             : #define JPEG2000_CSTY_PREC      0x01 // Precincts defined in coding style
     111             : #define JPEG2000_CSTY_SOP       0x02 // SOP marker present
     112             : #define JPEG2000_CSTY_EPH       0x04 // EPH marker present
     113             : 
     114             : // Progression orders
     115             : #define JPEG2000_PGOD_LRCP      0x00  // Layer-resolution level-component-position progression
     116             : #define JPEG2000_PGOD_RLCP      0x01  // Resolution level-layer-component-position progression
     117             : #define JPEG2000_PGOD_RPCL      0x02  // Resolution level-position-component-layer progression
     118             : #define JPEG2000_PGOD_PCRL      0x03  // Position-component-resolution level-layer progression
     119             : #define JPEG2000_PGOD_CPRL      0x04  // Component-position-resolution level-layer progression
     120             : 
     121             : typedef struct Jpeg2000T1Context {
     122             :     int data[6144];
     123             :     uint16_t flags[6156];
     124             :     MqcState mqc;
     125             :     int stride;
     126             : } Jpeg2000T1Context;
     127             : 
     128             : typedef struct Jpeg2000TgtNode {
     129             :     uint8_t val;
     130             :     uint8_t vis;
     131             :     struct Jpeg2000TgtNode *parent;
     132             : } Jpeg2000TgtNode;
     133             : 
     134             : typedef struct Jpeg2000CodingStyle {
     135             :     int nreslevels;           // number of resolution levels
     136             :     int nreslevels2decode;    // number of resolution levels to decode
     137             :     uint8_t log2_cblk_width,
     138             :             log2_cblk_height; // exponent of codeblock size
     139             :     uint8_t transform;        // DWT type
     140             :     uint8_t csty;             // coding style
     141             :     uint8_t nlayers;          // number of layers
     142             :     uint8_t mct;              // multiple component transformation
     143             :     uint8_t cblk_style;       // codeblock coding style
     144             :     uint8_t prog_order;       // progression order
     145             :     uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS];  // precincts size according resolution levels
     146             :     uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]; // TODO: initialize prec_size array with 0?
     147             : } Jpeg2000CodingStyle;
     148             : 
     149             : typedef struct Jpeg2000QuantStyle {
     150             :     uint8_t expn[JPEG2000_MAX_DECLEVELS * 3];  // quantization exponent
     151             :     uint16_t mant[JPEG2000_MAX_DECLEVELS * 3]; // quantization mantissa
     152             :     uint8_t quantsty;      // quantization style
     153             :     uint8_t nguardbits;    // number of guard bits
     154             : } Jpeg2000QuantStyle;
     155             : 
     156             : typedef struct Jpeg2000Pass {
     157             :     uint16_t rate;
     158             :     int64_t disto;
     159             :     uint8_t flushed[4];
     160             :     int flushed_len;
     161             : } Jpeg2000Pass;
     162             : 
     163             : typedef struct Jpeg2000Cblk {
     164             :     uint8_t npasses;
     165             :     uint8_t ninclpasses; // number coding of passes included in codestream
     166             :     uint8_t nonzerobits;
     167             :     uint16_t length;
     168             :     uint16_t lengthinc[JPEG2000_MAX_PASSES];
     169             :     uint8_t nb_lengthinc;
     170             :     uint8_t lblock;
     171             :     uint8_t *data;
     172             :     size_t data_allocated;
     173             :     int nb_terminations;
     174             :     int nb_terminationsinc;
     175             :     int data_start[JPEG2000_MAX_PASSES];
     176             :     Jpeg2000Pass *passes;
     177             :     int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
     178             : } Jpeg2000Cblk; // code block
     179             : 
     180             : typedef struct Jpeg2000Prec {
     181             :     int nb_codeblocks_width;
     182             :     int nb_codeblocks_height;
     183             :     Jpeg2000TgtNode *zerobits;
     184             :     Jpeg2000TgtNode *cblkincl;
     185             :     Jpeg2000Cblk *cblk;
     186             :     int decoded_layers;
     187             :     int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
     188             : } Jpeg2000Prec; // precinct
     189             : 
     190             : typedef struct Jpeg2000Band {
     191             :     int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
     192             :     uint16_t log2_cblk_width, log2_cblk_height;
     193             :     int i_stepsize; // quantization stepsize
     194             :     float f_stepsize; // quantization stepsize
     195             :     Jpeg2000Prec *prec;
     196             : } Jpeg2000Band; // subband
     197             : 
     198             : typedef struct Jpeg2000ResLevel {
     199             :     uint8_t nbands;
     200             :     int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
     201             :     int num_precincts_x, num_precincts_y; // number of precincts in x/y direction
     202             :     uint8_t log2_prec_width, log2_prec_height; // exponent of precinct size
     203             :     Jpeg2000Band *band;
     204             : } Jpeg2000ResLevel; // resolution level
     205             : 
     206             : typedef struct Jpeg2000Component {
     207             :     Jpeg2000ResLevel *reslevel;
     208             :     DWTContext dwt;
     209             :     float *f_data;
     210             :     int *i_data;
     211             :     int coord[2][2];   // border coordinates {{x0, x1}, {y0, y1}} -- can be reduced with lowres option
     212             :     int coord_o[2][2]; // border coordinates {{x0, x1}, {y0, y1}} -- original values from jpeg2000 headers
     213             : } Jpeg2000Component;
     214             : 
     215             : /* misc tools */
     216      980870 : static inline int ff_jpeg2000_ceildivpow2(int a, int b)
     217             : {
     218      980870 :     return -((-(int64_t)a) >> b);
     219             : }
     220             : 
     221         840 : static inline int ff_jpeg2000_ceildiv(int a, int b)
     222             : {
     223         840 :     return (a + (int64_t)b - 1) / b;
     224             : }
     225             : 
     226             : /* TIER-1 routines */
     227             : 
     228             : /* Set up lookup tables used in TIER-1. */
     229             : void ff_jpeg2000_init_tier1_luts(void);
     230             : 
     231             : /* Update significance of a coefficient at current position (x,y) and
     232             :  * for neighbors. */
     233             : void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1,
     234             :                                   int x, int y, int negative);
     235             : 
     236             : extern uint8_t ff_jpeg2000_sigctxno_lut[256][4];
     237             : 
     238             : /* Get context label (number in range[0..8]) of a coefficient for significance
     239             :  * propagation and cleanup coding passes. */
     240   361045072 : static inline int ff_jpeg2000_getsigctxno(int flag, int bandno)
     241             : {
     242   361045072 :     return ff_jpeg2000_sigctxno_lut[flag & 255][bandno];
     243             : }
     244             : 
     245             : static const uint8_t refctxno_lut[2][2] = { { 14, 15 }, { 16, 16 } };
     246             : 
     247             : /* Get context label (number in range[14..16]) of a coefficient for magnitude
     248             :  * refinement pass. */
     249   173208301 : static inline int ff_jpeg2000_getrefctxno(int flag)
     250             : {
     251   173208301 :     return refctxno_lut[(flag >> 14) & 1][(flag & 255) != 0];
     252             : }
     253             : 
     254             : extern uint8_t ff_jpeg2000_sgnctxno_lut[16][16];
     255             : extern uint8_t ff_jpeg2000_xorbit_lut[16][16];
     256             : 
     257             : /* Get context label (number in range[9..13]) for sign decoding. */
     258    97248712 : static inline int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)
     259             : {
     260    97248712 :     *xorbit = ff_jpeg2000_xorbit_lut[flag & 15][(flag >> 8) & 15];
     261    97248712 :     return ff_jpeg2000_sgnctxno_lut[flag & 15][(flag >> 8) & 15];
     262             : }
     263             : 
     264             : int ff_jpeg2000_init_component(Jpeg2000Component *comp,
     265             :                                Jpeg2000CodingStyle *codsty,
     266             :                                Jpeg2000QuantStyle *qntsty,
     267             :                                int cbps, int dx, int dy,
     268             :                                AVCodecContext *ctx);
     269             : 
     270             : void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty);
     271             : 
     272             : void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty);
     273             : 
     274     5087302 : static inline int needs_termination(int style, int passno) {
     275     5087302 :     if (style & JPEG2000_CBLK_BYPASS) {
     276           0 :         int type = passno % 3;
     277           0 :         passno /= 3;
     278           0 :         if (type == 0 && passno > 2)
     279           0 :             return 2;
     280           0 :         if (type == 2 && passno > 2)
     281           0 :             return 1;
     282           0 :         if (style & JPEG2000_CBLK_TERMALL) {
     283           0 :             return passno > 2 ? 2 : 1;
     284             :         }
     285             :     }
     286     5087302 :     if (style & JPEG2000_CBLK_TERMALL)
     287           0 :         return 1;
     288     5087302 :     return 0;
     289             : }
     290             : 
     291             : #endif /* AVCODEC_JPEG2000_H */

Generated by: LCOV version 1.13