j2k: Rename structs to be more similar to jpeg2000dec

This should simplify merging
Signed-off-by: Michael Niedermayer <michaelni@gmx.at>

libavcodec/j2k.c

@@ -64,12 +64,12 @@ static int tag_tree_size(int w, int h)
     return res + 1;
 }
 
-J2kTgtNode *ff_j2k_tag_tree_init(int w, int h)
+Jpeg2000TgtNode *ff_j2k_tag_tree_init(int w, int h)
 {
     int pw = w, ph = h;
-    J2kTgtNode *res, *t, *t2;
+    Jpeg2000TgtNode *res, *t, *t2;
 
-    t = res = av_mallocz(tag_tree_size(w, h)*sizeof(J2kTgtNode));
+    t = res = av_mallocz(tag_tree_size(w, h)*sizeof(Jpeg2000TgtNode));
 
     if (res == NULL)
         return NULL;
@@ -93,7 +93,7 @@ J2kTgtNode *ff_j2k_tag_tree_init(int w, int h)
     return res;
 }
 
-static void tag_tree_zero(J2kTgtNode *t, int w, int h)
+static void tag_tree_zero(Jpeg2000TgtNode *t, int w, int h)
 {
     int i, siz = tag_tree_size(w, h);
 
@@ -178,7 +178,7 @@ void ff_j2k_init_tier1_luts(void)
             ff_j2k_sgnctxno_lut[i][j] = getsgnctxno(i + (j << 8), &ff_j2k_xorbit_lut[i][j]);
 }
 
-void ff_j2k_set_significant(J2kT1Context *t1, int x, int y, int negative)
+void ff_j2k_set_significant(Jpeg2000T1Context *t1, int x, int y, int negative)
 {
     x++; y++;
     t1->flags[y][x] |= J2K_T1_SIG;
@@ -199,7 +199,7 @@ void ff_j2k_set_significant(J2kT1Context *t1, int x, int y, int negative)
     t1->flags[y-1][x-1] |= J2K_T1_SIG_SE;
 }
 
