falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
53488 Commits
32 Branches
1012MB
Tree: 53ec1c811e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '53ec1c811e'
${ noResults }
FFmpeg/libavcodec/j2k.c

415 lines
16KB
Raw Blame History 

  1. /*

  2.  * JPEG 2000 encoder and decoder common 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. /**

  24.  * JPEG 2000 image encoder and decoder common functions

  25.  * @file

  26.  * @author Kamil Nowosad

  27.  */

  28. 

  29. #include "libavutil/common.h"

  30. #include "libavutil/mem.h"

  31. #include "avcodec.h"

  32. #include "j2k.h"

  33. 

  34. #define SHL(a, n) ((n) >= 0 ? (a) << (n) : (a) >> -(n))

  35. 

  36. /* tag tree routines */

  37. 

  38. /* allocate the memory for tag tree */

  39. static int tag_tree_size(int w, int h)

  40. {

  41.     int res = 0;

  42.     while (w > 1 || h > 1) {

  43.         res += w * h;

  44.         w = (w + 1) >> 1;

  45.         h = (h + 1) >> 1;

  46.     }

  47.     return res + 1;

  48. }

  49. 

  50. Jpeg2000TgtNode *ff_j2k_tag_tree_init(int w, int h)

  51. {

  52.     int pw = w, ph = h;

  53.     Jpeg2000TgtNode *res, *t, *t2;

  54.     int32_t tt_size;

  55. 

  56.     tt_size = tag_tree_size(w, h);

  57. 

  58.     t = res = av_mallocz_array(tt_size, sizeof(*t));

  59.     if (!res)

  60.         return NULL;

  61. 

  62.     while (w > 1 || h > 1) {

  63.         int i, j;

  64.         pw = w;

  65.         ph = h;

  66. 

  67.         w  = (w + 1) >> 1;

  68.         h  = (h + 1) >> 1;

  69.         t2 = t + pw * ph;

  70. 

  71.         for (i = 0; i < ph; i++)

  72.             for (j = 0; j < pw; j++)

  73.                 t[i * pw + j].parent = &t2[(i >> 1) * w + (j >> 1)];

  74. 

  75.         t = t2;

  76.     }

  77.     t[0].parent = NULL;

  78.     return res;

  79. }

  80. 

  81. static void tag_tree_zero(Jpeg2000TgtNode *t, int w, int h)

  82. {

  83.     int i, siz = tag_tree_size(w, h);

  84. 

  85.     for (i = 0; i < siz; i++) {

  86.         t[i].val = 0;

  87.         t[i].vis = 0;

  88.     }

  89. }

  90. 

  91. static int getsigctxno(int flag, int bandno)

  92. {

  93.     int h, v, d;

  94. 

  95.     h = ((flag & JPEG2000_T1_SIG_E)  ? 1 : 0) +

  96.         ((flag & JPEG2000_T1_SIG_W)  ? 1 : 0);

  97.     v = ((flag & JPEG2000_T1_SIG_N)  ? 1 : 0) +

  98.         ((flag & JPEG2000_T1_SIG_S)  ? 1 : 0);

  99.     d = ((flag & JPEG2000_T1_SIG_NE) ? 1 : 0) +

  100.         ((flag & JPEG2000_T1_SIG_NW) ? 1 : 0) +

  101.         ((flag & JPEG2000_T1_SIG_SE) ? 1 : 0) +

  102.         ((flag & JPEG2000_T1_SIG_SW) ? 1 : 0);

  103. 

  104.     if (bandno < 3) {

  105.         if (bandno == 1)

  106.             FFSWAP(int, h, v);

  107.         if (h == 2) return 8;

  108.         if (h == 1) {

  109.             if (v >= 1) return 7;

  110.             if (d >= 1) return 6;

  111.             return 5;

  112.         }

  113.         if (v == 2) return 4;

  114.         if (v == 1) return 3;

  115.         if (d >= 2) return 2;

  116.         if (d == 1) return 1;

  117.     } else {

  118.         if (d >= 3) return 8;

  119.         if (d == 2) {

  120.             if (h+v >= 1) return 7;

  121.             return 6;

  122.         }

  123.         if (d == 1) {

  124.             if (h+v >= 2) return 5;

  125.             if (h+v == 1) return 4;

  126.             return 3;

  127.         }

  128.         if (h+v >= 2) return 2;

  129.         if (h+v == 1) return 1;

  130.     }

  131.     return 0;

  132. }

  133. 

  134. 

  135. static const int contribtab[3][3] = { {  0, -1,  1 }, { -1, -1,  0 }, {  1,  0,  1 } };

  136. static const int  ctxlbltab[3][3] = { { 13, 12, 11 }, { 10,  9, 10 }, { 11, 12, 13 } };

  137. static const int  xorbittab[3][3] = { {  1,  1,  1 }, {  1,  0,  0 }, {  0,  0,  0 } };

  138. 

  139. static int getsgnctxno(int flag, uint8_t *xorbit)

  140. {

  141.     int vcontrib, hcontrib;

  142. 

  143.     hcontrib = contribtab[flag & JPEG2000_T1_SIG_E ? flag & JPEG2000_T1_SGN_E ? 1 : 2 : 0]

  144.                          [flag & JPEG2000_T1_SIG_W ? flag & JPEG2000_T1_SGN_W ? 1 : 2 : 0] + 1;

  145.     vcontrib = contribtab[flag & JPEG2000_T1_SIG_S ? flag & JPEG2000_T1_SGN_S ? 1 : 2 : 0]

  146.                          [flag & JPEG2000_T1_SIG_N ? flag & JPEG2000_T1_SGN_N ? 1 : 2 : 0] + 1;

  147.     *xorbit = xorbittab[hcontrib][vcontrib];

  148. 

  149.     return ctxlbltab[hcontrib][vcontrib];

  150. }

  151. 

  152. void ff_j2k_set_significant(Jpeg2000T1Context *t1, int x, int y,

  153.                             int negative)

  154. {

  155.     x++;

  156.     y++;

  157.     t1->flags[y][x] |= JPEG2000_T1_SIG;

  158.     if (negative) {

  159.         t1->flags[y][x + 1] |= JPEG2000_T1_SIG_W | JPEG2000_T1_SGN_W;

  160.         t1->flags[y][x - 1] |= JPEG2000_T1_SIG_E | JPEG2000_T1_SGN_E;

  161.         t1->flags[y + 1][x] |= JPEG2000_T1_SIG_N | JPEG2000_T1_SGN_N;

  162.         t1->flags[y - 1][x] |= JPEG2000_T1_SIG_S | JPEG2000_T1_SGN_S;

  163.     } else {

  164.         t1->flags[y][x + 1] |= JPEG2000_T1_SIG_W;

  165.         t1->flags[y][x - 1] |= JPEG2000_T1_SIG_E;

  166.         t1->flags[y + 1][x] |= JPEG2000_T1_SIG_N;

  167.         t1->flags[y - 1][x] |= JPEG2000_T1_SIG_S;

  168.     }

  169.     t1->flags[y + 1][x + 1] |= JPEG2000_T1_SIG_NW;

  170.     t1->flags[y + 1][x - 1] |= JPEG2000_T1_SIG_NE;

  171.     t1->flags[y - 1][x + 1] |= JPEG2000_T1_SIG_SW;

  172.     t1->flags[y - 1][x - 1] |= JPEG2000_T1_SIG_SE;

  173. }

  174. 

  175. int ff_j2k_init_component(Jpeg2000Component *comp,

  176.                           Jpeg2000CodingStyle *codsty,

  177.                           Jpeg2000QuantStyle *qntsty,

  178.                           int cbps, int dx, int dy)

  179. {

  180.     uint8_t log2_band_prec_width, log2_band_prec_height;

  181.     int reslevelno, bandno, gbandno = 0, ret, i, j, csize = 1;

  182. 

  183.     if (ret=ff_j2k_dwt_init(&comp->dwt, comp->coord, codsty->nreslevels-1, codsty->transform))

  184.         return ret;

  185.     for (i = 0; i < 2; i++)

  186.         csize *= comp->coord[i][1] - comp->coord[i][0];

  187. 

  188.     comp->data = av_malloc_array(csize, sizeof(*comp->data));

  189.     if (!comp->data)

  190.         return AVERROR(ENOMEM);

  191.     comp->reslevel = av_malloc_array(codsty->nreslevels, sizeof(*comp->reslevel));

  192.     if (!comp->reslevel)

  193.         return AVERROR(ENOMEM);

  194.     /* LOOP on resolution levels */

  195.     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {

  196.         int declvl = codsty->nreslevels - reslevelno;    // N_L -r see  ISO/IEC 15444-1:2002 B.5

  197.         Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;

  198. 

  199.         /* Compute borders for each resolution level.

  200.          * Computation of trx_0, trx_1, try_0 and try_1.

  201.          * see ISO/IEC 15444-1:2002 eq. B.5 and B-14 */

  202.         for (i = 0; i < 2; i++)

  203.             for (j = 0; j < 2; j++)

  204.                 reslevel->coord[i][j] =

  205.                     ff_jpeg2000_ceildivpow2(comp->coord[i][j], declvl - 1);

  206.         // update precincts size: 2^n value

  207.         reslevel->log2_prec_width  = codsty->log2_prec_widths[reslevelno];

  208.         reslevel->log2_prec_height = codsty->log2_prec_heights[reslevelno];

  209. 

  210.         /* Number of bands for each resolution level */

  211.         if (reslevelno == 0)

  212.             reslevel->nbands = 1;

  213.         else

  214.             reslevel->nbands = 3;

  215. 

  216.         /* Number of precincts wich span the tile for resolution level reslevelno

  217.          * see B.6 in ISO/IEC 15444-1:2002 eq. B-16

  218.          * num_precincts_x = |- trx_1 / 2 ^ log2_prec_width) -| - (trx_0 / 2 ^ log2_prec_width)

  219.          * num_precincts_y = |- try_1 / 2 ^ log2_prec_width) -| - (try_0 / 2 ^ log2_prec_width)

  220.          * for Dcinema profiles in JPEG 2000

  221.          * num_precincts_x = |- trx_1 / 2 ^ log2_prec_width) -|

  222.          * num_precincts_y = |- try_1 / 2 ^ log2_prec_width) -| */

  223.         if (reslevel->coord[0][1] == reslevel->coord[0][0])

  224.             reslevel->num_precincts_x = 0;

  225.         else

  226.             reslevel->num_precincts_x =

  227.                 ff_jpeg2000_ceildivpow2(reslevel->coord[0][1],

  228.                                         reslevel->log2_prec_width) -

  229.                 (reslevel->coord[0][0] >> reslevel->log2_prec_width);

  230. 

  231.         if (reslevel->coord[1][1] == reslevel->coord[1][0])

  232.             reslevel->num_precincts_y = 0;

  233.         else

  234.             reslevel->num_precincts_y =

  235.                 ff_jpeg2000_ceildivpow2(reslevel->coord[1][1],

  236.                                         reslevel->log2_prec_height) -

  237.                 (reslevel->coord[1][0] >> reslevel->log2_prec_height);

  238. 

  239.         reslevel->band = av_malloc_array(reslevel->nbands, sizeof(*reslevel->band));

  240.         if (!reslevel->band)

  241.             return AVERROR(ENOMEM);

  242. 

  243.         for (bandno = 0; bandno < reslevel->nbands; bandno++, gbandno++) {

  244.             Jpeg2000Band *band = reslevel->band + bandno;

  245.             int cblkno, precx, precy, precno;

  246.             int x0, y0, x1, y1;

  247.             int xi0, yi0, xi1, yi1;

  248.             int cblkperprecw, cblkperprech;

  249. 

  250.             if (qntsty->quantsty != JPEG2000_QSTY_NONE) {

  251.                 static const uint8_t lut_gain[2][4] = {{0, 0, 0, 0}, {0, 1, 1, 2}};

  252.                 int numbps;

  253. 

  254.                 numbps = cbps + lut_gain[codsty->transform][bandno + reslevelno>0];

  255.                 band->stepsize = SHL(2048 + qntsty->mant[gbandno], 2 + numbps - qntsty->expn[gbandno]);

  256.             } else

  257.                 band->stepsize = 1 << 13;

  258. 

  259.             if (reslevelno == 0) {

  260.                 /* for reslevelno = 0, only one band, x0_b = y0_b = 0 */

  261.                 for (i = 0; i < 2; i++)

  262.                     for (j = 0; j < 2; j++)

  263.                         band->coord[i][j] =

  264.                             ff_jpeg2000_ceildivpow2(comp->coord[i][j],

  265.                                                     declvl - 1);

  266. 

  267.                 log2_band_prec_width  = reslevel->log2_prec_width;

  268.                 log2_band_prec_height = reslevel->log2_prec_height;

  269.                 /* see ISO/IEC 15444-1:2002 eq. B-17 and eq. B-15 */

  270.                 band->log2_cblk_width  = FFMIN(codsty->log2_cblk_width,

  271.                                                reslevel->log2_prec_width);

  272.                 band->log2_cblk_height = FFMIN(codsty->log2_cblk_height,

  273.                                                reslevel->log2_prec_height);

  274.             } else {

  275.                 /* 3 bands x0_b = 1 y0_b = 0; x0_b = 0 y0_b = 1; x0_b = y0_b = 1 */

  276.                 /* x0_b and y0_b are computed with ((bandno + 1 >> i) & 1) */

  277.                 for (i = 0; i < 2; i++)

  278.                     for (j = 0; j < 2; j++)

  279.                         /* Formula example for tbx_0 = ceildiv((tcx_0 - 2 ^ (declvl - 1) * x0_b) / declvl) */

  280.                         band->coord[i][j] =

  281.                             ff_jpeg2000_ceildivpow2(comp->coord[i][j] -

  282.                                                     (((bandno + 1 >> i) & 1) << declvl - 1),

  283.                                                     declvl);

  284.                 /* TODO: Manage case of 3 band offsets here or

  285.                  * in coding/decoding function? */

  286. 

  287.                 /* see ISO/IEC 15444-1:2002 eq. B-17 and eq. B-15 */

  288.                 band->log2_cblk_width  = FFMIN(codsty->log2_cblk_width,

  289.                                                reslevel->log2_prec_width - 1);

  290.                 band->log2_cblk_height = FFMIN(codsty->log2_cblk_height,

  291.                                                reslevel->log2_prec_height - 1);

  292. 

  293.                 log2_band_prec_width  = reslevel->log2_prec_width  - 1;

  294.                 log2_band_prec_height = reslevel->log2_prec_height - 1;

  295.             }

  296.             band->cblknx = ff_jpeg2000_ceildivpow2(band->coord[0][1], band->log2_cblk_width)  - (band->coord[0][0] >> band->log2_cblk_width);

  297.             band->cblkny = ff_jpeg2000_ceildivpow2(band->coord[1][1], band->log2_cblk_height) - (band->coord[1][0] >> band->log2_cblk_height);

  298. 

  299.             for (j = 0; j < 2; j++)

  300.                 band->coord[0][j] = ff_jpeg2000_ceildiv(band->coord[0][j], dx);

  301.             for (j = 0; j < 2; j++)

  302.                 band->coord[1][j] = ff_jpeg2000_ceildiv(band->coord[1][j], dy);

  303. 

  304.             band->cblknx = ff_jpeg2000_ceildiv(band->cblknx, dx);

  305.             band->cblkny = ff_jpeg2000_ceildiv(band->cblkny, dy);

  306. 

  307.             band->cblk = av_malloc_array(band->cblknx *

  308.                                          band->cblkny,

  309.                                          sizeof(*band->cblk));

  310.             if (!band->cblk)

  311.                 return AVERROR(ENOMEM);

  312.             band->prec = av_malloc_array(reslevel->num_precincts_x *

  313.                                          reslevel->num_precincts_y,

  314.                                          sizeof(*band->prec));

  315.             if (!band->prec)

  316.                 return AVERROR(ENOMEM);

  317. 

  318.             for (cblkno = 0; cblkno < band->cblknx * band->cblkny; cblkno++) {

  319.                 Jpeg2000Cblk *cblk = band->cblk + cblkno;

  320.                 cblk->zero = 0;

  321.                 cblk->lblock = 3;

  322.                 cblk->length = 0;

  323.                 cblk->lengthinc = 0;

  324.                 cblk->npasses = 0;

  325.             }

  326. 

  327.             y0 = band->coord[1][0];

  328.             y1 = ((band->coord[1][0] + (1<<reslevel->log2_prec_height)) & ~((1<<reslevel->log2_prec_height)-1)) - y0;

  329.             yi0 = 0;

  330.             yi1 = ff_jpeg2000_ceildivpow2(y1 - y0, codsty->log2_cblk_height) << codsty->log2_cblk_height;

  331.             yi1 = FFMIN(yi1, band->cblkny);

  332.             cblkperprech = 1<<(reslevel->log2_prec_height - codsty->log2_cblk_height);

  333.             for (precy = 0, precno = 0; precy < reslevel->num_precincts_y; precy++) {

  334.                 for (precx = 0; precx < reslevel->num_precincts_x; precx++, precno++) {

  335.                     band->prec[precno].yi0 = yi0;

  336.                     band->prec[precno].yi1 = yi1;

  337.                 }

  338.                 yi1 += cblkperprech;

  339.                 yi0 = yi1 - cblkperprech;

  340.                 yi1 = FFMIN(yi1, band->cblkny);

  341.             }

  342.             x0 = band->coord[0][0];

  343.             x1 = ((band->coord[0][0] + (1<<reslevel->log2_prec_width)) & ~((1<<reslevel->log2_prec_width)-1)) - x0;

  344.             xi0 = 0;

  345.             xi1 = ff_jpeg2000_ceildivpow2(x1 - x0, codsty->log2_cblk_width) << codsty->log2_cblk_width;

  346.             xi1 = FFMIN(xi1, band->cblknx);

  347. 

  348.             cblkperprecw = 1<<(reslevel->log2_prec_width - codsty->log2_cblk_width);

  349.             for (precx = 0, precno = 0; precx < reslevel->num_precincts_x; precx++) {

  350.                 for (precy = 0; precy < reslevel->num_precincts_y; precy++, precno = 0) {

  351.                     Jpeg2000Prec *prec = band->prec + precno;

  352.                     prec->xi0 = xi0;

  353.                     prec->xi1 = xi1;

  354.                     prec->cblkincl = ff_j2k_tag_tree_init(prec->xi1 - prec->xi0,

  355.                                                           prec->yi1 - prec->yi0);

  356.                     prec->zerobits = ff_j2k_tag_tree_init(prec->xi1 - prec->xi0,

  357.                                                           prec->yi1 - prec->yi0);

  358.                     if (!prec->cblkincl || !prec->zerobits)

  359.                         return AVERROR(ENOMEM);

  360. 

  361.                 }

  362.                 xi1 += cblkperprecw;

  363.                 xi0 = xi1 - cblkperprecw;

  364.                 xi1 = FFMIN(xi1, band->cblknx);

  365.             }

  366.         }

  367.     }

  368.     return 0;

  369. }

  370. 

  371. void ff_j2k_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)

  372. {

  373.     int reslevelno, bandno, cblkno, precno;

  374.     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {

  375.         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;

  376.         for (bandno = 0; bandno < rlevel->nbands; bandno++) {

  377.             Jpeg2000Band *band = rlevel->band + bandno;

  378.             for(precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++) {

  379.                 Jpeg2000Prec *prec = band->prec + precno;

  380.                 tag_tree_zero(prec->zerobits, prec->xi1 - prec->xi0, prec->yi1 - prec->yi0);

  381.                 tag_tree_zero(prec->cblkincl, prec->xi1 - prec->xi0, prec->yi1 - prec->yi0);

  382.             }

  383.             for (cblkno = 0; cblkno < band->cblknx * band->cblkny; cblkno++) {

  384.                 Jpeg2000Cblk *cblk = band->cblk + cblkno;

  385.                 cblk->length = 0;

  386.                 cblk->lblock = 3;

  387.             }

  388.         }

  389.     }

  390. }

  391. 

  392. void ff_j2k_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)

  393. {

  394.     int reslevelno, bandno, precno;

  395.     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {

  396.         Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;

  397. 

  398.         for (bandno = 0; bandno < reslevel->nbands; bandno++) {

  399.             Jpeg2000Band *band = reslevel->band + bandno;

  400.                 for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++) {

  401.                     Jpeg2000Prec *prec = band->prec + precno;

  402.                     av_freep(&prec->zerobits);

  403.                     av_freep(&prec->cblkincl);

  404.                 }

  405.                 av_freep(&band->cblk);

  406.                 av_freep(&band->prec);

  407.             }

  408.         av_freep(&reslevel->band);

  409.     }

  410. 

  411.     ff_j2k_dwt_destroy(&comp->dwt);

  412.     av_freep(&comp->reslevel);

  413.     av_freep(&comp->data);

  414. }