-int ff_j2k_init_component(J2kComponent *comp, J2kCodingStyle *codsty, J2kQuantStyle *qntsty, int cbps, int dx, int dy)
+int ff_j2k_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy)
 {
     int reslevelno, bandno, gbandno = 0, ret, i, j, csize = 1;
 
@@ -211,13 +211,13 @@ int ff_j2k_init_component(J2kComponent *comp, J2kCodingStyle *codsty, J2kQuantSt
     comp->data = av_malloc(csize * sizeof(int));
     if (!comp->data)
         return AVERROR(ENOMEM);
-    comp->reslevel = av_malloc(codsty->nreslevels * sizeof(J2kResLevel));
+    comp->reslevel = av_malloc(codsty->nreslevels * sizeof(Jpeg2000ResLevel));
 
     if (!comp->reslevel)
         return AVERROR(ENOMEM);
     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
         int declvl = codsty->nreslevels - reslevelno;
-        J2kResLevel *reslevel = comp->reslevel + reslevelno;
+        Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
 
         for (i = 0; i < 2; i++)
             for (j = 0; j < 2; j++)
@@ -241,11 +241,11 @@ int ff_j2k_init_component(J2kComponent *comp, J2kCodingStyle *codsty, J2kQuantSt
             reslevel->num_precincts_y = ff_j2k_ceildivpow2(reslevel->coord[1][1], codsty->log2_prec_height)
                                         - (reslevel->coord[1][0] >> codsty->log2_prec_height);
 
-        reslevel->band = av_malloc(reslevel->nbands * sizeof(J2kBand));
+        reslevel->band = av_malloc(reslevel->nbands * sizeof(Jpeg2000Band));
         if (!reslevel->band)
             return AVERROR(ENOMEM);
         for (bandno = 0; bandno < reslevel->nbands; bandno++, gbandno++){
-            J2kBand *band = reslevel->band + bandno;
+            Jpeg2000Band *band = reslevel->band + bandno;
             int cblkno, precx, precy, precno;
             int x0, y0, x1, y1;
             int xi0, yi0, xi1, yi1;
@@ -285,15 +285,15 @@ int ff_j2k_init_component(J2kComponent *comp, J2kCodingStyle *codsty, J2kQuantSt
             band->cblknx = ff_j2k_ceildiv(band->cblknx, dx);
             band->cblkny = ff_j2k_ceildiv(band->cblkny, dy);
 
-            band->cblk = av_malloc(sizeof(J2kCblk) * band->cblknx * band->cblkny);
+            band->cblk = av_malloc(sizeof(Jpeg2000Cblk) * band->cblknx * band->cblkny);
             if (!band->cblk)
                 return AVERROR(ENOMEM);
-            band->prec = av_malloc(sizeof(J2kCblk) * reslevel->num_precincts_x * reslevel->num_precincts_y);
+            band->prec = av_malloc(sizeof(Jpeg2000Cblk) * reslevel->num_precincts_x * reslevel->num_precincts_y);
             if (!band->prec)
                 return AVERROR(ENOMEM);
 
             for (cblkno = 0; cblkno < band->cblknx * band->cblkny; cblkno++){
-                J2kCblk *cblk = band->cblk + cblkno;
+                Jpeg2000Cblk *cblk = band->cblk + cblkno;
                 cblk->zero = 0;
                 cblk->lblock = 3;
                 cblk->length = 0;
@@ -325,7 +325,7 @@ int ff_j2k_init_component(J2kComponent *comp, J2kCodingStyle *codsty, J2kQuantSt
             cblkperprecw = 1<<(codsty->log2_prec_width - codsty->log2_cblk_width);
             for (precx = 0, precno = 0; precx < reslevel->num_precincts_x; precx++){
                 for (precy = 0; precy < reslevel->num_precincts_y; precy++, precno = 0){
-                    J2kPrec *prec = band->prec + precno;
+                    Jpeg2000Prec *prec = band->prec + precno;
                     prec->xi0 = xi0;
                     prec->xi1 = xi1;
                     prec->cblkincl = ff_j2k_tag_tree_init(prec->xi1 - prec->xi0,
@@ -345,20 +345,20 @@ int ff_j2k_init_component(J2kComponent *comp, J2kCodingStyle *codsty, J2kQuantSt
     return 0;
 }
 
-void ff_j2k_reinit(J2kComponent *comp, J2kCodingStyle *codsty)
+void ff_j2k_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
 {
     int reslevelno, bandno, cblkno, precno;
     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
-        J2kResLevel *rlevel = comp->reslevel + reslevelno;
+        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
         for (bandno = 0; bandno < rlevel->nbands; bandno++){
-            J2kBand *band = rlevel->band + bandno;
+            Jpeg2000Band *band = rlevel->band + bandno;
             for(precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++){
-                J2kPrec *prec = band->prec + precno;
+                Jpeg2000Prec *prec = band->prec + precno;
                 tag_tree_zero(prec->zerobits, prec->xi1 - prec->xi0, prec->yi1 - prec->yi0);
                 tag_tree_zero(prec->cblkincl, prec->xi1 - prec->xi0, prec->yi1 - prec->yi0);
             }
             for (cblkno = 0; cblkno < band->cblknx * band->cblkny; cblkno++){
-                J2kCblk *cblk = band->cblk + cblkno;
+                Jpeg2000Cblk *cblk = band->cblk + cblkno;
                 cblk->length = 0;
                 cblk->lblock = 3;
             }
@@ -366,16 +366,16 @@ void ff_j2k_reinit(J2kComponent *comp, J2kCodingStyle *codsty)
     }
 }
 
-void ff_j2k_cleanup(J2kComponent *comp, J2kCodingStyle *codsty)
+void ff_j2k_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
 {
     int reslevelno, bandno, precno;
     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
-        J2kResLevel *reslevel = comp->reslevel + reslevelno;
+        Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
 
         for (bandno = 0; bandno < reslevel->nbands ; bandno++){
-            J2kBand *band = reslevel->band + bandno;
+            Jpeg2000Band *band = reslevel->band + bandno;
                 for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
-                    J2kPrec *prec = band->prec + precno;
+                    Jpeg2000Prec *prec = band->prec + precno;
                     av_freep(&prec->zerobits);
                     av_freep(&prec->cblkincl);
                 }

libavcodec/j2k.h

@@ -31,7 +31,7 @@
 #include "mqc.h"
 #include "j2k_dwt.h"
 
-enum J2kMarkers{
+enum Jpeg2000Markers{
     J2K_SOC = 0xff4f, ///< start of codestream
     J2K_SIZ = 0xff51, ///< image and tile size
     J2K_COD,          ///< coding style default
@@ -54,7 +54,7 @@ enum J2kMarkers{
     J2K_EOC = 0xffd9, ///< end of codestream
 };
 
-enum J2kQuantsty{ ///< quantization style
+enum Jpeg2000Quantsty{ ///< quantization style
     J2K_QSTY_NONE, ///< no quantization
     J2K_QSTY_SI,   ///< scalar derived
     J2K_QSTY_SE    ///< scalar expoounded
@@ -104,13 +104,13 @@ typedef struct {
     int data[J2K_MAX_CBLKW][J2K_MAX_CBLKH];
     int flags[J2K_MAX_CBLKW+2][J2K_MAX_CBLKH+2];
     MqcState mqc;
-} J2kT1Context;
+} Jpeg2000T1Context;
 
-typedef struct J2kTgtNode {
+typedef struct Jpeg2000TgtNode {
     uint8_t val;
     uint8_t vis;
-    struct J2kTgtNode *parent;
-} J2kTgtNode;
+    struct Jpeg2000TgtNode *parent;
+} Jpeg2000TgtNode;
 
 typedef struct {
     uint8_t nreslevels;       ///< number of resolution levels
@@ -123,19 +123,19 @@ typedef struct {
     uint8_t nlayers;          ///< number of layers
     uint8_t mct;              ///< multiple component transformation
     uint8_t cblk_style;       ///< codeblock coding style
-} J2kCodingStyle;
+} Jpeg2000CodingStyle;
 
 typedef struct {
     uint8_t  expn[32 * 3]; ///< quantization exponent
     uint16_t mant[32 * 3]; ///< quantization mantissa
     uint8_t  quantsty;     ///< quantization style
     uint8_t  nguardbits;   ///< number of guard bits
-} J2kQuantStyle;
+} Jpeg2000QuantStyle;
 
 typedef struct {
     uint16_t rate;
     int64_t disto;
-} J2kPass;
+} Jpeg2000Pass;
 
 typedef struct {
     uint8_t npasses;
@@ -146,38 +146,38 @@ typedef struct {
     uint8_t lblock;
     uint8_t zero;
     uint8_t data[8192];
-    J2kPass passes[100];
-} J2kCblk; ///< code block
+    Jpeg2000Pass passes[100];
+} Jpeg2000Cblk; ///< code block
 
 typedef struct {
     uint16_t xi0, xi1, yi0, yi1; ///< codeblock indexes ([xi0, xi1))
-    J2kTgtNode *zerobits;
-    J2kTgtNode *cblkincl;
-} J2kPrec; ///< precinct
+    Jpeg2000TgtNode *zerobits;
+    Jpeg2000TgtNode *cblkincl;
+} Jpeg2000Prec; ///< precinct
 
 typedef struct {
     uint16_t coord[2][2]; ///< border coordinates {{x0, x1}, {y0, y1}}
     uint16_t codeblock_width, codeblock_height;
     uint16_t cblknx, cblkny;
     uint32_t stepsize; ///< quantization stepsize (* 2^13)
-    J2kPrec *prec;
-    J2kCblk *cblk;
-} J2kBand; ///< subband
+    Jpeg2000Prec *prec;
+    Jpeg2000Cblk *cblk;
+} Jpeg2000Band; ///< subband
 
 typedef struct {
     uint8_t nbands;
     uint16_t coord[2][2]; ///< border coordinates {{x0, x1}, {y0, y1}}
     uint16_t num_precincts_x, num_precincts_y; ///< number of precincts in x/y direction
     uint8_t log2_prec_width, log2_prec_height; ///< exponent of precinct size
-    J2kBand *band;
-} J2kResLevel; ///< resolution level
+    Jpeg2000Band *band;
+} Jpeg2000ResLevel; ///< resolution level
 
 typedef struct {
-   J2kResLevel *reslevel;
+   Jpeg2000ResLevel *reslevel;
    DWTContext dwt;
    int *data;
    uint16_t coord[2][2]; ///< border coordinates {{x0, x1}, {y0, y1}}
-} J2kComponent;
+} Jpeg2000Component;
 
 /* debug routines */
 #if 0
@@ -199,12 +199,12 @@ static inline int ff_j2k_ceildiv(int a, int b)
 }
 
 /* tag tree routines */
-J2kTgtNode *ff_j2k_tag_tree_init(int w, int h);
+Jpeg2000TgtNode *ff_j2k_tag_tree_init(int w, int h);
 
 /* TIER-1 routines */
 void ff_j2k_init_tier1_luts(void);
 
-void ff_j2k_set_significant(J2kT1Context *t1, int x, int y, int negative);
+void ff_j2k_set_significant(Jpeg2000T1Context *t1, int x, int y, int negative);
 
 extern uint8_t ff_j2k_nbctxno_lut[256][4];
 
@@ -227,8 +227,8 @@ static inline int ff_j2k_getsgnctxno(int flag, int *xorbit)
     return  ff_j2k_sgnctxno_lut[flag&15][(flag>>8)&15];
 }
 
-int ff_j2k_init_component(J2kComponent *comp, J2kCodingStyle *codsty, J2kQuantStyle *qntsty, int cbps, int dx, int dy);
-void ff_j2k_reinit(J2kComponent *comp, J2kCodingStyle *codsty);
-void ff_j2k_cleanup(J2kComponent *comp, J2kCodingStyle *codsty);
+int ff_j2k_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy);
+void ff_j2k_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty);
+void ff_j2k_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty);
 
 #endif /* AVCODEC_J2K_H */

libavcodec/j2kdec.c

@@ -42,11 +42,11 @@
 #define HAD_QCC 0x02
 
 typedef struct {
-   J2kComponent *comp;
+   Jpeg2000Component *comp;
    uint8_t properties[4];
-   J2kCodingStyle codsty[4];
-   J2kQuantStyle  qntsty[4];
-} J2kTile;
+   Jpeg2000CodingStyle codsty[4];
+   Jpeg2000QuantStyle  qntsty[4];
+} Jpeg2000Tile;
 
 typedef struct {
     AVCodecContext *avctx;
@@ -66,17 +66,17 @@ typedef struct {
     int numXtiles, numYtiles;
     int maxtilelen;
 
-    J2kCodingStyle codsty[4];
-    J2kQuantStyle  qntsty[4];
+    Jpeg2000CodingStyle codsty[4];
+    Jpeg2000QuantStyle  qntsty[4];
 
     int bit_index;
 
     int curtileno;
 
-    J2kTile *tile;
-} J2kDecoderContext;
+    Jpeg2000Tile *tile;
+} Jpeg2000DecoderContext;
 
-static int get_bits(J2kDecoderContext *s, int n)
+static int get_bits(Jpeg2000DecoderContext *s, int n)
 {
     int res = 0;
 
@@ -91,14 +91,14 @@ static int get_bits(J2kDecoderContext *s, int n)
     return res;
 }
 
-static void j2k_flush(J2kDecoderContext *s)
+static void j2k_flush(Jpeg2000DecoderContext *s)
 {
     if (bytestream2_get_byte(&s->g) == 0xff)
         bytestream2_skip(&s->g, 1);
     s->bit_index = 8;
 }
 #if 0
-void printcomp(J2kComponent *comp)
+void printcomp(Jpeg2000Component *comp)
 {
     int i;
     for (i = 0; i < comp->y1 - comp->y0; i++)
@@ -110,7 +110,7 @@ static void nspaces(FILE *fd, int n)
     while(n--) putc(' ', fd);
 }
 
-static void dump(J2kDecoderContext *s, FILE *fd)
+static void dump(Jpeg2000DecoderContext *s, FILE *fd)
 {
     int tileno, compno, reslevelno, bandno, precno;
     fprintf(fd, "XSiz = %d, YSiz = %d, tile_width = %d, tile_height = %d\n"
@@ -119,18 +119,18 @@ static void dump(J2kDecoderContext *s, FILE *fd)
             s->width, s->height, s->tile_width, s->tile_height,
             s->numXtiles, s->numYtiles, s->ncomponents);
     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
-        J2kTile *tile = s->tile + tileno;
+        Jpeg2000Tile *tile = s->tile + tileno;
         nspaces(fd, 2);
         fprintf(fd, "tile %d:\n", tileno);
         for(compno = 0; compno < s->ncomponents; compno++){
-            J2kComponent *comp = tile->comp + compno;
+            Jpeg2000Component *comp = tile->comp + compno;
             nspaces(fd, 4);
             fprintf(fd, "component %d:\n", compno);
             nspaces(fd, 4);
             fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d\n",
                         comp->x0, comp->x1, comp->y0, comp->y1);
             for(reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
-                J2kResLevel *reslevel = comp->reslevel + reslevelno;
+                Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
                 nspaces(fd, 6);
                 fprintf(fd, "reslevel %d:\n", reslevelno);
                 nspaces(fd, 6);
@@ -138,7 +138,7 @@ static void dump(J2kDecoderContext *s, FILE *fd)
                         reslevel->x0, reslevel->x1, reslevel->y0,
                         reslevel->y1, reslevel->nbands);
                 for(bandno = 0; bandno < reslevel->nbands; bandno++){
-                    J2kBand *band = reslevel->band + bandno;
+                    Jpeg2000Band *band = reslevel->band + bandno;
                     nspaces(fd, 8);
                     fprintf(fd, "band %d:\n", bandno);
                     nspaces(fd, 8);
@@ -149,7 +149,7 @@ static void dump(J2kDecoderContext *s, FILE *fd)
                                 band->codeblock_width, band->codeblock_height,
                                 band->cblknx, band->cblkny);
                     for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
-                        J2kPrec *prec = band->prec + precno;
+                        Jpeg2000Prec *prec = band->prec + precno;
                         nspaces(fd, 10);
                         fprintf(fd, "prec %d:\n", precno);
                         nspaces(fd, 10);
@@ -164,9 +164,9 @@ static void dump(J2kDecoderContext *s, FILE *fd)
 #endif
 
 /** decode the value stored in node */
-static int tag_tree_decode(J2kDecoderContext *s, J2kTgtNode *node, int threshold)
+static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node, int threshold)
 {
-    J2kTgtNode *stack[30];
+    Jpeg2000TgtNode *stack[30];
     int sp = -1, curval = 0;
 
     if(!node)
@@ -203,7 +203,7 @@ static int tag_tree_decode(J2kDecoderContext *s, J2kTgtNode *node, int threshold
 
 /* marker segments */
 /** get sizes and offsets of image, tiles; number of components */
-static int get_siz(J2kDecoderContext *s)
+static int get_siz(Jpeg2000DecoderContext *s)
 {
     int i, ret;
     ThreadFrame frame = { .f = s->picture };
@@ -245,17 +245,17 @@ static int get_siz(J2kDecoderContext *s)
     s->numXtiles = ff_j2k_ceildiv(s->width - s->tile_offset_x, s->tile_width);
     s->numYtiles = ff_j2k_ceildiv(s->height - s->tile_offset_y, s->tile_height);
 
-    if(s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(J2kTile))
+    if(s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(Jpeg2000Tile))
         return AVERROR(EINVAL);
 
-    s->tile = av_mallocz(s->numXtiles * s->numYtiles * sizeof(J2kTile));
+    s->tile = av_mallocz(s->numXtiles * s->numYtiles * sizeof(Jpeg2000Tile));
     if (!s->tile)
         return AVERROR(ENOMEM);
 
     for (i = 0; i < s->numXtiles * s->numYtiles; i++){
-        J2kTile *tile = s->tile + i;
+        Jpeg2000Tile *tile = s->tile + i;
 
-        tile->comp = av_mallocz(s->ncomponents * sizeof(J2kComponent));
+        tile->comp = av_mallocz(s->ncomponents * sizeof(Jpeg2000Component));
         if (!tile->comp)
             return AVERROR(ENOMEM);
     }
@@ -294,7 +294,7 @@ static int get_siz(J2kDecoderContext *s)
 }
 
 /** get common part for COD and COC segments */
-static int get_cox(J2kDecoderContext *s, J2kCodingStyle *c)
+static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
 {
     if (bytestream2_get_bytes_left(&s->g) < 5)
         return AVERROR(EINVAL);
@@ -317,9 +317,9 @@ static int get_cox(J2kDecoderContext *s, J2kCodingStyle *c)
 }
 
 /** get coding parameters for a particular tile or whole image*/
-static int get_cod(J2kDecoderContext *s, J2kCodingStyle *c, uint8_t *properties)
+static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
 {
-    J2kCodingStyle tmp;
+    Jpeg2000CodingStyle tmp;
     int compno;
 
     if (bytestream2_get_bytes_left(&s->g) < 5)
@@ -341,13 +341,13 @@ static int get_cod(J2kDecoderContext *s, J2kCodingStyle *c, uint8_t *properties)
     get_cox(s, &tmp);
     for (compno = 0; compno < s->ncomponents; compno++){
         if (!(properties[compno] & HAD_COC))
-            memcpy(c + compno, &tmp, sizeof(J2kCodingStyle));
+            memcpy(c + compno, &tmp, sizeof(Jpeg2000CodingStyle));
     }
     return 0;
 }
 
 /** get coding parameters for a component in the whole image on a particular tile */
-static int get_coc(J2kDecoderContext *s, J2kCodingStyle *c, uint8_t *properties)
+static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
 {
     int compno;
 
@@ -365,7 +365,7 @@ static int get_coc(J2kDecoderContext *s, J2kCodingStyle *c, uint8_t *properties)
 }
 
 /** get common part for QCD and QCC segments */
-static int get_qcx(J2kDecoderContext *s, int n, J2kQuantStyle *q)
+static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
 {
     int i, x;
 
@@ -408,21 +408,21 @@ static int get_qcx(J2kDecoderContext *s, int n, J2kQuantStyle *q)
 }
 
 /** get quantization parameters for a particular tile or a whole image */
-static int get_qcd(J2kDecoderContext *s, int n, J2kQuantStyle *q, uint8_t *properties)
+static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
 {
-    J2kQuantStyle tmp;
+    Jpeg2000QuantStyle tmp;
     int compno;
 
     if (get_qcx(s, n, &tmp))
         return -1;
     for (compno = 0; compno < s->ncomponents; compno++)
         if (!(properties[compno] & HAD_QCC))
-            memcpy(q + compno, &tmp, sizeof(J2kQuantStyle));
+            memcpy(q + compno, &tmp, sizeof(Jpeg2000QuantStyle));
     return 0;
 }
 
 /** get quantization parameters for a component in the whole image on in a particular tile */
-static int get_qcc(J2kDecoderContext *s, int n, J2kQuantStyle *q, uint8_t *properties)
+static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
 {
     int compno;
 
@@ -435,7 +435,7 @@ static int get_qcc(J2kDecoderContext *s, int n, J2kQuantStyle *q, uint8_t *prope
 }
 
 /** get start of tile segment */
-static uint8_t get_sot(J2kDecoderContext *s)
+static uint8_t get_sot(Jpeg2000DecoderContext *s)
 {
     if (bytestream2_get_bytes_left(&s->g) < 8)
         return AVERROR(EINVAL);
@@ -449,30 +449,30 @@ static uint8_t get_sot(J2kDecoderContext *s)
     bytestream2_skipu(&s->g, 4); ///< Psot (ignored)
 
     if (!bytestream2_get_byteu(&s->g)){ ///< TPsot
-        J2kTile *tile = s->tile + s->curtileno;
+        Jpeg2000Tile *tile = s->tile + s->curtileno;
 
         /* copy defaults */
-        memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(J2kCodingStyle));
-        memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(J2kQuantStyle));
+        memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
+        memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
     }
     bytestream2_get_byteu(&s->g); ///< TNsot
 
     return 0;
 }
 
-static int init_tile(J2kDecoderContext *s, int tileno)
+static int init_tile(Jpeg2000DecoderContext *s, int tileno)
 {
     int compno,
         tilex = tileno % s->numXtiles,
         tiley = tileno / s->numXtiles;
-    J2kTile *tile = s->tile + tileno;
+    Jpeg2000Tile *tile = s->tile + tileno;
 
     if (!tile->comp)
         return AVERROR(ENOMEM);
     for (compno = 0; compno < s->ncomponents; compno++){
-        J2kComponent *comp = tile->comp + compno;
-        J2kCodingStyle *codsty = tile->codsty + compno;
-        J2kQuantStyle  *qntsty = tile->qntsty + compno;
+        Jpeg2000Component *comp = tile->comp + compno;
+        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
+        Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
         int ret; // global bandno
 
         comp->coord[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x);
@@ -487,7 +487,7 @@ static int init_tile(J2kDecoderContext *s, int tileno)
 }
 
 /** read the number of coding passes */
-static int getnpasses(J2kDecoderContext *s)
+static int getnpasses(Jpeg2000DecoderContext *s)
 {
     int num;
     if (!get_bits(s, 1))
@@ -502,7 +502,7 @@ static int getnpasses(J2kDecoderContext *s)
     return num < 0 ? num : 37 + num;
 }
 
-static int getlblockinc(J2kDecoderContext *s)
+static int getlblockinc(Jpeg2000DecoderContext *s)
 {
     int res = 0, ret;
     while (ret = get_bits(s, 1)){
@@ -513,7 +513,7 @@ static int getlblockinc(J2kDecoderContext *s)
     return res;
 }
 
-static int decode_packet(J2kDecoderContext *s, J2kCodingStyle *codsty, J2kResLevel *rlevel, int precno,
+static int decode_packet(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000ResLevel *rlevel, int precno,
                          int layno, uint8_t *expn, int numgbits)
 {
     int bandno, cblkny, cblknx, cblkno, ret;
@@ -525,8 +525,8 @@ static int decode_packet(J2kDecoderContext *s, J2kCodingStyle *codsty, J2kResLev
         return ret;
 
     for (bandno = 0; bandno < rlevel->nbands; bandno++){
-        J2kBand *band = rlevel->band + bandno;
-        J2kPrec *prec = band->prec + precno;
+        Jpeg2000Band *band = rlevel->band + bandno;
+        Jpeg2000Prec *prec = band->prec + precno;
         int pos = 0;
 
         if (band->coord[0][0] == band->coord[0][1]
@@ -535,7 +535,7 @@ static int decode_packet(J2kDecoderContext *s, J2kCodingStyle *codsty, J2kResLev
 
         for (cblkny = prec->yi0; cblkny < prec->yi1; cblkny++)
             for(cblknx = prec->xi0, cblkno = cblkny * band->cblknx + cblknx; cblknx < prec->xi1; cblknx++, cblkno++, pos++){
-                J2kCblk *cblk = band->cblk + cblkno;
+                Jpeg2000Cblk *cblk = band->cblk + cblkno;
                 int incl, newpasses, llen;
 
                 if (cblk->npasses)
@@ -571,12 +571,12 @@ static int decode_packet(J2kDecoderContext *s, J2kCodingStyle *codsty, J2kResLev
     }
 
     for (bandno = 0; bandno < rlevel->nbands; bandno++){
-        J2kBand *band = rlevel->band + bandno;
+        Jpeg2000Band *band = rlevel->band + bandno;
         int yi, cblknw = band->prec[precno].xi1 - band->prec[precno].xi0;
         for (yi = band->prec[precno].yi0; yi < band->prec[precno].yi1; yi++){
             int xi;
             for (xi = band->prec[precno].xi0; xi < band->prec[precno].xi1; xi++){
-                J2kCblk *cblk = band->cblk + yi * cblknw + xi;
+                Jpeg2000Cblk *cblk = band->cblk + yi * cblknw + xi;
                 if (bytestream2_get_bytes_left(&s->g) < cblk->lengthinc)
                     return AVERROR(EINVAL);
                 bytestream2_get_bufferu(&s->g, cblk->data, cblk->lengthinc);
@@ -588,7 +588,7 @@ static int decode_packet(J2kDecoderContext *s, J2kCodingStyle *codsty, J2kResLev
     return 0;
 }
 
-static int jpeg2000_decode_packets(J2kDecoderContext *s, J2kTile *tile)
+static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
 {
     int layno, reslevelno, compno, precno, ok_reslevel;
     s->bit_index = 8;
@@ -597,10 +597,10 @@ static int jpeg2000_decode_packets(J2kDecoderContext *s, J2kTile *tile)
         for (reslevelno = 0; ok_reslevel; reslevelno++){
             ok_reslevel = 0;
             for (compno = 0; compno < s->ncomponents; compno++){
-                J2kCodingStyle *codsty = tile->codsty + compno;
-                J2kQuantStyle  *qntsty = tile->qntsty + compno;
+                Jpeg2000CodingStyle *codsty = tile->codsty + compno;
+                Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
                 if (reslevelno < codsty->nreslevels){
-                    J2kResLevel *rlevel = tile->comp[compno].reslevel + reslevelno;
+                    Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel + reslevelno;
                     ok_reslevel = 1;
                     for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++){
                         if (decode_packet(s, codsty, rlevel, precno, layno, qntsty->expn +
@@ -615,7 +615,7 @@ static int jpeg2000_decode_packets(J2kDecoderContext *s, J2kTile *tile)
 }
 
 /* TIER-1 routines */
-static void decode_sigpass(J2kT1Context *t1, int width, int height, int bpno, int bandno, int bpass_csty_symbol,
+static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bpno, int bandno, int bpass_csty_symbol,
                            int vert_causal_ctx_csty_symbol)
 {
     int mask = 3 << (bpno - 1), y0, x, y;
@@ -642,7 +642,7 @@ static void decode_sigpass(J2kT1Context *t1, int width, int height, int bpno, in
             }
 }
 
-static void decode_refpass(J2kT1Context *t1, int width, int height, int bpno)
+static void decode_refpass(Jpeg2000T1Context *t1, int width, int height, int bpno)
 {
     int phalf, nhalf;
     int y0, x, y;
@@ -662,7 +662,7 @@ static void decode_refpass(J2kT1Context *t1, int width, int height, int bpno)
             }
 }
 
-static void decode_clnpass(J2kDecoderContext *s, J2kT1Context *t1, int width, int height,
+static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1, int width, int height,
                            int bpno, int bandno, int seg_symbols)
 {
     int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
@@ -712,7 +712,7 @@ static void decode_clnpass(J2kDecoderContext *s, J2kT1Context *t1, int width, in
     }
 }
 
-static int decode_cblk(J2kDecoderContext *s, J2kCodingStyle *codsty, J2kT1Context *t1, J2kCblk *cblk,
+static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
                        int width, int height, int bandpos)
 {
     int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y, clnpass_cnt = 0;
@@ -755,7 +755,7 @@ static int decode_cblk(J2kDecoderContext *s, J2kCodingStyle *codsty, J2kT1Contex
     return 0;
 }
 
-static void mct_decode(J2kDecoderContext *s, J2kTile *tile)
+static void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
 {
     int i, *src[3], i0, i1, i2, csize = 1;
 
@@ -786,21 +786,21 @@ static void mct_decode(J2kDecoderContext *s, J2kTile *tile)
     }
 }
 
-static int decode_tile(J2kDecoderContext *s, J2kTile *tile)
+static int decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
 {
     int compno, reslevelno, bandno;
     int x, y, *src[4];
     uint8_t *line;
-    J2kT1Context t1;
+    Jpeg2000T1Context t1;
 
     for (compno = 0; compno < s->ncomponents; compno++){
-        J2kComponent *comp = tile->comp + compno;
-        J2kCodingStyle *codsty = tile->codsty + compno;
+        Jpeg2000Component *comp = tile->comp + compno;
+        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
 
         for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
-            J2kResLevel *rlevel = comp->reslevel + reslevelno;
+            Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
             for (bandno = 0; bandno < rlevel->nbands; bandno++){
-                J2kBand *band = rlevel->band + bandno;
+                Jpeg2000Band *band = rlevel->band + bandno;
                 int cblkx, cblky, cblkno=0, xx0, x0, xx1, y0, yy0, yy1, bandpos;
 
                 bandpos = bandno + (reslevelno > 0);
@@ -903,13 +903,13 @@ static int decode_tile(J2kDecoderContext *s, J2kTile *tile)
     return 0;
 }
 
-static void cleanup(J2kDecoderContext *s)
+static void cleanup(Jpeg2000DecoderContext *s)
 {
     int tileno, compno;
     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
         for (compno = 0; compno < s->ncomponents; compno++){
-            J2kComponent *comp = s->tile[tileno].comp + compno;
-            J2kCodingStyle *codsty = s->tile[tileno].codsty + compno;
+            Jpeg2000Component *comp = s->tile[tileno].comp + compno;
+            Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
 
             ff_j2k_cleanup(comp, codsty);
         }
@@ -918,10 +918,10 @@ static void cleanup(J2kDecoderContext *s)
     av_freep(&s->tile);
 }
 
-static int decode_codestream(J2kDecoderContext *s)
+static int decode_codestream(Jpeg2000DecoderContext *s)
 {
-    J2kCodingStyle *codsty = s->codsty;
-    J2kQuantStyle  *qntsty = s->qntsty;
+    Jpeg2000CodingStyle *codsty = s->codsty;
+    Jpeg2000QuantStyle  *qntsty = s->qntsty;
     uint8_t *properties = s->properties;
 
     for (;;){
@@ -937,7 +937,7 @@ static int decode_codestream(J2kDecoderContext *s)
         oldpos = bytestream2_tell(&s->g);
 
         if (marker == J2K_SOD){
-            J2kTile *tile = s->tile + s->curtileno;
+            Jpeg2000Tile *tile = s->tile + s->curtileno;
             if (ret = init_tile(s, s->curtileno)) {
                 av_log(s->avctx, AV_LOG_ERROR, "tile initialization failed\n");
                 return ret;
@@ -994,7 +994,7 @@ static int decode_codestream(J2kDecoderContext *s)
     return 0;
 }
 
-static int jp2_find_codestream(J2kDecoderContext *s)
+static int jp2_find_codestream(Jpeg2000DecoderContext *s)
 {
     uint32_t atom_size, atom;
     int found_codestream = 0, search_range = 10;
@@ -1021,7 +1021,7 @@ static int decode_frame(AVCodecContext *avctx,
                         void *data, int *got_frame,
                         AVPacket *avpkt)
 {
-    J2kDecoderContext *s = avctx->priv_data;
+    Jpeg2000DecoderContext *s = avctx->priv_data;
     AVFrame *picture = data;
     int tileno, ret;
 
@@ -1074,7 +1074,7 @@ err_out:
 
 static av_cold int j2kdec_init(AVCodecContext *avctx)
 {
-    J2kDecoderContext *s = avctx->priv_data;
+    Jpeg2000DecoderContext *s = avctx->priv_data;
 
     s->avctx = avctx;
 
@@ -1087,7 +1087,7 @@ AVCodec ff_j2k_decoder = {
     .name           = "j2k",
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_JPEG2000,
-    .priv_data_size = sizeof(J2kDecoderContext),
+    .priv_data_size = sizeof(Jpeg2000DecoderContext),
     .init           = j2kdec_init,
     .decode         = decode_frame,
     .capabilities   = CODEC_CAP_EXPERIMENTAL | CODEC_CAP_FRAME_THREADS,

libavcodec/j2kenc.c

@@ -55,8 +55,8 @@ static const int dwt_norms[2][4][10] = { // [dwt_type][band][rlevel] (multiplied
 };
 
 typedef struct {
-   J2kComponent *comp;
-} J2kTile;
+   Jpeg2000Component *comp;
+} Jpeg2000Tile;
 
 typedef struct {
     AVCodecContext *avctx;
@@ -77,11 +77,11 @@ typedef struct {
 
     int64_t lambda;
 
-    J2kCodingStyle codsty;
-    J2kQuantStyle  qntsty;
+    Jpeg2000CodingStyle codsty;
+    Jpeg2000QuantStyle  qntsty;
 
-    J2kTile *tile;
-} J2kEncoderContext;
+    Jpeg2000Tile *tile;
+} Jpeg2000EncoderContext;
 
 
 /* debug */
@@ -94,14 +94,14 @@ static void nspaces(FILE *fd, int n)
     while(n--) putc(' ', fd);
 }
 
-static void printcomp(J2kComponent *comp)
+static void printcomp(Jpeg2000Component *comp)
 {
     int i;
     for (i = 0; i < comp->y1 - comp->y0; i++)
         ff_j2k_printv(comp->data + i * (comp->x1 - comp->x0), comp->x1 - comp->x0);
 }
 
-static void dump(J2kEncoderContext *s, FILE *fd)
+static void dump(Jpeg2000EncoderContext *s, FILE *fd)
 {
     int tileno, compno, reslevelno, bandno, precno;
     fprintf(fd, "XSiz = %d, YSiz = %d, tile_width = %d, tile_height = %d\n"
@@ -110,18 +110,18 @@ static void dump(J2kEncoderContext *s, FILE *fd)
             s->width, s->height, s->tile_width, s->tile_height,
             s->numXtiles, s->numYtiles, s->ncomponents);
     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
-        J2kTile *tile = s->tile + tileno;
+        Jpeg2000Tile *tile = s->tile + tileno;
         nspaces(fd, 2);
         fprintf(fd, "tile %d:\n", tileno);
         for(compno = 0; compno < s->ncomponents; compno++){
-            J2kComponent *comp = tile->comp + compno;
+            Jpeg2000Component *comp = tile->comp + compno;
             nspaces(fd, 4);
             fprintf(fd, "component %d:\n", compno);
             nspaces(fd, 4);
             fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d\n",
                         comp->x0, comp->x1, comp->y0, comp->y1);
             for(reslevelno = 0; reslevelno < s->nreslevels; reslevelno++){
-                J2kResLevel *reslevel = comp->reslevel + reslevelno;
+                Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
                 nspaces(fd, 6);
                 fprintf(fd, "reslevel %d:\n", reslevelno);
                 nspaces(fd, 6);
@@ -129,7 +129,7 @@ static void dump(J2kEncoderContext *s, FILE *fd)
                         reslevel->x0, reslevel->x1, reslevel->y0,
                         reslevel->y1, reslevel->nbands);
                 for(bandno = 0; bandno < reslevel->nbands; bandno++){
-                    J2kBand *band = reslevel->band + bandno;
+                    Jpeg2000Band *band = reslevel->band + bandno;
                     nspaces(fd, 8);
                     fprintf(fd, "band %d:\n", bandno);
                     nspaces(fd, 8);
@@ -140,7 +140,7 @@ static void dump(J2kEncoderContext *s, FILE *fd)
                                 band->codeblock_width, band->codeblock_height,
                                 band->cblknx, band->cblkny);
                     for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
-                        J2kPrec *prec = band->prec + precno;
+                        Jpeg2000Prec *prec = band->prec + precno;
                         nspaces(fd, 10);
                         fprintf(fd, "prec %d:\n", precno);
                         nspaces(fd, 10);
@@ -157,7 +157,7 @@ static void dump(J2kEncoderContext *s, FILE *fd)
 /* bitstream routines */
 
 /** put n times val bit */
-static void put_bits(J2kEncoderContext *s, int val, int n) // TODO: optimize
+static void put_bits(Jpeg2000EncoderContext *s, int val, int n) // TODO: optimize
 {
     while (n-- > 0){
         if (s->bit_index == 8)
@@ -170,14 +170,14 @@ static void put_bits(J2kEncoderContext *s, int val, int n) // TODO: optimize
 }
 
 /** put n least significant bits of a number num */
-static void put_num(J2kEncoderContext *s, int num, int n)
+static void put_num(Jpeg2000EncoderContext *s, int num, int n)
 {
     while(--n >= 0)
         put_bits(s, (num >> n) & 1, 1);
 }
 
 /** flush the bitstream */
-static void j2k_flush(J2kEncoderContext *s)
+static void j2k_flush(Jpeg2000EncoderContext *s)
 {
     if (s->bit_index){
         s->bit_index = 0;
@@ -188,9 +188,9 @@ static void j2k_flush(J2kEncoderContext *s)
 /* tag tree routines */
 
 /** code the value stored in node */
-static void tag_tree_code(J2kEncoderContext *s, J2kTgtNode *node, int threshold)
+static void tag_tree_code(Jpeg2000EncoderContext *s, Jpeg2000TgtNode *node, int threshold)
 {
-    J2kTgtNode *stack[30];
+    Jpeg2000TgtNode *stack[30];
     int sp = 1, curval = 0;
     stack[0] = node;
 
@@ -216,7 +216,7 @@ static void tag_tree_code(J2kEncoderContext *s, J2kTgtNode *node, int threshold)
 }
 
 /** update the value in node */
-static void tag_tree_update(J2kTgtNode *node)
+static void tag_tree_update(Jpeg2000TgtNode *node)
 {
     int lev = 0;
     while (node->parent){
@@ -228,7 +228,7 @@ static void tag_tree_update(J2kTgtNode *node)
     }
 }
 
-static int put_siz(J2kEncoderContext *s)
+static int put_siz(Jpeg2000EncoderContext *s)
 {
     int i;
 
@@ -257,9 +257,9 @@ static int put_siz(J2kEncoderContext *s)
     return 0;
 }
 
-static int put_cod(J2kEncoderContext *s)
+static int put_cod(Jpeg2000EncoderContext *s)
 {
-    J2kCodingStyle *codsty = &s->codsty;
+    Jpeg2000CodingStyle *codsty = &s->codsty;
 
     if (s->buf_end - s->buf < 14)
         return -1;
@@ -284,11 +284,11 @@ static int put_cod(J2kEncoderContext *s)
     return 0;
 }
 
-static int put_qcd(J2kEncoderContext *s, int compno)
+static int put_qcd(Jpeg2000EncoderContext *s, int compno)
 {
     int i, size;
-    J2kCodingStyle *codsty = &s->codsty;
-    J2kQuantStyle  *qntsty = &s->qntsty;
+    Jpeg2000CodingStyle *codsty = &s->codsty;
+    Jpeg2000QuantStyle  *qntsty = &s->qntsty;
 
     if (qntsty->quantsty == J2K_QSTY_NONE)
         size = 4 + 3 * (codsty->nreslevels-1);
@@ -310,7 +310,7 @@ static int put_qcd(J2kEncoderContext *s, int compno)
     return 0;
 }
 
-static uint8_t *put_sot(J2kEncoderContext *s, int tileno)
+static uint8_t *put_sot(Jpeg2000EncoderContext *s, int tileno)
 {
     uint8_t *psotptr;
 
@@ -334,27 +334,27 @@ static uint8_t *put_sot(J2kEncoderContext *s, int tileno)
  * allocate memory for them
  * divide the input image into tile-components
  */
-static int init_tiles(J2kEncoderContext *s)
+static int init_tiles(Jpeg2000EncoderContext *s)
 {
     int tileno, tilex, tiley, compno;
-    J2kCodingStyle *codsty = &s->codsty;
-    J2kQuantStyle  *qntsty = &s->qntsty;
+    Jpeg2000CodingStyle *codsty = &s->codsty;
+    Jpeg2000QuantStyle  *qntsty = &s->qntsty;
 
     s->numXtiles = ff_j2k_ceildiv(s->width, s->tile_width);
     s->numYtiles = ff_j2k_ceildiv(s->height, s->tile_height);
 
-    s->tile = av_malloc(s->numXtiles * s->numYtiles * sizeof(J2kTile));
+    s->tile = av_malloc(s->numXtiles * s->numYtiles * sizeof(Jpeg2000Tile));
     if (!s->tile)
         return AVERROR(ENOMEM);
     for (tileno = 0, tiley = 0; tiley < s->numYtiles; tiley++)
         for (tilex = 0; tilex < s->numXtiles; tilex++, tileno++){
-            J2kTile *tile = s->tile + tileno;
+            Jpeg2000Tile *tile = s->tile + tileno;
 
-            tile->comp = av_malloc(s->ncomponents * sizeof(J2kComponent));
+            tile->comp = av_malloc(s->ncomponents * sizeof(Jpeg2000Component));
             if (!tile->comp)
                 return AVERROR(ENOMEM);
             for (compno = 0; compno < s->ncomponents; compno++){
-                J2kComponent *comp = tile->comp + compno;
+                Jpeg2000Component *comp = tile->comp + compno;
                 int ret, i, j;
 
                 comp->coord[0][0] = tilex * s->tile_width;
@@ -373,15 +373,15 @@ static int init_tiles(J2kEncoderContext *s)
     return 0;
 }
 
-static void copy_frame(J2kEncoderContext *s)
+static void copy_frame(Jpeg2000EncoderContext *s)
 {
     int tileno, compno, i, y, x;
     uint8_t *line;
     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
-        J2kTile *tile = s->tile + tileno;
+        Jpeg2000Tile *tile = s->tile + tileno;
         if (s->planar){
             for (compno = 0; compno < s->ncomponents; compno++){
-                J2kComponent *comp = tile->comp + compno;
+                Jpeg2000Component *comp = tile->comp + compno;
                 int *dst = comp->data;
                 line = s->picture.data[compno]
                        + comp->coord[1][0] * s->picture.linesize[compno]
@@ -411,11 +411,11 @@ static void copy_frame(J2kEncoderContext *s)
     }
 }
 
-static void init_quantization(J2kEncoderContext *s)
+static void init_quantization(Jpeg2000EncoderContext *s)
 {
     int compno, reslevelno, bandno;
-    J2kQuantStyle  *qntsty = &s->qntsty;
-    J2kCodingStyle *codsty = &s->codsty;
+    Jpeg2000QuantStyle  *qntsty = &s->qntsty;
+    Jpeg2000CodingStyle *codsty = &s->codsty;
 
     for (compno = 0; compno < s->ncomponents; compno++){
         int gbandno = 0;
@@ -473,7 +473,7 @@ static int getnmsedec_ref(int x, int bpno)
     return lut_nmsedec_ref0[x & ((1 << NMSEDEC_BITS) - 1)];
 }
 
-static void encode_sigpass(J2kT1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
+static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
 {
     int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
     int vert_causal_ctx_csty_loc_symbol;
@@ -496,7 +496,7 @@ static void encode_sigpass(J2kT1Context *t1, int width, int height, int bandno,
             }
 }
 
-static void encode_refpass(J2kT1Context *t1, int width, int height, int *nmsedec, int bpno)
+static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno)
 {
     int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
     for (y0 = 0; y0 < height; y0 += 4)
@@ -510,7 +510,7 @@ static void encode_refpass(J2kT1Context *t1, int width, int height, int *nmsedec
                 }
 }
 
-static void encode_clnpass(J2kT1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
+static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
 {
     int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
     int vert_causal_ctx_csty_loc_symbol;
@@ -566,7 +566,7 @@ static void encode_clnpass(J2kT1Context *t1, int width, int height, int bandno,
         }
 }
 
-static void encode_cblk(J2kEncoderContext *s, J2kT1Context *t1, J2kCblk *cblk, J2kTile *tile,
+static void encode_cblk(Jpeg2000EncoderContext *s, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, Jpeg2000Tile *tile,
                         int width, int height, int bandpos, int lev)
 {
     int pass_t = 2, passno, x, y, max=0, nmsedec, bpno;
@@ -625,7 +625,7 @@ static void encode_cblk(J2kEncoderContext *s, J2kT1Context *t1, J2kCblk *cblk, J
 
 /* tier-2 routines: */
 
-static void putnumpasses(J2kEncoderContext *s, int n)
+static void putnumpasses(Jpeg2000EncoderContext *s, int n)
 {
     if (n == 1)
         put_num(s, 0, 1);
@@ -640,7 +640,7 @@ static void putnumpasses(J2kEncoderContext *s, int n)
 }
 
 
-static int encode_packet(J2kEncoderContext *s, J2kResLevel *rlevel, int precno,
+static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int precno,
                           uint8_t *expn, int numgbits)
 {
     int bandno, empty = 1;
@@ -667,8 +667,8 @@ static int encode_packet(J2kEncoderContext *s, J2kResLevel *rlevel, int precno,
     }
 
     for (bandno = 0; bandno < rlevel->nbands; bandno++){
-        J2kBand *band = rlevel->band + bandno;
-        J2kPrec *prec = band->prec + precno;
+        Jpeg2000Band *band = rlevel->band + bandno;
+        Jpeg2000Prec *prec = band->prec + precno;
         int yi, xi, pos;
         int cblknw = prec->xi1 - prec->xi0;
 
@@ -688,7 +688,7 @@ static int encode_packet(J2kEncoderContext *s, J2kResLevel *rlevel, int precno,
         for (pos=0, yi = prec->yi0; yi < prec->yi1; yi++){
             for (xi = prec->xi0; xi < prec->xi1; xi++, pos++){
                 int pad = 0, llen, length;
-                J2kCblk *cblk = band->cblk + yi * cblknw + xi;
+                Jpeg2000Cblk *cblk = band->cblk + yi * cblknw + xi;
 
                 if (s->buf_end - s->buf < 20) // approximately
                     return -1;
@@ -717,13 +717,13 @@ static int encode_packet(J2kEncoderContext *s, J2kResLevel *rlevel, int precno,
     }
     j2k_flush(s);
     for (bandno = 0; bandno < rlevel->nbands; bandno++){
-        J2kBand *band = rlevel->band + bandno;
-        J2kPrec *prec = band->prec + precno;
+        Jpeg2000Band *band = rlevel->band + bandno;
+        Jpeg2000Prec *prec = band->prec + precno;
         int yi, cblknw = prec->xi1 - prec->xi0;
         for (yi = prec->yi0; yi < prec->yi1; yi++){
             int xi;
             for (xi = prec->xi0; xi < prec->xi1; xi++){
-                J2kCblk *cblk = band->cblk + yi * cblknw + xi;
+                Jpeg2000Cblk *cblk = band->cblk + yi * cblknw + xi;
                 if (cblk->ninclpasses){
                     if (s->buf_end - s->buf < cblk->passes[cblk->ninclpasses-1].rate)
                         return -1;
@@ -735,18 +735,18 @@ static int encode_packet(J2kEncoderContext *s, J2kResLevel *rlevel, int precno,
     return 0;
 }
 
-static int encode_packets(J2kEncoderContext *s, J2kTile *tile, int tileno)
+static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
 {
     int compno, reslevelno, ret;
-    J2kCodingStyle *codsty = &s->codsty;
-    J2kQuantStyle  *qntsty = &s->qntsty;
+    Jpeg2000CodingStyle *codsty = &s->codsty;
+    Jpeg2000QuantStyle  *qntsty = &s->qntsty;
 
     av_log(s->avctx, AV_LOG_DEBUG, "tier2\n");
     // lay-rlevel-comp-pos progression
     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
         for (compno = 0; compno < s->ncomponents; compno++){
             int precno;
-            J2kResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
+            Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
             for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
                 if (ret = encode_packet(s, reslevel, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
                               qntsty->nguardbits))
@@ -758,7 +758,7 @@ static int encode_packets(J2kEncoderContext *s, J2kTile *tile, int tileno)
     return 0;
 }
 
-static int getcut(J2kCblk *cblk, int64_t lambda, int dwt_norm)
+static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm)
 {
     int passno, res = 0;
     for (passno = 0; passno < cblk->npasses; passno++){
@@ -776,23 +776,23 @@ static int getcut(J2kCblk *cblk, int64_t lambda, int dwt_norm)
     return res;
 }
 
-static void truncpasses(J2kEncoderContext *s, J2kTile *tile)
+static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
 {
     int compno, reslevelno, bandno, cblkno, lev;
-    J2kCodingStyle *codsty = &s->codsty;
+    Jpeg2000CodingStyle *codsty = &s->codsty;
 
     for (compno = 0; compno < s->ncomponents; compno++){
-        J2kComponent *comp = tile->comp + compno;
+        Jpeg2000Component *comp = tile->comp + compno;
 
         for (reslevelno = 0, lev = codsty->nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++, lev--){
-            J2kResLevel *reslevel = comp->reslevel + reslevelno;
+            Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
 
             for (bandno = 0; bandno < reslevel->nbands ; bandno++){
                 int bandpos = bandno + (reslevelno > 0);
-                J2kBand *band = reslevel->band + bandno;
+                Jpeg2000Band *band = reslevel->band + bandno;
 
                 for (cblkno = 0; cblkno < band->cblknx * band->cblkny; cblkno++){
-                    J2kCblk *cblk = band->cblk + cblkno;
+                    Jpeg2000Cblk *cblk = band->cblk + cblkno;
 
                     cblk->ninclpasses = getcut(cblk, s->lambda,
                             (int64_t)dwt_norms[codsty->transform][bandpos][lev] * (int64_t)band->stepsize >> 13);
@@ -802,13 +802,13 @@ static void truncpasses(J2kEncoderContext *s, J2kTile *tile)
     }
 }
 
-static int encode_tile(J2kEncoderContext *s, J2kTile *tile, int tileno)
+static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
 {
     int compno, reslevelno, bandno, ret;
-    J2kT1Context t1;
-    J2kCodingStyle *codsty = &s->codsty;
+    Jpeg2000T1Context t1;
+    Jpeg2000CodingStyle *codsty = &s->codsty;
     for (compno = 0; compno < s->ncomponents; compno++){
-        J2kComponent *comp = s->tile[tileno].comp + compno;
+        Jpeg2000Component *comp = s->tile[tileno].comp + compno;
 
         av_log(s->avctx, AV_LOG_DEBUG,"dwt\n");
         if (ret = ff_j2k_dwt_encode(&comp->dwt, comp->data))
@@ -816,10 +816,10 @@ static int encode_tile(J2kEncoderContext *s, J2kTile *tile, int tileno)
         av_log(s->avctx, AV_LOG_DEBUG,"after dwt -> tier1\n");
 
         for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
-            J2kResLevel *reslevel = comp->reslevel + reslevelno;
+            Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
 
             for (bandno = 0; bandno < reslevel->nbands ; bandno++){
-                J2kBand *band = reslevel->band + bandno;
+                Jpeg2000Band *band = reslevel->band + bandno;
                 int cblkx, cblky, cblkno=0, xx0, x0, xx1, y0, yy0, yy1, bandpos;
                 yy0 = bandno == 0 ? 0 : comp->reslevel[reslevelno-1].coord[1][1] - comp->reslevel[reslevelno-1].coord[1][0];
                 y0 = yy0;
@@ -880,14 +880,14 @@ static int encode_tile(J2kEncoderContext *s, J2kTile *tile, int tileno)
     return 0;
 }
 
-static void cleanup(J2kEncoderContext *s)
+static void cleanup(Jpeg2000EncoderContext *s)
 {
     int tileno, compno;
-    J2kCodingStyle *codsty = &s->codsty;
+    Jpeg2000CodingStyle *codsty = &s->codsty;
 
     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
         for (compno = 0; compno < s->ncomponents; compno++){
-            J2kComponent *comp = s->tile[tileno].comp + compno;
+            Jpeg2000Component *comp = s->tile[tileno].comp + compno;
             ff_j2k_cleanup(comp, codsty);
         }
         av_freep(&s->tile[tileno].comp);
@@ -895,11 +895,11 @@ static void cleanup(J2kEncoderContext *s)
     av_freep(&s->tile);
 }
 
-static void reinit(J2kEncoderContext *s)
+static void reinit(Jpeg2000EncoderContext *s)
 {
     int tileno, compno;
     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
-        J2kTile *tile = s->tile + tileno;
+        Jpeg2000Tile *tile = s->tile + tileno;
         for (compno = 0; compno < s->ncomponents; compno++)
             ff_j2k_reinit(tile->comp + compno, &s->codsty);
     }
@@ -909,7 +909,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                         const AVFrame *pict, int *got_packet)
 {
     int tileno, ret;
-    J2kEncoderContext *s = avctx->priv_data;
+    Jpeg2000EncoderContext *s = avctx->priv_data;
 
     if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*9 + FF_MIN_BUFFER_SIZE)) < 0)
         return ret;
@@ -962,9 +962,9 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 static av_cold int j2kenc_init(AVCodecContext *avctx)
 {
     int i, ret;
-    J2kEncoderContext *s = avctx->priv_data;
-    J2kCodingStyle *codsty = &s->codsty;
-    J2kQuantStyle  *qntsty = &s->qntsty;
+    Jpeg2000EncoderContext *s = avctx->priv_data;
+    Jpeg2000CodingStyle *codsty = &s->codsty;
+    Jpeg2000QuantStyle  *qntsty = &s->qntsty;
 
     s->avctx = avctx;
     av_log(s->avctx, AV_LOG_DEBUG, "init\n");
@@ -1020,7 +1020,7 @@ static av_cold int j2kenc_init(AVCodecContext *avctx)
 
 static int j2kenc_destroy(AVCodecContext *avctx)
 {
-    J2kEncoderContext *s = avctx->priv_data;
+    Jpeg2000EncoderContext *s = avctx->priv_data;
 
     cleanup(s);
     return 0;
@@ -1030,7 +1030,7 @@ AVCodec ff_j2k_encoder = {
     .name           = "j2k",
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_JPEG2000,
-    .priv_data_size = sizeof(J2kEncoderContext),
+    .priv_data_size = sizeof(Jpeg2000EncoderContext),
     .init           = j2kenc_init,
     .encode2        = encode_frame,
     .close          = j2kenc_destroy,