Message ID | 20240615031517.148911-1-owatanab@es.takushoku-u.ac.jp |
---|---|
State | New |
Headers | show |
Series | [FFmpeg-devel,1/2] avcodec/jpeg2000dec: Add support for placeholder passes, CAP, and CPF markers | expand |
Context | Check | Description |
---|---|---|
yinshiyou/make_loongarch64 | success | Make finished |
yinshiyou/make_fate_loongarch64 | success | Make fate finished |
andriy/make_x86 | success | Make finished |
andriy/make_fate_x86 | success | Make fate finished |
Hi Osamu, Can you provide the list of J2K reference codestreams that this code allows FFMPEG to support -- not including those already supported [1]? [1] https://github.com/FFmpeg/FFmpeg/blob/master/tests/fate/jpeg2000.mak Best, -- Pierre On Fri, Jun 14, 2024 at 8:15 PM Osamu Watanabe <owatanab@es.takushoku-u.ac.jp> wrote: > > Signed-off-by: Osamu Watanabe <owatanab@es.takushoku-u.ac.jp> > --- > libavcodec/jpeg2000.h | 10 + > libavcodec/jpeg2000dec.c | 454 ++++++++++++++++++++++++++++++------- > libavcodec/jpeg2000dec.h | 7 + > libavcodec/jpeg2000htdec.c | 225 ++++++++++-------- > libavcodec/jpeg2000htdec.h | 2 +- > 5 files changed, 518 insertions(+), 180 deletions(-) > > diff --git a/libavcodec/jpeg2000.h b/libavcodec/jpeg2000.h > index d004c08f10..93221d90ca 100644 > --- a/libavcodec/jpeg2000.h > +++ b/libavcodec/jpeg2000.h > @@ -37,12 +37,14 @@ > > enum Jpeg2000Markers { > JPEG2000_SOC = 0xff4f, // start of codestream > + JPEG2000_CAP = 0xff50, // extended capabilities > JPEG2000_SIZ = 0xff51, // image and tile size > JPEG2000_COD, // coding style default > JPEG2000_COC, // coding style component > JPEG2000_TLM = 0xff55, // tile-part length, main header > JPEG2000_PLM = 0xff57, // packet length, main header > JPEG2000_PLT, // packet length, tile-part header > + JPEG2000_CPF, // corresponding profile > JPEG2000_QCD = 0xff5c, // quantization default > JPEG2000_QCC, // quantization component > JPEG2000_RGN, // region of interest > @@ -58,6 +60,12 @@ enum Jpeg2000Markers { > JPEG2000_EOC = 0xffd9, // end of codestream > }; > > +enum JPEG2000_Ccap15_b14_15_params { > + HTJ2K_HTONLY = 0, // HTONLY, bit 14 and 15 are 0 > + HTJ2K_HTDECLARED, // HTDECLARED, bit 14 = 1 and bit 15 = 0 > + HTJ2K_MIXED = 3, // MIXED, bit 14 and 15 are 1 > +}; > + > #define JPEG2000_SOP_FIXED_BYTES 0xFF910004 > #define JPEG2000_SOP_BYTE_LENGTH 6 > > @@ -192,6 +200,8 @@ typedef struct Jpeg2000Cblk { > /* specific to HT code-blocks */ > int zbp; > int pass_lengths[2]; > + uint8_t modes; // copy of SPcod/SPcoc field to parse HT-MIXED mode > + uint8_t ht_plhd; // are we looking for HT placeholder passes? > } Jpeg2000Cblk; // code block > > typedef struct Jpeg2000Prec { > diff --git a/libavcodec/jpeg2000dec.c b/libavcodec/jpeg2000dec.c > index d15502a527..d299c67cc7 100644 > --- a/libavcodec/jpeg2000dec.c > +++ b/libavcodec/jpeg2000dec.c > @@ -54,6 +54,15 @@ > #define HAD_COC 0x01 > #define HAD_QCC 0x02 > > +// Values of flag for placeholder passes > +enum HT_PLHD_STATUS { > + HT_PLHD_OFF, > + HT_PLHD_ON > +}; > + > +#define HT_MIXED 0x80 // bit 7 of SPcod/SPcoc > + > + > /* get_bits functions for JPEG2000 packet bitstream > * It is a get_bit function with a bit-stuffing routine. If the value of the > * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB. > @@ -382,6 +391,9 @@ static int get_siz(Jpeg2000DecoderContext *s) > } else if (ncomponents == 1 && s->precision == 8) { > s->avctx->pix_fmt = AV_PIX_FMT_GRAY8; > i = 0; > + } else if (ncomponents == 1 && s->precision == 12) { > + s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE; > + i = 0; > } > } > > @@ -408,6 +420,73 @@ static int get_siz(Jpeg2000DecoderContext *s) > s->avctx->bits_per_raw_sample = s->precision; > return 0; > } > +/* get extended capabilities (CAP) marker segment */ > +static int get_cap(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c) > +{ > + uint32_t Pcap; > + uint16_t Ccap_i[32] = { 0 }; > + uint16_t Ccap_15; > + uint8_t P; > + > + if (bytestream2_get_bytes_left(&s->g) < 6) { > + av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for CAP\n"); > + return AVERROR_INVALIDDATA; > + } > + > + Pcap = bytestream2_get_be32u(&s->g); > + s->isHT = (Pcap >> (31 - (15 - 1))) & 1; > + for (int i = 0; i < 32; i++) { > + if ((Pcap >> (31 - i)) & 1) > + Ccap_i[i] = bytestream2_get_be16u(&s->g); > + } > + Ccap_15 = Ccap_i[14]; > + if (s->isHT == 1) { > + av_log(s->avctx, AV_LOG_INFO, "This is an HTJ2K codestream.\n"); > + // Bits 14-15 > + switch ((Ccap_15 >> 14) & 0x3) { > + case 0x3: > + s->Ccap15_b14_15 = HTJ2K_MIXED; > + break; > + case 0x1: > + s->Ccap15_b14_15 = HTJ2K_HTDECLARED; > + break; > + case 0x0: > + s->Ccap15_b14_15 = HTJ2K_HTONLY; > + break; > + default: > + av_log(s->avctx, AV_LOG_ERROR, "Unknown CCap value.\n"); > + return AVERROR(EINVAL); > + break; > + } > + // Bit 13 > + if ((Ccap_15 >> 13) & 1) { > + av_log(s->avctx, AV_LOG_ERROR, "MULTIHT set is not supported.\n"); > + return AVERROR_PATCHWELCOME; > + } > + // Bit 12 > + s->Ccap15_b12 = (Ccap_15 >> 12) & 1; > + // Bit 11 > + s->Ccap15_b11 = (Ccap_15 >> 11) & 1; > + // Bit 5 > + s->Ccap15_b05 = (Ccap_15 >> 5) & 1; > + // Bit 0-4 > + P = Ccap_15 & 0x1F; > + if (!P) > + s->HT_MAGB = 8; > + else if (P < 20) > + s->HT_MAGB = P + 8; > + else if (P < 31) > + s->HT_MAGB = 4 * (P - 19) + 27; > + else > + s->HT_MAGB = 74; > + > + if (s->HT_MAGB > 31) { > + av_log(s->avctx, AV_LOG_ERROR, "Available internal precision is exceeded (MAGB> 31).\n"); > + return AVERROR_PATCHWELCOME; > + } > + } > + return 0; > +} > > /* get common part for COD and COC segments */ > static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c) > @@ -802,6 +881,15 @@ static int read_crg(Jpeg2000DecoderContext *s, int n) > bytestream2_skip(&s->g, n - 2); > return 0; > } > + > +static int read_cpf(Jpeg2000DecoderContext *s, int n) > +{ > + if (bytestream2_get_bytes_left(&s->g) < (n - 2)) > + return AVERROR_INVALIDDATA; > + bytestream2_skip(&s->g, n - 2); > + return 0; > +} > + > /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1 > * Used to know the number of tile parts and lengths. > * There may be multiple TLMs in the header. > @@ -965,6 +1053,10 @@ static int init_tile(Jpeg2000DecoderContext *s, int tileno) > comp->roi_shift = s->roi_shift[compno]; > if (!codsty->init) > return AVERROR_INVALIDDATA; > + if (s->isHT && (!s->Ccap15_b05) && (!codsty->transform)) > + av_log(s->avctx, AV_LOG_WARNING, "Transformation = 0 (lossy DWT) is found in HTREV HT set\n"); > + if (s->isHT && s->Ccap15_b14_15 != (codsty->cblk_style >> 6) && s->Ccap15_b14_15 != HTJ2K_HTONLY) > + av_log(s->avctx, AV_LOG_WARNING, "SPcod/SPcoc value does not match bit 14-15 values of Ccap15\n"); > if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty, > s->cbps[compno], s->cdx[compno], > s->cdy[compno], s->avctx)) > @@ -1067,100 +1159,275 @@ static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, > int incl, newpasses, llen; > void *tmp; > > - if (cblk->npasses) > - incl = get_bits(s, 1); > - else > + if (!cblk->incl) { > + incl = 0; > + cblk->modes = codsty->cblk_style; > + if (cblk->modes >= JPEG2000_CTSY_HTJ2K_F) > + cblk->ht_plhd = HT_PLHD_ON; > + if (layno > 0) > + incl = tag_tree_decode(s, prec->cblkincl + cblkno, 0 + 1) == 0; > incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno; > - if (!incl) > - continue; > - else if (incl < 0) > - return incl; > - > - if (!cblk->npasses) { > - int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100); > - int v = expn[bandno] + numgbits - 1 - zbp; > > - if (v < 0 || v > 30) { > - av_log(s->avctx, AV_LOG_ERROR, > - "nonzerobits %d invalid or unsupported\n", v); > - return AVERROR_INVALIDDATA; > + if (incl) { > + int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100); > + int v = expn[bandno] + numgbits - 1 - (zbp - tile->comp->roi_shift); > + if (v < 0 || v > 30) { > + av_log(s->avctx, AV_LOG_ERROR, > + "nonzerobits %d invalid or unsupported\n", v); > + return AVERROR_INVALIDDATA; > + } > + cblk->incl = 1; > + cblk->nonzerobits = v; > + cblk->zbp = zbp; > + cblk->lblock = 3; > } > - cblk->zbp = zbp; > - cblk->nonzerobits = v; > - } > - if ((newpasses = getnpasses(s)) < 0) > - return newpasses; > - av_assert2(newpasses > 0); > - if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) { > - avpriv_request_sample(s->avctx, "Too many passes"); > - return AVERROR_PATCHWELCOME; > - } > - if ((llen = getlblockinc(s)) < 0) > - return llen; > - if (cblk->lblock + llen + av_log2(newpasses) > 16) { > - avpriv_request_sample(s->avctx, > - "Block with length beyond 16 bits"); > - return AVERROR_PATCHWELCOME; > + } else { > + incl = get_bits(s, 1); > } > > - cblk->lblock += llen; > - > - cblk->nb_lengthinc = 0; > - cblk->nb_terminationsinc = 0; > - av_free(cblk->lengthinc); > - cblk->lengthinc = av_calloc(newpasses, sizeof(*cblk->lengthinc)); > - if (!cblk->lengthinc) > - return AVERROR(ENOMEM); > - tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start)); > - if (!tmp) > - return AVERROR(ENOMEM); > - cblk->data_start = tmp; > - do { > - int newpasses1 = 0; > - > - while (newpasses1 < newpasses) { > - newpasses1 ++; > - if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) { > - cblk->nb_terminationsinc ++; > - break; > + if (incl) { > + uint8_t bypass_term_threshold = 0; > + uint8_t bits_to_read = 0; > + uint32_t segment_bytes = 0; > + int32_t segment_passes = 0; > + uint8_t next_segment_passes = 0; > + int32_t href_passes, pass_bound; > + uint32_t tmp_length = 0; > + > + if ((newpasses = getnpasses(s)) <= 0) > + return newpasses; > + if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) { > + avpriv_request_sample(s->avctx, "Too many passes"); > + return AVERROR_PATCHWELCOME; > + } > + if ((llen = getlblockinc(s)) < 0) > + return llen; > + if (cblk->lblock + llen + av_log2(newpasses) > 16) { > + avpriv_request_sample(s->avctx, > + "Block with length beyond 16 bits"); > + return AVERROR_PATCHWELCOME; > + } > + cblk->nb_lengthinc = 0; > + cblk->nb_terminationsinc = 0; > + av_free(cblk->lengthinc); > + cblk->lengthinc = av_calloc(newpasses, sizeof(*cblk->lengthinc)); > + if (!cblk->lengthinc) > + return AVERROR(ENOMEM); > + tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, > + sizeof(*cblk->data_start)); > + if (!tmp) > + return AVERROR(ENOMEM); > + cblk->data_start = tmp; > + cblk->lblock += llen; > + > + if (cblk->ht_plhd) { > + href_passes = (cblk->npasses + newpasses - 1) % 3; > + segment_passes = newpasses - href_passes; > + pass_bound = 2; > + bits_to_read = cblk->lblock; > + if (segment_passes < 1) { > + // No possible HT Cleanup pass here; may have placeholder passes > + // or an original J2K block bit-stream (in MIXED mode). > + segment_passes = newpasses; > + while (pass_bound <= segment_passes) { > + bits_to_read++; > + pass_bound += pass_bound; > + } > + segment_bytes = get_bits(s, bits_to_read); > + if (segment_bytes) { > + if (cblk->modes & HT_MIXED) { > + cblk->ht_plhd = HT_PLHD_OFF; > + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); > + } > + else { > + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); > + } > + } > + } else { > + while (pass_bound <= segment_passes) { > + bits_to_read++; > + pass_bound += pass_bound; > + } > + segment_bytes = get_bits(s, bits_to_read); > + if (segment_bytes) { > + // No more placeholder passes > + if (!(cblk->modes & HT_MIXED)) { > + // Must be the first HT Cleanup pass > + if (segment_bytes < 2) > + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); > + next_segment_passes = 2; > + cblk->ht_plhd = HT_PLHD_OFF; > + // Write length information for HT CleanUp segment > + cblk->pass_lengths[0] = segment_bytes; > + } else if (cblk->lblock > 3 && segment_bytes > 1 > + && (segment_bytes >> (bits_to_read - 1)) == 0) { > + // Must be the first HT Cleanup pass, since length MSB is 0 > + next_segment_passes = 2; > + cblk->ht_plhd = HT_PLHD_OFF; > + // Write length information for HT CleanUp segment > + cblk->pass_lengths[0] = segment_bytes; > + } else { > + // Must have an original (non-HT) block coding pass > + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); > + cblk->ht_plhd = HT_PLHD_OFF; > + segment_passes = newpasses; > + while (pass_bound <= segment_passes) { > + bits_to_read++; > + pass_bound += pass_bound; > + segment_bytes <<= 1; > + segment_bytes += get_bits(s, 1); > + } > + } > + } else { > + // Probably parsing placeholder passes, but we need to read an > + // extra length bit to verify this, since prior to the first > + // HT Cleanup pass, the number of length bits read for a > + // contributing code-block is dependent on the number of passes > + // being included, as if it were a non-HT code-block. > + segment_passes = newpasses; > + if (pass_bound <= segment_passes) { > + while (1) { > + bits_to_read++; > + pass_bound += pass_bound; > + segment_bytes <<= 1; > + segment_bytes += get_bits(s, 1); > + if (pass_bound > segment_passes) > + break; > + } > + if (segment_bytes) { > + if (cblk->modes & HT_MIXED) { > + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); > + cblk->ht_plhd = HT_PLHD_OFF; > + } else { > + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); > + } > + } > + } > + } > } > + } else if (cblk->modes & JPEG2000_CTSY_HTJ2K_F) { > + // Quality layer commences with a non-initial HT coding pass > + if(bits_to_read != 0) > + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); > + segment_passes = cblk->npasses % 3; > + if (segment_passes == 0) { > + // newpasses is a HT Cleanup pass; next segment has refinement passes > + segment_passes = 1; > + next_segment_passes = 2; > + if (segment_bytes == 1) > + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); > + } else { > + // newpasses = 1 means npasses is HT SigProp; 2 means newpasses is > + // HT MagRef pass > + segment_passes = newpasses > 1 ? 3 - segment_passes : 1; > + next_segment_passes = 1; > + bits_to_read = av_log2(segment_passes); > + } > + bits_to_read = (uint8_t) (bits_to_read + cblk->lblock); > + segment_bytes = get_bits(s, bits_to_read); > + // Write length information for HT Refinment segment > + cblk->pass_lengths[1] += segment_bytes; > + } else if (!(cblk->modes & (JPEG2000_CBLK_TERMALL | JPEG2000_CBLK_BYPASS))) { > + // Common case for non-HT code-blocks; we have only one segment > + bits_to_read = (uint8_t) cblk->lblock + av_log2((uint8_t) newpasses); > + segment_bytes = get_bits(s, bits_to_read); > + segment_passes = newpasses; > + } else if (cblk->modes & JPEG2000_CBLK_TERMALL) { > + // RESTART MODE > + bits_to_read = cblk->lblock; > + segment_bytes = get_bits(s, bits_to_read); > + segment_passes = 1; > + next_segment_passes = 1; > + cblk->nb_terminationsinc++; > + } else { > + // BYPASS MODE > + bypass_term_threshold = 10; > + if(bits_to_read != 0) > + av_log(s->avctx, AV_LOG_WARNING, "Length information for a codeblock is invalid\n"); > + if (cblk->npasses < bypass_term_threshold) { > + // May have from 1 to 10 uninterrupted passes before 1st RAW SigProp > + segment_passes = bypass_term_threshold - cblk->npasses; > + if (segment_passes > newpasses) > + segment_passes = newpasses; > + while ((2 << bits_to_read) <= segment_passes) > + bits_to_read++; > + next_segment_passes = 2; > + } else if ((cblk->npasses - bypass_term_threshold) % 3 < 2) { > + // 0 means newpasses is a RAW SigProp; 1 means newpasses is a RAW MagRef pass > + segment_passes = newpasses > 1 ? 2 - (cblk->npasses - bypass_term_threshold) % 3 : 1; > + bits_to_read = av_log2(segment_passes); > + next_segment_passes = 1; > + } else { > + // newpasses is an isolated Cleanup pass that precedes a RAW SigProp pass > + segment_passes = 1; > + next_segment_passes = 2; > + } > + bits_to_read = (uint8_t) (bits_to_read + cblk->lblock); > + segment_bytes = get_bits(s, bits_to_read); > } > - > - if (newpasses > 1 && (codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F)) { > - // Retrieve pass lengths for each pass > - int href_passes = (cblk->npasses + newpasses - 1) % 3; > - int eb = av_log2(newpasses - href_passes); > - int extra_bit = newpasses > 2 ? 1 : 0; > - if ((ret = get_bits(s, llen + eb + 3)) < 0) > - return ret; > - cblk->pass_lengths[0] = ret; > - if ((ret = get_bits(s, llen + 3 + extra_bit)) < 0) > - return ret; > - cblk->pass_lengths[1] = ret; > - ret = cblk->pass_lengths[0] + cblk->pass_lengths[1]; > + // Update cblk->npasses and write length information > + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); > + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; > + > + if ((cblk->modes & JPEG2000_CTSY_HTJ2K_F) && cblk->ht_plhd == HT_PLHD_OFF) { > + newpasses -= (uint8_t) segment_passes; > + while (newpasses > 0) { > + segment_passes = newpasses > 1 ? next_segment_passes : 1; > + next_segment_passes = (uint8_t) (3 - next_segment_passes); > + bits_to_read = (uint8_t) (cblk->lblock + av_log2(segment_passes)); > + segment_bytes = get_bits(s, bits_to_read); > + newpasses -= (uint8_t) (segment_passes); > + // This is a FAST Refinement pass > + // Write length information for HT Refinement segment > + cblk->pass_lengths[1] += segment_bytes; > + // Update cblk->npasses and write length information > + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); > + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; > + } > } else { > - if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0) > - return ret; > - cblk->pass_lengths[0] = ret; > + newpasses -= (uint8_t) (segment_passes); > + while (newpasses > 0) { > + if (bypass_term_threshold != 0) { > + segment_passes = newpasses > 1 ? next_segment_passes : 1; > + next_segment_passes = (uint8_t) (3 - next_segment_passes); > + bits_to_read = (uint8_t) (cblk->lblock + av_log2(segment_passes)); > + } else { > + if ((cblk->modes & JPEG2000_CBLK_TERMALL) == 0) > + av_log(s->avctx, AV_LOG_WARNING, "Corrupted packet header is found.\n"); > + segment_passes = 1; > + bits_to_read = cblk->lblock; > + } > + segment_bytes = get_bits(s, bits_to_read); > + newpasses -= (uint8_t) (segment_passes); > + > + // Update cblk->npasses and write length information > + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); > + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; > + cblk->nb_terminationsinc++; > + } > } > - if (ret > cblk->data_allocated) { > - size_t new_size = FFMAX(2*cblk->data_allocated, ret); > + > + for (int i = 0; i < cblk->nb_lengthinc; ++i) > + tmp_length = (tmp_length < cblk->lengthinc[i]) ? cblk->lengthinc[i] : tmp_length; > + > + if (tmp_length > cblk->data_allocated) { > + size_t new_size = FFMAX(2 * cblk->data_allocated, tmp_length); > void *new = av_realloc(cblk->data, new_size); > if (new) { > cblk->data = new; > cblk->data_allocated = new_size; > } > } > - if (ret > cblk->data_allocated) { > + if (tmp_length > cblk->data_allocated) { > avpriv_request_sample(s->avctx, > "Block with lengthinc greater than %"SIZE_SPECIFIER"", > cblk->data_allocated); > return AVERROR_PATCHWELCOME; > } > - cblk->lengthinc[cblk->nb_lengthinc++] = ret; > - cblk->npasses += newpasses1; > - newpasses -= newpasses1; > - } while(newpasses); > + } else { > + // This codeblock has no contribution to the current packet > + continue; > + } > } > } > jpeg2000_flush(s); > @@ -1695,7 +1962,7 @@ static int decode_cblk(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *cod > Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, > int width, int height, int bandpos, uint8_t roi_shift) > { > - int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1 + roi_shift; > + int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1; > int pass_cnt = 0; > int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC; > int term_cnt = 0; > @@ -1909,7 +2176,7 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile > Jpeg2000Band *band = rlevel->band + bandno; > int cblkno = 0, bandpos; > /* See Rec. ITU-T T.800, Equation E-2 */ > - int magp = quantsty->expn[subbandno] + quantsty->nguardbits - 1; > + int M_b = quantsty->expn[subbandno] + quantsty->nguardbits - 1; > > bandpos = bandno + (reslevelno > 0); > > @@ -1917,8 +2184,8 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile > band->coord[1][0] == band->coord[1][1]) > continue; > > - if ((codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) && magp >= 31) { > - avpriv_request_sample(s->avctx, "JPEG2000_CTSY_HTJ2K_F and magp >= 31"); > + if ((codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) && M_b >= 31) { > + avpriv_request_sample(s->avctx, "JPEG2000_CTSY_HTJ2K_F and M_b >= 31"); > return AVERROR_PATCHWELCOME; > } > > @@ -1935,11 +2202,11 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile > > Jpeg2000Cblk *cblk = prec->cblk + cblkno; > > - if (codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) > + if (cblk->modes & JPEG2000_CTSY_HTJ2K_F) > ret = ff_jpeg2000_decode_htj2k(s, codsty, &t1, cblk, > cblk->coord[0][1] - cblk->coord[0][0], > cblk->coord[1][1] - cblk->coord[1][0], > - magp, comp->roi_shift); > + M_b, comp->roi_shift); > else > ret = decode_cblk(s, codsty, &t1, cblk, > cblk->coord[0][1] - cblk->coord[0][0], > @@ -2178,22 +2445,42 @@ static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s) > if (!s->tile) > s->numXtiles = s->numYtiles = 0; > break; > + case JPEG2000_CAP: > + if (!s->ncomponents) { > + av_log(s->avctx, AV_LOG_WARNING, "CAP marker segment shall come after SIZ\n"); > + } > + ret = get_cap(s, codsty); > + break; > case JPEG2000_COC: > + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) > + av_log(s->avctx, AV_LOG_WARNING, "COC marker is found in HOMOGENEOUS HT set\n"); > ret = get_coc(s, codsty, properties); > break; > case JPEG2000_COD: > + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) > + av_log(s->avctx, AV_LOG_WARNING, "COD marker is found in HOMOGENEOUS HT set\n"); > ret = get_cod(s, codsty, properties); > break; > case JPEG2000_RGN: > + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) > + av_log(s->avctx, AV_LOG_WARNING, "RGB marker is found in HOMOGENEOUS HT set\n"); > ret = get_rgn(s, len); > + if ((!s->Ccap15_b12) && s->isHT) > + av_log(s->avctx, AV_LOG_WARNING, "RGN marker is found in RGNFREE HT set\n"); > break; > case JPEG2000_QCC: > + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) > + av_log(s->avctx, AV_LOG_WARNING, "QCC marker is found in HOMOGENEOUS HT set\n"); > ret = get_qcc(s, len, qntsty, properties); > break; > case JPEG2000_QCD: > + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) > + av_log(s->avctx, AV_LOG_WARNING, "QCD marker is found in HOMOGENEOUS HT set\n"); > ret = get_qcd(s, len, qntsty, properties); > break; > case JPEG2000_POC: > + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) > + av_log(s->avctx, AV_LOG_WARNING, "POC marker is found in HOMOGENEOUS HT set\n"); > ret = get_poc(s, len, poc); > break; > case JPEG2000_SOT: > @@ -2243,9 +2530,14 @@ static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s) > "Cannot have both PPT and PPM marker.\n"); > return AVERROR_INVALIDDATA; > } > - > + if ((!s->Ccap15_b11) && s->isHT) > + av_log(s->avctx, AV_LOG_WARNING, "PPT marker is found in HOMOGENEOUS HT set\n"); > ret = get_ppt(s, len); > break; > + case JPEG2000_CPF: > + // Corresponding profile marker > + ret = read_cpf(s, len); > + break; > default: > av_log(s->avctx, AV_LOG_ERROR, > "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n", > diff --git a/libavcodec/jpeg2000dec.h b/libavcodec/jpeg2000dec.h > index d0ca6e7a79..326a572722 100644 > --- a/libavcodec/jpeg2000dec.h > +++ b/libavcodec/jpeg2000dec.h > @@ -112,6 +112,13 @@ typedef struct Jpeg2000DecoderContext { > Jpeg2000Tile *tile; > Jpeg2000DSPContext dsp; > > + uint8_t isHT; // HTJ2K? > + uint8_t Ccap15_b14_15; // HTONLY(= 0) or HTDECLARED(= 1) or MIXED(= 3) ? > + uint8_t Ccap15_b12; // RGNFREE(= 0) or RGN(= 1)? > + uint8_t Ccap15_b11; // HOMOGENEOUS(= 0) or HETEROGENEOUS(= 1) ? > + uint8_t Ccap15_b05; // HTREV(= 0) or HTIRV(= 1) ? > + uint8_t HT_MAGB; // MAGB value > + > /*options parameters*/ > int reduction_factor; > } Jpeg2000DecoderContext; > diff --git a/libavcodec/jpeg2000htdec.c b/libavcodec/jpeg2000htdec.c > index eba0936089..beb4a386b0 100644 > --- a/libavcodec/jpeg2000htdec.c > +++ b/libavcodec/jpeg2000htdec.c > @@ -122,7 +122,7 @@ static void jpeg2000_init_mel(StateVars *s, uint32_t Pcup) > > static void jpeg2000_init_mag_ref(StateVars *s, uint32_t Lref) > { > - s->pos = Lref - 2; > + s->pos = Lref - 1; > s->bits = 0; > s->last = 0xFF; > s->tmp = 0; > @@ -145,9 +145,10 @@ static void jpeg2000_init_mel_decoder(MelDecoderState *mel_state) > static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *array) > { > uint64_t tmp = 0; > - int32_t position = buffer->pos - 4; > uint32_t new_bits = 32; > > + buffer->last = array[buffer->pos + 1]; > + > if (buffer->bits_left >= 32) > return 0; // enough data, no need to pull in more bits > > @@ -157,9 +158,24 @@ static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *ar > * the bottom most bits. > */ > > - for(int i = FFMAX(0, position + 1); i <= buffer->pos + 1; i++) > - tmp = 256*tmp + array[i]; > - > + if (buffer->pos >= 3) { // Common case; we have at least 4 bytes available > + tmp = array[buffer->pos - 3]; > + tmp = (tmp << 8) | array[buffer->pos - 2]; > + tmp = (tmp << 8) | array[buffer->pos - 1]; > + tmp = (tmp << 8) | array[buffer->pos]; > + tmp = (tmp << 8) | buffer->last; // For stuffing bit detection > + buffer->pos -= 4; > + } else { > + if (buffer->pos >= 2) > + tmp = array[buffer->pos - 2]; > + if (buffer->pos >= 1) > + tmp = (tmp << 8) | array[buffer->pos - 1]; > + if (buffer->pos >= 0) > + tmp = (tmp << 8) | array[buffer->pos]; > + buffer->pos = 0; > + tmp = (tmp << 8) | buffer->last; // For stuffing bit detection > + } > + // Now remove any stuffing bits, shifting things down as we go > if ((tmp & 0x7FFF000000) > 0x7F8F000000) { > tmp &= 0x7FFFFFFFFF; > new_bits--; > @@ -176,13 +192,11 @@ static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *ar > tmp = (tmp & 0x0000007FFF) + ((tmp & 0xFFFFFF0000) >> 1); > new_bits--; > } > - > - tmp >>= 8; // Remove temporary byte loaded > + tmp >>= 8; // Shifts away the extra byte we imported > > /* Add bits to the MSB of the bit buffer */ > buffer->bit_buf |= tmp << buffer->bits_left; > buffer->bits_left += new_bits; > - buffer->pos = FFMAX(0, position); > return 0; > } > > @@ -406,6 +420,7 @@ static void recover_mag_sgn(StateVars *mag_sgn, uint8_t pos, uint16_t q, int32_t > E[n] = 32 - ff_clz(v[pos][i] | 1); > mu_n[n] = (v[pos][i] >> 1) + 1; > mu_n[n] <<= pLSB; > + mu_n[n] |= (1 << (pLSB - 1)); // Add 0.5 (reconstruction parameter = 1/2) > mu_n[n] |= ((uint32_t) (v[pos][i] & 1)) << 31; // sign bit. > } > } > @@ -414,7 +429,7 @@ static void recover_mag_sgn(StateVars *mag_sgn, uint8_t pos, uint16_t q, int32_t > static int jpeg2000_import_bit(StateVars *stream, const uint8_t *array, uint32_t length) > { > int cond = stream->pos < length; > - int pos = FFMIN(stream->pos, length); > + int pos = FFMIN(stream->pos, length - 1); > if (stream->bits == 0) { > stream->bits = (stream->tmp == 0xFF) ? 7 : 8; > stream->pos += cond; > @@ -426,14 +441,22 @@ static int jpeg2000_import_bit(StateVars *stream, const uint8_t *array, uint32_t > > static int jpeg2000_peek_bit(StateVars *stream, const uint8_t *array, uint32_t length) > { > + uint8_t bit; > + > if (stream->bits == 0) { > - int cond = stream->pos < length; > - int pos = FFMIN(stream->pos, length); > - stream->bits = (stream->tmp == 0xFF) ? 7 : 8; > - stream->pos += cond; > - stream->tmp = cond ? array[pos] : 0xFF; > + stream->bits = (stream->last == 0xFF) ? 7 : 8; > + if (stream->pos < length) { > + stream->tmp = array[stream->pos]; > + stream->pos++; > + } else { > + stream->tmp = 0; > + } > + stream->last = stream->tmp; > } > - return (stream->tmp >> stream->bits) & 1; > + bit = stream->tmp & 1; > + stream->tmp >>= 1; > + stream->bits--; > + return bit; > } > > static int jpeg2000_decode_mel_sym(MelDecoderState *mel_state, > @@ -994,66 +1017,63 @@ static void jpeg2000_calc_mbr(uint8_t *mbr, const uint16_t i, const uint16_t j, > const uint32_t mbr_info, uint8_t causal_cond, > uint8_t *block_states, int stride) > { > - int local_mbr = 0; > - > - local_mbr |= jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SIGMA, block_states); > - local_mbr |= jpeg2000_get_state(i - 1, j + 0, stride, HT_SHIFT_SIGMA, block_states); > - local_mbr |= jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_SIGMA, block_states); > - > - local_mbr |= jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_SIGMA, block_states); > - local_mbr |= jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_SIGMA, block_states); > - > - local_mbr |= jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; > - local_mbr |= jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; > - local_mbr |= jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; > - > - local_mbr |= jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_REF, block_states) * > - jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SCAN, block_states); > - local_mbr |= jpeg2000_get_state(i - 1, j + 0, stride, HT_SHIFT_REF, block_states) * > - jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SCAN, block_states); > - local_mbr |= jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_REF, block_states) * > - jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_SCAN, block_states); > - > - local_mbr |= jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_REF, block_states) * > - jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_SCAN, block_states); > - local_mbr |= jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_REF, block_states) * > - jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_SCAN, block_states); > - > - local_mbr |= jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_REF, block_states) * > - jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_SCAN, block_states) * causal_cond; > - local_mbr |= jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_REF, block_states) * > - jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_SCAN, block_states) * causal_cond; > - local_mbr |= jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_REF, block_states) * > - jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_SCAN, block_states) * causal_cond; > - > - *mbr |= local_mbr; > + uint8_t *state_p0 = block_states + i * stride + j; > + uint8_t *state_p1 = block_states + (i + 1) * stride + j; > + uint8_t *state_p2 = block_states + (i + 2) * stride + j; > + > + uint8_t mbr0 = state_p0[0] | state_p0[1] | state_p0[2]; > + uint8_t mbr1 = state_p1[0] | state_p1[2]; > + uint8_t mbr2 = state_p2[0] | state_p2[1] | state_p2[2]; > + *mbr = mbr0 | mbr1 | (mbr2 & causal_cond); > + *mbr |= (mbr0 >> HT_SHIFT_REF) & (mbr0 >> HT_SHIFT_SCAN); > + *mbr |= (mbr1 >> HT_SHIFT_REF) & (mbr1 >> HT_SHIFT_SCAN); > + *mbr |= (mbr2 >> HT_SHIFT_REF) & (mbr2 >> HT_SHIFT_SCAN) & causal_cond; > + *mbr &= 1; > } > > static void jpeg2000_process_stripes_block(StateVars *sig_prop, int i_s, int j_s, > int width, int height, int stride, int pLSB, > int32_t *sample_buf, uint8_t *block_states, > - uint8_t *magref_segment, uint32_t magref_length) > + uint8_t *magref_segment, uint32_t magref_length, > + uint8_t is_causal) > { > for (int j = j_s; j < j_s + width; j++) { > uint32_t mbr_info = 0; > for (int i = i_s; i < i_s + height; i++) { > - int modify_state, cond; > + int modify_state; > uint8_t bit; > - uint8_t causal_cond = i != (i_s + height - 1); > + uint8_t causal_cond = (is_causal == 0) || (i != (i_s + height - 1)); > int32_t *sp = &sample_buf[j + (i * (stride))]; > uint8_t mbr = 0; > > - if (jpeg2000_get_state(i, j, stride - 2, HT_SHIFT_SIGMA, block_states) == 0) > + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) == 0) > jpeg2000_calc_mbr(&mbr, i, j, mbr_info & 0x1EF, causal_cond, block_states, stride); > mbr_info >>= 3; > - cond = mbr != 0; > - bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); > - *sp |= (bit * cond) << pLSB; > - sig_prop->bits -= cond; > - modify_state = (((1 << HT_SHIFT_REF_IND) | (1 << HT_SHIFT_REF)) * cond) | 1 << HT_SHIFT_SCAN; > + > + modify_state = block_states[(i + 1) * stride + (j + 1)]; > + modify_state |= 1 << HT_SHIFT_SCAN; > + if (mbr != 0) { > + modify_state |= 1 << HT_SHIFT_REF_IND; > + bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); > + modify_state |= bit << HT_SHIFT_REF; > + *sp |= bit << pLSB; > + *sp |= bit << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) > + } > jpeg2000_modify_state(i, j, stride, modify_state, block_states); > } > } > + // decode sign > + for (int j = j_s; j < j_s + width; j++) { > + for (int i = i_s; i < i_s + height; i++) { > + uint8_t bit; > + int32_t *sp = &sample_buf[j + (i * (stride))]; > + uint8_t *state_p = block_states + (i + 1) * stride + (j + 1); > + if ((state_p[0] >> HT_SHIFT_REF) & 1) { > + bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); > + *sp |= (int32_t)bit << 31; > + } > + } > + } > } > > /** > @@ -1074,6 +1094,7 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, > > int last_width; > uint16_t i = 0, j = 0; > + uint8_t is_causal = cblk->modes & JPEG2000_CBLK_VSC; > > jpeg2000_init_zero(&sp_dec); > > @@ -1082,14 +1103,14 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, > for (int n2 = 0; n2 < num_h_stripe; n2++) { > jpeg2000_process_stripes_block(&sp_dec, i, j, b_width, b_height, stride, > pLSB, sample_buf, block_states, magref_segment, > - magref_length); > + magref_length, is_causal); > j += 4; > } > last_width = width % 4; > if (last_width) > jpeg2000_process_stripes_block(&sp_dec, i, j, last_width, b_height, stride, > pLSB, sample_buf, block_states, magref_segment, > - magref_length); > + magref_length, is_causal); > i += 4; > } > > @@ -1099,20 +1120,20 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, > for (int n2 = 0; n2 < num_h_stripe; n2++) { > jpeg2000_process_stripes_block(&sp_dec, i, j, b_width, b_height, stride, > pLSB, sample_buf, block_states, magref_segment, > - magref_length); > + magref_length, is_causal); > j += 4; > } > last_width = width % 4; > if (last_width) > jpeg2000_process_stripes_block(&sp_dec, i, j, last_width, b_height, stride, > pLSB, sample_buf, block_states, magref_segment, > - magref_length); > + magref_length, is_causal); > } > > /** > * See procedure decodeSigPropMag at Rec. ITU-T T.814, 7.5. > */ > -static int > +static void > jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int stride, > uint8_t *magref_segment,uint32_t magref_length, > uint8_t pLSB, int32_t *sample_buf, uint8_t *block_states) > @@ -1123,7 +1144,8 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int > uint16_t height = 4; > uint16_t i_start = 0; > int32_t *sp; > - > + int32_t bit; > + int32_t tmp; > jpeg2000_init_mag_ref(&mag_ref, magref_length); > > for (int n1 = 0; n1 < num_v_stripe; n1++) { > @@ -1134,9 +1156,13 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int > * Rec. ITU-T T.814, Figure 7. > */ > sp = &sample_buf[j + i * stride]; > - if (jpeg2000_get_state(i, j, width, HT_SHIFT_SIGMA, block_states) != 0) { > - jpeg2000_modify_state(i, j, width, 1 << HT_SHIFT_REF_IND, block_states); > - *sp |= jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length) << pLSB; > + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) != 0) { > + jpeg2000_modify_state(i, j, stride, 1 << HT_SHIFT_REF_IND, block_states); > + bit = jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length); > + tmp = 0xFFFFFFFE | (uint32_t)bit; > + tmp <<= pLSB; > + sp[0] &= tmp; > + sp[0] |= 1 << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) > } > } > } > @@ -1146,21 +1172,24 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int > for (int j = 0; j < width; j++) { > for (int i = i_start; i < i_start + height; i++) { > sp = &sample_buf[j + i * stride]; > - if (jpeg2000_get_state(i, j, width, HT_SHIFT_SIGMA, block_states) != 0) { > - jpeg2000_modify_state(i, j, width, 1 << HT_SHIFT_REF_IND, block_states); > - *sp |= jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length) << pLSB; > + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) != 0) { > + jpeg2000_modify_state(i, j, stride, 1 << HT_SHIFT_REF_IND, block_states); > + bit = jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length); > + tmp = 0xFFFFFFFE | (uint32_t)bit; > + tmp <<= pLSB; > + sp[0] &= tmp; > + sp[0] |= 1 << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) > } > } > } > - return 1; > } > > > int > ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, > - int width, int height, int magp, uint8_t roi_shift) > + int width, int height, int M_b, uint8_t roi_shift) > { > - uint8_t p0 = 0; // Number of placeholder passes > + uint8_t p0 = 0; // 3 * p0 = Number of placeholder passes > uint32_t Lcup; // Length of HT cleanup segment > uint32_t Lref; // Length of Refinement segment > uint32_t Scup; // HT cleanup segment suffix length > @@ -1174,7 +1203,7 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c > > int z_blk; // Number of ht coding pass > > - uint8_t empty_passes; > + uint8_t num_plhd_passes; // Number of placeholder passes > > StateVars mag_sgn; // Magnitude and Sign > StateVars mel; // Adaptive run-length coding > @@ -1190,8 +1219,8 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c > uint8_t *block_states = NULL; > > int32_t n, val; // Post-processing > - > - int32_t M_b = magp; > + const uint32_t mask = UINT32_MAX >> (M_b + 1); // bit mask for ROI detection > + uint8_t num_rempass; > > const int quad_buf_width = width + 4; > const int quad_buf_height = height + 4; > @@ -1201,22 +1230,17 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c > av_assert0(width * height <= 4096); > av_assert0(width * height > 0); > > - if (roi_shift) > - avpriv_report_missing_feature(s->avctx, "ROI shift"); > - > memset(t1->data, 0, t1->stride * height * sizeof(*t1->data)); > memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags)); > > if (cblk->npasses == 0) > return 0; > > - if (cblk->npasses > 3) > - p0 = 0; > - else if (cblk->length == 0) > - p0 = 1; > - > - empty_passes = p0 * 3; > - z_blk = cblk->npasses - empty_passes; > + num_rempass = cblk->npasses % 3; // Number of remainder passes > + num_plhd_passes = num_rempass ? cblk->npasses - num_rempass : cblk->npasses - 3; > + av_assert0(num_plhd_passes % 3 == 0); > + p0 = num_plhd_passes / 3; > + z_blk = cblk->npasses - num_plhd_passes; > > if (z_blk <= 0) > return 0; // No passes within this set, continue > @@ -1231,7 +1255,11 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c > } > Dcup = cblk->data; > Dref = cblk->data + Lcup; // Dref comes after the refinement segment > + > + cblk->data[cblk->length] = 0xFF; // an extra byte for refinement segment (buffer->last) > + > S_blk = p0 + cblk->zbp; > + cblk->zbp = S_blk - 1; > pLSB = 30 - S_blk; > > Scup = (Dcup[Lcup - 1] << 4) + (Dcup[Lcup - 2] & 0x0F); > @@ -1277,31 +1305,32 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c > goto free; > } > > - if (cblk->npasses > 1) > + if (z_blk > 1) > jpeg2000_decode_sigprop_segment(cblk, width, height, quad_buf_width, Dref, Lref, > pLSB - 1, sample_buf, block_states); > > - if (cblk->npasses > 2) { > - > - if (Lref < 2){ > - av_log(s->avctx,AV_LOG_ERROR,"Invalid magnitude refinement length\n"); > - ret = AVERROR_INVALIDDATA; > - goto free; > - } > - if ((ret = jpeg2000_decode_magref_segment(width, height, quad_buf_width, Dref, Lref, > - pLSB - 1, sample_buf, block_states)) < 0) > - goto free; > - } > + if (z_blk > 2) > + jpeg2000_decode_magref_segment(width, height, quad_buf_width, Dref, Lref, > + pLSB - 1, sample_buf, block_states); > > pLSB = 31 - M_b; > > /* Reconstruct the sample values */ > for (int y = 0; y < height; y++) { > for (int x = 0; x < width; x++) { > + int32_t sign; > + > n = x + (y * t1->stride); > val = sample_buf[x + (y * quad_buf_width)]; > + sign = val & INT32_MIN; > + val &= INT32_MAX; > + /* ROI shift, if necessary */ > + if (roi_shift && (((uint32_t)val & ~mask) == 0)) > + val <<= roi_shift; > /* Convert sign-magnitude to two's complement. */ > - val = val >> 31 ? 0x80000000 - val : val; > + if (sign) > + val = -val; > + /* Shift down to 1 bit upper from decimal point for reconstruction value (= 0.5) */ > val >>= (pLSB - 1); > t1->data[n] = val; > } > diff --git a/libavcodec/jpeg2000htdec.h b/libavcodec/jpeg2000htdec.h > index 572d095c92..8d6919a0de 100644 > --- a/libavcodec/jpeg2000htdec.h > +++ b/libavcodec/jpeg2000htdec.h > @@ -29,6 +29,6 @@ > > int ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, > Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, > - int height, int magp, uint8_t roi_shift); > + int height, int M_b, uint8_t roi_shift); > > #endif /* AVCODEC_JPEG2000HTDEC_H */ > -- > 2.34.1 >
Hi Pierre, Here is the list of supported J2K reference codestreams. p0_10.j2k p1_01.j2k p1_02.j2k p1_03.j2k p1_04.j2k p1_05.j2k p1_06.j2k ds0_hm_15_b8.j2k ds0_ht_02_b11.j2k ds0_ht_02_b12.j2k ds0_ht_03_b11.j2k ds0_ht_03_b14.j2k ds0_ht_04_b11.j2k ds0_ht_04_b12.j2k ds0_ht_05_b11.j2k ds0_ht_05_b12.j2k ds0_ht_07_b11.j2k ds0_ht_07_b15.j2k ds0_ht_07_b16.j2k ds0_ht_08_b11.j2k ds0_ht_08_b15.j2k ds0_ht_08_b16.j2k ds0_ht_09_b11.j2k ds0_ht_10_b11.j2k ds0_ht_11_b10.j2k ds0_ht_12_b11.j2k ds0_ht_14_b11.j2k ds0_ht_15_b11.j2k ds0_ht_15_b14.j2k ds0_ht_16_b11.j2k ds1_ht_01_b11.j2k ds1_ht_01_b12.j2k ds1_ht_02_b11.j2k ds1_ht_02_b12.j2k ds1_ht_03_b11.j2k ds1_ht_03_b12.j2k ds1_ht_04_b9.j2k ds1_ht_05_b11.j2k ds1_ht_06_b11.j2k hifi_ht1_02.j2k hifi_p1_02.j2k FYI - the following codestreams are excluded from the list due to their unsupported pixel format in FFMPEG. p0_06.j2k p0_13.j2k p1_07.j2k ds0_ht_06_b11.j2k ds0_ht_06_b15.j2k ds0_ht_06_b18.j2k ds0_hm_06_b11.j2k ds0_hm_06_b18.j2k ds0_ht_13_b11.j2k ds1_ht_07_b11.j2k Separate color component should be decodable and I can provide them if necessary. Best, Osau > On Jun 15, 2024, at 15:00, Pierre-Anthony Lemieux <pal@sandflow.com> wrote: > > Hi Osamu, > > Can you provide the list of J2K reference codestreams that this code > allows FFMPEG to support -- not including those already supported [1]? > > [1] https://github.com/FFmpeg/FFmpeg/blob/master/tests/fate/jpeg2000.mak > > Best, > > -- Pierre > > On Fri, Jun 14, 2024 at 8:15?PM Osamu Watanabe > <owatanab@es.takushoku-u.ac.jp> wrote: >> >> Signed-off-by: Osamu Watanabe <owatanab@es.takushoku-u.ac.jp> >> --- >> libavcodec/jpeg2000.h | 10 + >> libavcodec/jpeg2000dec.c | 454 ++++++++++++++++++++++++++++++------- >> libavcodec/jpeg2000dec.h | 7 + >> libavcodec/jpeg2000htdec.c | 225 ++++++++++-------- >> libavcodec/jpeg2000htdec.h | 2 +- >> 5 files changed, 518 insertions(+), 180 deletions(-) >> >> diff --git a/libavcodec/jpeg2000.h b/libavcodec/jpeg2000.h >> index d004c08f10..93221d90ca 100644 >> --- a/libavcodec/jpeg2000.h >> +++ b/libavcodec/jpeg2000.h >> @@ -37,12 +37,14 @@ >> >> enum Jpeg2000Markers { >> JPEG2000_SOC = 0xff4f, // start of codestream >> + JPEG2000_CAP = 0xff50, // extended capabilities >> JPEG2000_SIZ = 0xff51, // image and tile size >> JPEG2000_COD, // coding style default >> JPEG2000_COC, // coding style component >> JPEG2000_TLM = 0xff55, // tile-part length, main header >> JPEG2000_PLM = 0xff57, // packet length, main header >> JPEG2000_PLT, // packet length, tile-part header >> + JPEG2000_CPF, // corresponding profile >> JPEG2000_QCD = 0xff5c, // quantization default >> JPEG2000_QCC, // quantization component >> JPEG2000_RGN, // region of interest >> @@ -58,6 +60,12 @@ enum Jpeg2000Markers { >> JPEG2000_EOC = 0xffd9, // end of codestream >> }; >> >> +enum JPEG2000_Ccap15_b14_15_params { >> + HTJ2K_HTONLY = 0, // HTONLY, bit 14 and 15 are 0 >> + HTJ2K_HTDECLARED, // HTDECLARED, bit 14 = 1 and bit 15 = 0 >> + HTJ2K_MIXED = 3, // MIXED, bit 14 and 15 are 1 >> +}; >> + >> #define JPEG2000_SOP_FIXED_BYTES 0xFF910004 >> #define JPEG2000_SOP_BYTE_LENGTH 6 >> >> @@ -192,6 +200,8 @@ typedef struct Jpeg2000Cblk { >> /* specific to HT code-blocks */ >> int zbp; >> int pass_lengths[2]; >> + uint8_t modes; // copy of SPcod/SPcoc field to parse HT-MIXED mode >> + uint8_t ht_plhd; // are we looking for HT placeholder passes? >> } Jpeg2000Cblk; // code block >> >> typedef struct Jpeg2000Prec { >> diff --git a/libavcodec/jpeg2000dec.c b/libavcodec/jpeg2000dec.c >> index d15502a527..d299c67cc7 100644 >> --- a/libavcodec/jpeg2000dec.c >> +++ b/libavcodec/jpeg2000dec.c >> @@ -54,6 +54,15 @@ >> #define HAD_COC 0x01 >> #define HAD_QCC 0x02 >> >> +// Values of flag for placeholder passes >> +enum HT_PLHD_STATUS { >> + HT_PLHD_OFF, >> + HT_PLHD_ON >> +}; >> + >> +#define HT_MIXED 0x80 // bit 7 of SPcod/SPcoc >> + >> + >> /* get_bits functions for JPEG2000 packet bitstream >> * It is a get_bit function with a bit-stuffing routine. If the value of the >> * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB. >> @@ -382,6 +391,9 @@ static int get_siz(Jpeg2000DecoderContext *s) >> } else if (ncomponents == 1 && s->precision == 8) { >> s->avctx->pix_fmt = AV_PIX_FMT_GRAY8; >> i = 0; >> + } else if (ncomponents == 1 && s->precision == 12) { >> + s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE; >> + i = 0; >> } >> } >> >> @@ -408,6 +420,73 @@ static int get_siz(Jpeg2000DecoderContext *s) >> s->avctx->bits_per_raw_sample = s->precision; >> return 0; >> } >> +/* get extended capabilities (CAP) marker segment */ >> +static int get_cap(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c) >> +{ >> + uint32_t Pcap; >> + uint16_t Ccap_i[32] = { 0 }; >> + uint16_t Ccap_15; >> + uint8_t P; >> + >> + if (bytestream2_get_bytes_left(&s->g) < 6) { >> + av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for CAP\n"); >> + return AVERROR_INVALIDDATA; >> + } >> + >> + Pcap = bytestream2_get_be32u(&s->g); >> + s->isHT = (Pcap >> (31 - (15 - 1))) & 1; >> + for (int i = 0; i < 32; i++) { >> + if ((Pcap >> (31 - i)) & 1) >> + Ccap_i[i] = bytestream2_get_be16u(&s->g); >> + } >> + Ccap_15 = Ccap_i[14]; >> + if (s->isHT == 1) { >> + av_log(s->avctx, AV_LOG_INFO, "This is an HTJ2K codestream.\n"); >> + // Bits 14-15 >> + switch ((Ccap_15 >> 14) & 0x3) { >> + case 0x3: >> + s->Ccap15_b14_15 = HTJ2K_MIXED; >> + break; >> + case 0x1: >> + s->Ccap15_b14_15 = HTJ2K_HTDECLARED; >> + break; >> + case 0x0: >> + s->Ccap15_b14_15 = HTJ2K_HTONLY; >> + break; >> + default: >> + av_log(s->avctx, AV_LOG_ERROR, "Unknown CCap value.\n"); >> + return AVERROR(EINVAL); >> + break; >> + } >> + // Bit 13 >> + if ((Ccap_15 >> 13) & 1) { >> + av_log(s->avctx, AV_LOG_ERROR, "MULTIHT set is not supported.\n"); >> + return AVERROR_PATCHWELCOME; >> + } >> + // Bit 12 >> + s->Ccap15_b12 = (Ccap_15 >> 12) & 1; >> + // Bit 11 >> + s->Ccap15_b11 = (Ccap_15 >> 11) & 1; >> + // Bit 5 >> + s->Ccap15_b05 = (Ccap_15 >> 5) & 1; >> + // Bit 0-4 >> + P = Ccap_15 & 0x1F; >> + if (!P) >> + s->HT_MAGB = 8; >> + else if (P < 20) >> + s->HT_MAGB = P + 8; >> + else if (P < 31) >> + s->HT_MAGB = 4 * (P - 19) + 27; >> + else >> + s->HT_MAGB = 74; >> + >> + if (s->HT_MAGB > 31) { >> + av_log(s->avctx, AV_LOG_ERROR, "Available internal precision is exceeded (MAGB> 31).\n"); >> + return AVERROR_PATCHWELCOME; >> + } >> + } >> + return 0; >> +} >> >> /* get common part for COD and COC segments */ >> static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c) >> @@ -802,6 +881,15 @@ static int read_crg(Jpeg2000DecoderContext *s, int n) >> bytestream2_skip(&s->g, n - 2); >> return 0; >> } >> + >> +static int read_cpf(Jpeg2000DecoderContext *s, int n) >> +{ >> + if (bytestream2_get_bytes_left(&s->g) < (n - 2)) >> + return AVERROR_INVALIDDATA; >> + bytestream2_skip(&s->g, n - 2); >> + return 0; >> +} >> + >> /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1 >> * Used to know the number of tile parts and lengths. >> * There may be multiple TLMs in the header. >> @@ -965,6 +1053,10 @@ static int init_tile(Jpeg2000DecoderContext *s, int tileno) >> comp->roi_shift = s->roi_shift[compno]; >> if (!codsty->init) >> return AVERROR_INVALIDDATA; >> + if (s->isHT && (!s->Ccap15_b05) && (!codsty->transform)) >> + av_log(s->avctx, AV_LOG_WARNING, "Transformation = 0 (lossy DWT) is found in HTREV HT set\n"); >> + if (s->isHT && s->Ccap15_b14_15 != (codsty->cblk_style >> 6) && s->Ccap15_b14_15 != HTJ2K_HTONLY) >> + av_log(s->avctx, AV_LOG_WARNING, "SPcod/SPcoc value does not match bit 14-15 values of Ccap15\n"); >> if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty, >> s->cbps[compno], s->cdx[compno], >> s->cdy[compno], s->avctx)) >> @@ -1067,100 +1159,275 @@ static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, >> int incl, newpasses, llen; >> void *tmp; >> >> - if (cblk->npasses) >> - incl = get_bits(s, 1); >> - else >> + if (!cblk->incl) { >> + incl = 0; >> + cblk->modes = codsty->cblk_style; >> + if (cblk->modes >= JPEG2000_CTSY_HTJ2K_F) >> + cblk->ht_plhd = HT_PLHD_ON; >> + if (layno > 0) >> + incl = tag_tree_decode(s, prec->cblkincl + cblkno, 0 + 1) == 0; >> incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno; >> - if (!incl) >> - continue; >> - else if (incl < 0) >> - return incl; >> - >> - if (!cblk->npasses) { >> - int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100); >> - int v = expn[bandno] + numgbits - 1 - zbp; >> >> - if (v < 0 || v > 30) { >> - av_log(s->avctx, AV_LOG_ERROR, >> - "nonzerobits %d invalid or unsupported\n", v); >> - return AVERROR_INVALIDDATA; >> + if (incl) { >> + int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100); >> + int v = expn[bandno] + numgbits - 1 - (zbp - tile->comp->roi_shift); >> + if (v < 0 || v > 30) { >> + av_log(s->avctx, AV_LOG_ERROR, >> + "nonzerobits %d invalid or unsupported\n", v); >> + return AVERROR_INVALIDDATA; >> + } >> + cblk->incl = 1; >> + cblk->nonzerobits = v; >> + cblk->zbp = zbp; >> + cblk->lblock = 3; >> } >> - cblk->zbp = zbp; >> - cblk->nonzerobits = v; >> - } >> - if ((newpasses = getnpasses(s)) < 0) >> - return newpasses; >> - av_assert2(newpasses > 0); >> - if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) { >> - avpriv_request_sample(s->avctx, "Too many passes"); >> - return AVERROR_PATCHWELCOME; >> - } >> - if ((llen = getlblockinc(s)) < 0) >> - return llen; >> - if (cblk->lblock + llen + av_log2(newpasses) > 16) { >> - avpriv_request_sample(s->avctx, >> - "Block with length beyond 16 bits"); >> - return AVERROR_PATCHWELCOME; >> + } else { >> + incl = get_bits(s, 1); >> } >> >> - cblk->lblock += llen; >> - >> - cblk->nb_lengthinc = 0; >> - cblk->nb_terminationsinc = 0; >> - av_free(cblk->lengthinc); >> - cblk->lengthinc = av_calloc(newpasses, sizeof(*cblk->lengthinc)); >> - if (!cblk->lengthinc) >> - return AVERROR(ENOMEM); >> - tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start)); >> - if (!tmp) >> - return AVERROR(ENOMEM); >> - cblk->data_start = tmp; >> - do { >> - int newpasses1 = 0; >> - >> - while (newpasses1 < newpasses) { >> - newpasses1 ++; >> - if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) { >> - cblk->nb_terminationsinc ++; >> - break; >> + if (incl) { >> + uint8_t bypass_term_threshold = 0; >> + uint8_t bits_to_read = 0; >> + uint32_t segment_bytes = 0; >> + int32_t segment_passes = 0; >> + uint8_t next_segment_passes = 0; >> + int32_t href_passes, pass_bound; >> + uint32_t tmp_length = 0; >> + >> + if ((newpasses = getnpasses(s)) <= 0) >> + return newpasses; >> + if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) { >> + avpriv_request_sample(s->avctx, "Too many passes"); >> + return AVERROR_PATCHWELCOME; >> + } >> + if ((llen = getlblockinc(s)) < 0) >> + return llen; >> + if (cblk->lblock + llen + av_log2(newpasses) > 16) { >> + avpriv_request_sample(s->avctx, >> + "Block with length beyond 16 bits"); >> + return AVERROR_PATCHWELCOME; >> + } >> + cblk->nb_lengthinc = 0; >> + cblk->nb_terminationsinc = 0; >> + av_free(cblk->lengthinc); >> + cblk->lengthinc = av_calloc(newpasses, sizeof(*cblk->lengthinc)); >> + if (!cblk->lengthinc) >> + return AVERROR(ENOMEM); >> + tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, >> + sizeof(*cblk->data_start)); >> + if (!tmp) >> + return AVERROR(ENOMEM); >> + cblk->data_start = tmp; >> + cblk->lblock += llen; >> + >> + if (cblk->ht_plhd) { >> + href_passes = (cblk->npasses + newpasses - 1) % 3; >> + segment_passes = newpasses - href_passes; >> + pass_bound = 2; >> + bits_to_read = cblk->lblock; >> + if (segment_passes < 1) { >> + // No possible HT Cleanup pass here; may have placeholder passes >> + // or an original J2K block bit-stream (in MIXED mode). >> + segment_passes = newpasses; >> + while (pass_bound <= segment_passes) { >> + bits_to_read++; >> + pass_bound += pass_bound; >> + } >> + segment_bytes = get_bits(s, bits_to_read); >> + if (segment_bytes) { >> + if (cblk->modes & HT_MIXED) { >> + cblk->ht_plhd = HT_PLHD_OFF; >> + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); >> + } >> + else { >> + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); >> + } >> + } >> + } else { >> + while (pass_bound <= segment_passes) { >> + bits_to_read++; >> + pass_bound += pass_bound; >> + } >> + segment_bytes = get_bits(s, bits_to_read); >> + if (segment_bytes) { >> + // No more placeholder passes >> + if (!(cblk->modes & HT_MIXED)) { >> + // Must be the first HT Cleanup pass >> + if (segment_bytes < 2) >> + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); >> + next_segment_passes = 2; >> + cblk->ht_plhd = HT_PLHD_OFF; >> + // Write length information for HT CleanUp segment >> + cblk->pass_lengths[0] = segment_bytes; >> + } else if (cblk->lblock > 3 && segment_bytes > 1 >> + && (segment_bytes >> (bits_to_read - 1)) == 0) { >> + // Must be the first HT Cleanup pass, since length MSB is 0 >> + next_segment_passes = 2; >> + cblk->ht_plhd = HT_PLHD_OFF; >> + // Write length information for HT CleanUp segment >> + cblk->pass_lengths[0] = segment_bytes; >> + } else { >> + // Must have an original (non-HT) block coding pass >> + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); >> + cblk->ht_plhd = HT_PLHD_OFF; >> + segment_passes = newpasses; >> + while (pass_bound <= segment_passes) { >> + bits_to_read++; >> + pass_bound += pass_bound; >> + segment_bytes <<= 1; >> + segment_bytes += get_bits(s, 1); >> + } >> + } >> + } else { >> + // Probably parsing placeholder passes, but we need to read an >> + // extra length bit to verify this, since prior to the first >> + // HT Cleanup pass, the number of length bits read for a >> + // contributing code-block is dependent on the number of passes >> + // being included, as if it were a non-HT code-block. >> + segment_passes = newpasses; >> + if (pass_bound <= segment_passes) { >> + while (1) { >> + bits_to_read++; >> + pass_bound += pass_bound; >> + segment_bytes <<= 1; >> + segment_bytes += get_bits(s, 1); >> + if (pass_bound > segment_passes) >> + break; >> + } >> + if (segment_bytes) { >> + if (cblk->modes & HT_MIXED) { >> + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); >> + cblk->ht_plhd = HT_PLHD_OFF; >> + } else { >> + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); >> + } >> + } >> + } >> + } >> } >> + } else if (cblk->modes & JPEG2000_CTSY_HTJ2K_F) { >> + // Quality layer commences with a non-initial HT coding pass >> + if(bits_to_read != 0) >> + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); >> + segment_passes = cblk->npasses % 3; >> + if (segment_passes == 0) { >> + // newpasses is a HT Cleanup pass; next segment has refinement passes >> + segment_passes = 1; >> + next_segment_passes = 2; >> + if (segment_bytes == 1) >> + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); >> + } else { >> + // newpasses = 1 means npasses is HT SigProp; 2 means newpasses is >> + // HT MagRef pass >> + segment_passes = newpasses > 1 ? 3 - segment_passes : 1; >> + next_segment_passes = 1; >> + bits_to_read = av_log2(segment_passes); >> + } >> + bits_to_read = (uint8_t) (bits_to_read + cblk->lblock); >> + segment_bytes = get_bits(s, bits_to_read); >> + // Write length information for HT Refinment segment >> + cblk->pass_lengths[1] += segment_bytes; >> + } else if (!(cblk->modes & (JPEG2000_CBLK_TERMALL | JPEG2000_CBLK_BYPASS))) { >> + // Common case for non-HT code-blocks; we have only one segment >> + bits_to_read = (uint8_t) cblk->lblock + av_log2((uint8_t) newpasses); >> + segment_bytes = get_bits(s, bits_to_read); >> + segment_passes = newpasses; >> + } else if (cblk->modes & JPEG2000_CBLK_TERMALL) { >> + // RESTART MODE >> + bits_to_read = cblk->lblock; >> + segment_bytes = get_bits(s, bits_to_read); >> + segment_passes = 1; >> + next_segment_passes = 1; >> + cblk->nb_terminationsinc++; >> + } else { >> + // BYPASS MODE >> + bypass_term_threshold = 10; >> + if(bits_to_read != 0) >> + av_log(s->avctx, AV_LOG_WARNING, "Length information for a codeblock is invalid\n"); >> + if (cblk->npasses < bypass_term_threshold) { >> + // May have from 1 to 10 uninterrupted passes before 1st RAW SigProp >> + segment_passes = bypass_term_threshold - cblk->npasses; >> + if (segment_passes > newpasses) >> + segment_passes = newpasses; >> + while ((2 << bits_to_read) <= segment_passes) >> + bits_to_read++; >> + next_segment_passes = 2; >> + } else if ((cblk->npasses - bypass_term_threshold) % 3 < 2) { >> + // 0 means newpasses is a RAW SigProp; 1 means newpasses is a RAW MagRef pass >> + segment_passes = newpasses > 1 ? 2 - (cblk->npasses - bypass_term_threshold) % 3 : 1; >> + bits_to_read = av_log2(segment_passes); >> + next_segment_passes = 1; >> + } else { >> + // newpasses is an isolated Cleanup pass that precedes a RAW SigProp pass >> + segment_passes = 1; >> + next_segment_passes = 2; >> + } >> + bits_to_read = (uint8_t) (bits_to_read + cblk->lblock); >> + segment_bytes = get_bits(s, bits_to_read); >> } >> - >> - if (newpasses > 1 && (codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F)) { >> - // Retrieve pass lengths for each pass >> - int href_passes = (cblk->npasses + newpasses - 1) % 3; >> - int eb = av_log2(newpasses - href_passes); >> - int extra_bit = newpasses > 2 ? 1 : 0; >> - if ((ret = get_bits(s, llen + eb + 3)) < 0) >> - return ret; >> - cblk->pass_lengths[0] = ret; >> - if ((ret = get_bits(s, llen + 3 + extra_bit)) < 0) >> - return ret; >> - cblk->pass_lengths[1] = ret; >> - ret = cblk->pass_lengths[0] + cblk->pass_lengths[1]; >> + // Update cblk->npasses and write length information >> + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); >> + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; >> + >> + if ((cblk->modes & JPEG2000_CTSY_HTJ2K_F) && cblk->ht_plhd == HT_PLHD_OFF) { >> + newpasses -= (uint8_t) segment_passes; >> + while (newpasses > 0) { >> + segment_passes = newpasses > 1 ? next_segment_passes : 1; >> + next_segment_passes = (uint8_t) (3 - next_segment_passes); >> + bits_to_read = (uint8_t) (cblk->lblock + av_log2(segment_passes)); >> + segment_bytes = get_bits(s, bits_to_read); >> + newpasses -= (uint8_t) (segment_passes); >> + // This is a FAST Refinement pass >> + // Write length information for HT Refinement segment >> + cblk->pass_lengths[1] += segment_bytes; >> + // Update cblk->npasses and write length information >> + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); >> + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; >> + } >> } else { >> - if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0) >> - return ret; >> - cblk->pass_lengths[0] = ret; >> + newpasses -= (uint8_t) (segment_passes); >> + while (newpasses > 0) { >> + if (bypass_term_threshold != 0) { >> + segment_passes = newpasses > 1 ? next_segment_passes : 1; >> + next_segment_passes = (uint8_t) (3 - next_segment_passes); >> + bits_to_read = (uint8_t) (cblk->lblock + av_log2(segment_passes)); >> + } else { >> + if ((cblk->modes & JPEG2000_CBLK_TERMALL) == 0) >> + av_log(s->avctx, AV_LOG_WARNING, "Corrupted packet header is found.\n"); >> + segment_passes = 1; >> + bits_to_read = cblk->lblock; >> + } >> + segment_bytes = get_bits(s, bits_to_read); >> + newpasses -= (uint8_t) (segment_passes); >> + >> + // Update cblk->npasses and write length information >> + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); >> + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; >> + cblk->nb_terminationsinc++; >> + } >> } >> - if (ret > cblk->data_allocated) { >> - size_t new_size = FFMAX(2*cblk->data_allocated, ret); >> + >> + for (int i = 0; i < cblk->nb_lengthinc; ++i) >> + tmp_length = (tmp_length < cblk->lengthinc[i]) ? cblk->lengthinc[i] : tmp_length; >> + >> + if (tmp_length > cblk->data_allocated) { >> + size_t new_size = FFMAX(2 * cblk->data_allocated, tmp_length); >> void *new = av_realloc(cblk->data, new_size); >> if (new) { >> cblk->data = new; >> cblk->data_allocated = new_size; >> } >> } >> - if (ret > cblk->data_allocated) { >> + if (tmp_length > cblk->data_allocated) { >> avpriv_request_sample(s->avctx, >> "Block with lengthinc greater than %"SIZE_SPECIFIER"", >> cblk->data_allocated); >> return AVERROR_PATCHWELCOME; >> } >> - cblk->lengthinc[cblk->nb_lengthinc++] = ret; >> - cblk->npasses += newpasses1; >> - newpasses -= newpasses1; >> - } while(newpasses); >> + } else { >> + // This codeblock has no contribution to the current packet >> + continue; >> + } >> } >> } >> jpeg2000_flush(s); >> @@ -1695,7 +1962,7 @@ static int decode_cblk(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *cod >> Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, >> int width, int height, int bandpos, uint8_t roi_shift) >> { >> - int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1 + roi_shift; >> + int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1; >> int pass_cnt = 0; >> int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC; >> int term_cnt = 0; >> @@ -1909,7 +2176,7 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile >> Jpeg2000Band *band = rlevel->band + bandno; >> int cblkno = 0, bandpos; >> /* See Rec. ITU-T T.800, Equation E-2 */ >> - int magp = quantsty->expn[subbandno] + quantsty->nguardbits - 1; >> + int M_b = quantsty->expn[subbandno] + quantsty->nguardbits - 1; >> >> bandpos = bandno + (reslevelno > 0); >> >> @@ -1917,8 +2184,8 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile >> band->coord[1][0] == band->coord[1][1]) >> continue; >> >> - if ((codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) && magp >= 31) { >> - avpriv_request_sample(s->avctx, "JPEG2000_CTSY_HTJ2K_F and magp >= 31"); >> + if ((codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) && M_b >= 31) { >> + avpriv_request_sample(s->avctx, "JPEG2000_CTSY_HTJ2K_F and M_b >= 31"); >> return AVERROR_PATCHWELCOME; >> } >> >> @@ -1935,11 +2202,11 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile >> >> Jpeg2000Cblk *cblk = prec->cblk + cblkno; >> >> - if (codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) >> + if (cblk->modes & JPEG2000_CTSY_HTJ2K_F) >> ret = ff_jpeg2000_decode_htj2k(s, codsty, &t1, cblk, >> cblk->coord[0][1] - cblk->coord[0][0], >> cblk->coord[1][1] - cblk->coord[1][0], >> - magp, comp->roi_shift); >> + M_b, comp->roi_shift); >> else >> ret = decode_cblk(s, codsty, &t1, cblk, >> cblk->coord[0][1] - cblk->coord[0][0], >> @@ -2178,22 +2445,42 @@ static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s) >> if (!s->tile) >> s->numXtiles = s->numYtiles = 0; >> break; >> + case JPEG2000_CAP: >> + if (!s->ncomponents) { >> + av_log(s->avctx, AV_LOG_WARNING, "CAP marker segment shall come after SIZ\n"); >> + } >> + ret = get_cap(s, codsty); >> + break; >> case JPEG2000_COC: >> + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) >> + av_log(s->avctx, AV_LOG_WARNING, "COC marker is found in HOMOGENEOUS HT set\n"); >> ret = get_coc(s, codsty, properties); >> break; >> case JPEG2000_COD: >> + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) >> + av_log(s->avctx, AV_LOG_WARNING, "COD marker is found in HOMOGENEOUS HT set\n"); >> ret = get_cod(s, codsty, properties); >> break; >> case JPEG2000_RGN: >> + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) >> + av_log(s->avctx, AV_LOG_WARNING, "RGB marker is found in HOMOGENEOUS HT set\n"); >> ret = get_rgn(s, len); >> + if ((!s->Ccap15_b12) && s->isHT) >> + av_log(s->avctx, AV_LOG_WARNING, "RGN marker is found in RGNFREE HT set\n"); >> break; >> case JPEG2000_QCC: >> + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) >> + av_log(s->avctx, AV_LOG_WARNING, "QCC marker is found in HOMOGENEOUS HT set\n"); >> ret = get_qcc(s, len, qntsty, properties); >> break; >> case JPEG2000_QCD: >> + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) >> + av_log(s->avctx, AV_LOG_WARNING, "QCD marker is found in HOMOGENEOUS HT set\n"); >> ret = get_qcd(s, len, qntsty, properties); >> break; >> case JPEG2000_POC: >> + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) >> + av_log(s->avctx, AV_LOG_WARNING, "POC marker is found in HOMOGENEOUS HT set\n"); >> ret = get_poc(s, len, poc); >> break; >> case JPEG2000_SOT: >> @@ -2243,9 +2530,14 @@ static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s) >> "Cannot have both PPT and PPM marker.\n"); >> return AVERROR_INVALIDDATA; >> } >> - >> + if ((!s->Ccap15_b11) && s->isHT) >> + av_log(s->avctx, AV_LOG_WARNING, "PPT marker is found in HOMOGENEOUS HT set\n"); >> ret = get_ppt(s, len); >> break; >> + case JPEG2000_CPF: >> + // Corresponding profile marker >> + ret = read_cpf(s, len); >> + break; >> default: >> av_log(s->avctx, AV_LOG_ERROR, >> "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n", >> diff --git a/libavcodec/jpeg2000dec.h b/libavcodec/jpeg2000dec.h >> index d0ca6e7a79..326a572722 100644 >> --- a/libavcodec/jpeg2000dec.h >> +++ b/libavcodec/jpeg2000dec.h >> @@ -112,6 +112,13 @@ typedef struct Jpeg2000DecoderContext { >> Jpeg2000Tile *tile; >> Jpeg2000DSPContext dsp; >> >> + uint8_t isHT; // HTJ2K? >> + uint8_t Ccap15_b14_15; // HTONLY(= 0) or HTDECLARED(= 1) or MIXED(= 3) ? >> + uint8_t Ccap15_b12; // RGNFREE(= 0) or RGN(= 1)? >> + uint8_t Ccap15_b11; // HOMOGENEOUS(= 0) or HETEROGENEOUS(= 1) ? >> + uint8_t Ccap15_b05; // HTREV(= 0) or HTIRV(= 1) ? >> + uint8_t HT_MAGB; // MAGB value >> + >> /*options parameters*/ >> int reduction_factor; >> } Jpeg2000DecoderContext; >> diff --git a/libavcodec/jpeg2000htdec.c b/libavcodec/jpeg2000htdec.c >> index eba0936089..beb4a386b0 100644 >> --- a/libavcodec/jpeg2000htdec.c >> +++ b/libavcodec/jpeg2000htdec.c >> @@ -122,7 +122,7 @@ static void jpeg2000_init_mel(StateVars *s, uint32_t Pcup) >> >> static void jpeg2000_init_mag_ref(StateVars *s, uint32_t Lref) >> { >> - s->pos = Lref - 2; >> + s->pos = Lref - 1; >> s->bits = 0; >> s->last = 0xFF; >> s->tmp = 0; >> @@ -145,9 +145,10 @@ static void jpeg2000_init_mel_decoder(MelDecoderState *mel_state) >> static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *array) >> { >> uint64_t tmp = 0; >> - int32_t position = buffer->pos - 4; >> uint32_t new_bits = 32; >> >> + buffer->last = array[buffer->pos + 1]; >> + >> if (buffer->bits_left >= 32) >> return 0; // enough data, no need to pull in more bits >> >> @@ -157,9 +158,24 @@ static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *ar >> * the bottom most bits. >> */ >> >> - for(int i = FFMAX(0, position + 1); i <= buffer->pos + 1; i++) >> - tmp = 256*tmp + array[i]; >> - >> + if (buffer->pos >= 3) { // Common case; we have at least 4 bytes available >> + tmp = array[buffer->pos - 3]; >> + tmp = (tmp << 8) | array[buffer->pos - 2]; >> + tmp = (tmp << 8) | array[buffer->pos - 1]; >> + tmp = (tmp << 8) | array[buffer->pos]; >> + tmp = (tmp << 8) | buffer->last; // For stuffing bit detection >> + buffer->pos -= 4; >> + } else { >> + if (buffer->pos >= 2) >> + tmp = array[buffer->pos - 2]; >> + if (buffer->pos >= 1) >> + tmp = (tmp << 8) | array[buffer->pos - 1]; >> + if (buffer->pos >= 0) >> + tmp = (tmp << 8) | array[buffer->pos]; >> + buffer->pos = 0; >> + tmp = (tmp << 8) | buffer->last; // For stuffing bit detection >> + } >> + // Now remove any stuffing bits, shifting things down as we go >> if ((tmp & 0x7FFF000000) > 0x7F8F000000) { >> tmp &= 0x7FFFFFFFFF; >> new_bits--; >> @@ -176,13 +192,11 @@ static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *ar >> tmp = (tmp & 0x0000007FFF) + ((tmp & 0xFFFFFF0000) >> 1); >> new_bits--; >> } >> - >> - tmp >>= 8; // Remove temporary byte loaded >> + tmp >>= 8; // Shifts away the extra byte we imported >> >> /* Add bits to the MSB of the bit buffer */ >> buffer->bit_buf |= tmp << buffer->bits_left; >> buffer->bits_left += new_bits; >> - buffer->pos = FFMAX(0, position); >> return 0; >> } >> >> @@ -406,6 +420,7 @@ static void recover_mag_sgn(StateVars *mag_sgn, uint8_t pos, uint16_t q, int32_t >> E[n] = 32 - ff_clz(v[pos][i] | 1); >> mu_n[n] = (v[pos][i] >> 1) + 1; >> mu_n[n] <<= pLSB; >> + mu_n[n] |= (1 << (pLSB - 1)); // Add 0.5 (reconstruction parameter = 1/2) >> mu_n[n] |= ((uint32_t) (v[pos][i] & 1)) << 31; // sign bit. >> } >> } >> @@ -414,7 +429,7 @@ static void recover_mag_sgn(StateVars *mag_sgn, uint8_t pos, uint16_t q, int32_t >> static int jpeg2000_import_bit(StateVars *stream, const uint8_t *array, uint32_t length) >> { >> int cond = stream->pos < length; >> - int pos = FFMIN(stream->pos, length); >> + int pos = FFMIN(stream->pos, length - 1); >> if (stream->bits == 0) { >> stream->bits = (stream->tmp == 0xFF) ? 7 : 8; >> stream->pos += cond; >> @@ -426,14 +441,22 @@ static int jpeg2000_import_bit(StateVars *stream, const uint8_t *array, uint32_t >> >> static int jpeg2000_peek_bit(StateVars *stream, const uint8_t *array, uint32_t length) >> { >> + uint8_t bit; >> + >> if (stream->bits == 0) { >> - int cond = stream->pos < length; >> - int pos = FFMIN(stream->pos, length); >> - stream->bits = (stream->tmp == 0xFF) ? 7 : 8; >> - stream->pos += cond; >> - stream->tmp = cond ? array[pos] : 0xFF; >> + stream->bits = (stream->last == 0xFF) ? 7 : 8; >> + if (stream->pos < length) { >> + stream->tmp = array[stream->pos]; >> + stream->pos++; >> + } else { >> + stream->tmp = 0; >> + } >> + stream->last = stream->tmp; >> } >> - return (stream->tmp >> stream->bits) & 1; >> + bit = stream->tmp & 1; >> + stream->tmp >>= 1; >> + stream->bits--; >> + return bit; >> } >> >> static int jpeg2000_decode_mel_sym(MelDecoderState *mel_state, >> @@ -994,66 +1017,63 @@ static void jpeg2000_calc_mbr(uint8_t *mbr, const uint16_t i, const uint16_t j, >> const uint32_t mbr_info, uint8_t causal_cond, >> uint8_t *block_states, int stride) >> { >> - int local_mbr = 0; >> - >> - local_mbr |= jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SIGMA, block_states); >> - local_mbr |= jpeg2000_get_state(i - 1, j + 0, stride, HT_SHIFT_SIGMA, block_states); >> - local_mbr |= jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_SIGMA, block_states); >> - >> - local_mbr |= jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_SIGMA, block_states); >> - local_mbr |= jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_SIGMA, block_states); >> - >> - local_mbr |= jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; >> - local_mbr |= jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; >> - local_mbr |= jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; >> - >> - local_mbr |= jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_REF, block_states) * >> - jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SCAN, block_states); >> - local_mbr |= jpeg2000_get_state(i - 1, j + 0, stride, HT_SHIFT_REF, block_states) * >> - jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SCAN, block_states); >> - local_mbr |= jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_REF, block_states) * >> - jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_SCAN, block_states); >> - >> - local_mbr |= jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_REF, block_states) * >> - jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_SCAN, block_states); >> - local_mbr |= jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_REF, block_states) * >> - jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_SCAN, block_states); >> - >> - local_mbr |= jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_REF, block_states) * >> - jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_SCAN, block_states) * causal_cond; >> - local_mbr |= jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_REF, block_states) * >> - jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_SCAN, block_states) * causal_cond; >> - local_mbr |= jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_REF, block_states) * >> - jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_SCAN, block_states) * causal_cond; >> - >> - *mbr |= local_mbr; >> + uint8_t *state_p0 = block_states + i * stride + j; >> + uint8_t *state_p1 = block_states + (i + 1) * stride + j; >> + uint8_t *state_p2 = block_states + (i + 2) * stride + j; >> + >> + uint8_t mbr0 = state_p0[0] | state_p0[1] | state_p0[2]; >> + uint8_t mbr1 = state_p1[0] | state_p1[2]; >> + uint8_t mbr2 = state_p2[0] | state_p2[1] | state_p2[2]; >> + *mbr = mbr0 | mbr1 | (mbr2 & causal_cond); >> + *mbr |= (mbr0 >> HT_SHIFT_REF) & (mbr0 >> HT_SHIFT_SCAN); >> + *mbr |= (mbr1 >> HT_SHIFT_REF) & (mbr1 >> HT_SHIFT_SCAN); >> + *mbr |= (mbr2 >> HT_SHIFT_REF) & (mbr2 >> HT_SHIFT_SCAN) & causal_cond; >> + *mbr &= 1; >> } >> >> static void jpeg2000_process_stripes_block(StateVars *sig_prop, int i_s, int j_s, >> int width, int height, int stride, int pLSB, >> int32_t *sample_buf, uint8_t *block_states, >> - uint8_t *magref_segment, uint32_t magref_length) >> + uint8_t *magref_segment, uint32_t magref_length, >> + uint8_t is_causal) >> { >> for (int j = j_s; j < j_s + width; j++) { >> uint32_t mbr_info = 0; >> for (int i = i_s; i < i_s + height; i++) { >> - int modify_state, cond; >> + int modify_state; >> uint8_t bit; >> - uint8_t causal_cond = i != (i_s + height - 1); >> + uint8_t causal_cond = (is_causal == 0) || (i != (i_s + height - 1)); >> int32_t *sp = &sample_buf[j + (i * (stride))]; >> uint8_t mbr = 0; >> >> - if (jpeg2000_get_state(i, j, stride - 2, HT_SHIFT_SIGMA, block_states) == 0) >> + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) == 0) >> jpeg2000_calc_mbr(&mbr, i, j, mbr_info & 0x1EF, causal_cond, block_states, stride); >> mbr_info >>= 3; >> - cond = mbr != 0; >> - bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); >> - *sp |= (bit * cond) << pLSB; >> - sig_prop->bits -= cond; >> - modify_state = (((1 << HT_SHIFT_REF_IND) | (1 << HT_SHIFT_REF)) * cond) | 1 << HT_SHIFT_SCAN; >> + >> + modify_state = block_states[(i + 1) * stride + (j + 1)]; >> + modify_state |= 1 << HT_SHIFT_SCAN; >> + if (mbr != 0) { >> + modify_state |= 1 << HT_SHIFT_REF_IND; >> + bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); >> + modify_state |= bit << HT_SHIFT_REF; >> + *sp |= bit << pLSB; >> + *sp |= bit << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) >> + } >> jpeg2000_modify_state(i, j, stride, modify_state, block_states); >> } >> } >> + // decode sign >> + for (int j = j_s; j < j_s + width; j++) { >> + for (int i = i_s; i < i_s + height; i++) { >> + uint8_t bit; >> + int32_t *sp = &sample_buf[j + (i * (stride))]; >> + uint8_t *state_p = block_states + (i + 1) * stride + (j + 1); >> + if ((state_p[0] >> HT_SHIFT_REF) & 1) { >> + bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); >> + *sp |= (int32_t)bit << 31; >> + } >> + } >> + } >> } >> >> /** >> @@ -1074,6 +1094,7 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, >> >> int last_width; >> uint16_t i = 0, j = 0; >> + uint8_t is_causal = cblk->modes & JPEG2000_CBLK_VSC; >> >> jpeg2000_init_zero(&sp_dec); >> >> @@ -1082,14 +1103,14 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, >> for (int n2 = 0; n2 < num_h_stripe; n2++) { >> jpeg2000_process_stripes_block(&sp_dec, i, j, b_width, b_height, stride, >> pLSB, sample_buf, block_states, magref_segment, >> - magref_length); >> + magref_length, is_causal); >> j += 4; >> } >> last_width = width % 4; >> if (last_width) >> jpeg2000_process_stripes_block(&sp_dec, i, j, last_width, b_height, stride, >> pLSB, sample_buf, block_states, magref_segment, >> - magref_length); >> + magref_length, is_causal); >> i += 4; >> } >> >> @@ -1099,20 +1120,20 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, >> for (int n2 = 0; n2 < num_h_stripe; n2++) { >> jpeg2000_process_stripes_block(&sp_dec, i, j, b_width, b_height, stride, >> pLSB, sample_buf, block_states, magref_segment, >> - magref_length); >> + magref_length, is_causal); >> j += 4; >> } >> last_width = width % 4; >> if (last_width) >> jpeg2000_process_stripes_block(&sp_dec, i, j, last_width, b_height, stride, >> pLSB, sample_buf, block_states, magref_segment, >> - magref_length); >> + magref_length, is_causal); >> } >> >> /** >> * See procedure decodeSigPropMag at Rec. ITU-T T.814, 7.5. >> */ >> -static int >> +static void >> jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int stride, >> uint8_t *magref_segment,uint32_t magref_length, >> uint8_t pLSB, int32_t *sample_buf, uint8_t *block_states) >> @@ -1123,7 +1144,8 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int >> uint16_t height = 4; >> uint16_t i_start = 0; >> int32_t *sp; >> - >> + int32_t bit; >> + int32_t tmp; >> jpeg2000_init_mag_ref(&mag_ref, magref_length); >> >> for (int n1 = 0; n1 < num_v_stripe; n1++) { >> @@ -1134,9 +1156,13 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int >> * Rec. ITU-T T.814, Figure 7. >> */ >> sp = &sample_buf[j + i * stride]; >> - if (jpeg2000_get_state(i, j, width, HT_SHIFT_SIGMA, block_states) != 0) { >> - jpeg2000_modify_state(i, j, width, 1 << HT_SHIFT_REF_IND, block_states); >> - *sp |= jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length) << pLSB; >> + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) != 0) { >> + jpeg2000_modify_state(i, j, stride, 1 << HT_SHIFT_REF_IND, block_states); >> + bit = jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length); >> + tmp = 0xFFFFFFFE | (uint32_t)bit; >> + tmp <<= pLSB; >> + sp[0] &= tmp; >> + sp[0] |= 1 << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) >> } >> } >> } >> @@ -1146,21 +1172,24 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int >> for (int j = 0; j < width; j++) { >> for (int i = i_start; i < i_start + height; i++) { >> sp = &sample_buf[j + i * stride]; >> - if (jpeg2000_get_state(i, j, width, HT_SHIFT_SIGMA, block_states) != 0) { >> - jpeg2000_modify_state(i, j, width, 1 << HT_SHIFT_REF_IND, block_states); >> - *sp |= jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length) << pLSB; >> + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) != 0) { >> + jpeg2000_modify_state(i, j, stride, 1 << HT_SHIFT_REF_IND, block_states); >> + bit = jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length); >> + tmp = 0xFFFFFFFE | (uint32_t)bit; >> + tmp <<= pLSB; >> + sp[0] &= tmp; >> + sp[0] |= 1 << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) >> } >> } >> } >> - return 1; >> } >> >> >> int >> ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, >> - int width, int height, int magp, uint8_t roi_shift) >> + int width, int height, int M_b, uint8_t roi_shift) >> { >> - uint8_t p0 = 0; // Number of placeholder passes >> + uint8_t p0 = 0; // 3 * p0 = Number of placeholder passes >> uint32_t Lcup; // Length of HT cleanup segment >> uint32_t Lref; // Length of Refinement segment >> uint32_t Scup; // HT cleanup segment suffix length >> @@ -1174,7 +1203,7 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c >> >> int z_blk; // Number of ht coding pass >> >> - uint8_t empty_passes; >> + uint8_t num_plhd_passes; // Number of placeholder passes >> >> StateVars mag_sgn; // Magnitude and Sign >> StateVars mel; // Adaptive run-length coding >> @@ -1190,8 +1219,8 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c >> uint8_t *block_states = NULL; >> >> int32_t n, val; // Post-processing >> - >> - int32_t M_b = magp; >> + const uint32_t mask = UINT32_MAX >> (M_b + 1); // bit mask for ROI detection >> + uint8_t num_rempass; >> >> const int quad_buf_width = width + 4; >> const int quad_buf_height = height + 4; >> @@ -1201,22 +1230,17 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c >> av_assert0(width * height <= 4096); >> av_assert0(width * height > 0); >> >> - if (roi_shift) >> - avpriv_report_missing_feature(s->avctx, "ROI shift"); >> - >> memset(t1->data, 0, t1->stride * height * sizeof(*t1->data)); >> memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags)); >> >> if (cblk->npasses == 0) >> return 0; >> >> - if (cblk->npasses > 3) >> - p0 = 0; >> - else if (cblk->length == 0) >> - p0 = 1; >> - >> - empty_passes = p0 * 3; >> - z_blk = cblk->npasses - empty_passes; >> + num_rempass = cblk->npasses % 3; // Number of remainder passes >> + num_plhd_passes = num_rempass ? cblk->npasses - num_rempass : cblk->npasses - 3; >> + av_assert0(num_plhd_passes % 3 == 0); >> + p0 = num_plhd_passes / 3; >> + z_blk = cblk->npasses - num_plhd_passes; >> >> if (z_blk <= 0) >> return 0; // No passes within this set, continue >> @@ -1231,7 +1255,11 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c >> } >> Dcup = cblk->data; >> Dref = cblk->data + Lcup; // Dref comes after the refinement segment >> + >> + cblk->data[cblk->length] = 0xFF; // an extra byte for refinement segment (buffer->last) >> + >> S_blk = p0 + cblk->zbp; >> + cblk->zbp = S_blk - 1; >> pLSB = 30 - S_blk; >> >> Scup = (Dcup[Lcup - 1] << 4) + (Dcup[Lcup - 2] & 0x0F); >> @@ -1277,31 +1305,32 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c >> goto free; >> } >> >> - if (cblk->npasses > 1) >> + if (z_blk > 1) >> jpeg2000_decode_sigprop_segment(cblk, width, height, quad_buf_width, Dref, Lref, >> pLSB - 1, sample_buf, block_states); >> >> - if (cblk->npasses > 2) { >> - >> - if (Lref < 2){ >> - av_log(s->avctx,AV_LOG_ERROR,"Invalid magnitude refinement length\n"); >> - ret = AVERROR_INVALIDDATA; >> - goto free; >> - } >> - if ((ret = jpeg2000_decode_magref_segment(width, height, quad_buf_width, Dref, Lref, >> - pLSB - 1, sample_buf, block_states)) < 0) >> - goto free; >> - } >> + if (z_blk > 2) >> + jpeg2000_decode_magref_segment(width, height, quad_buf_width, Dref, Lref, >> + pLSB - 1, sample_buf, block_states); >> >> pLSB = 31 - M_b; >> >> /* Reconstruct the sample values */ >> for (int y = 0; y < height; y++) { >> for (int x = 0; x < width; x++) { >> + int32_t sign; >> + >> n = x + (y * t1->stride); >> val = sample_buf[x + (y * quad_buf_width)]; >> + sign = val & INT32_MIN; >> + val &= INT32_MAX; >> + /* ROI shift, if necessary */ >> + if (roi_shift && (((uint32_t)val & ~mask) == 0)) >> + val <<= roi_shift; >> /* Convert sign-magnitude to two's complement. */ >> - val = val >> 31 ? 0x80000000 - val : val; >> + if (sign) >> + val = -val; >> + /* Shift down to 1 bit upper from decimal point for reconstruction value (= 0.5) */ >> val >>= (pLSB - 1); >> t1->data[n] = val; >> } >> diff --git a/libavcodec/jpeg2000htdec.h b/libavcodec/jpeg2000htdec.h >> index 572d095c92..8d6919a0de 100644 >> --- a/libavcodec/jpeg2000htdec.h >> +++ b/libavcodec/jpeg2000htdec.h >> @@ -29,6 +29,6 @@ >> >> int ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, >> Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, >> - int height, int magp, uint8_t roi_shift); >> + int height, int M_b, uint8_t roi_shift); >> >> #endif /* AVCODEC_JPEG2000HTDEC_H */ >> -- >> 2.34.1 >>
On Sat, Jun 15, 2024 at 12:15:16PM +0900, Osamu Watanabe wrote: > Signed-off-by: Osamu Watanabe <owatanab@es.takushoku-u.ac.jp> > --- > libavcodec/jpeg2000.h | 10 + > libavcodec/jpeg2000dec.c | 454 ++++++++++++++++++++++++++++++------- > libavcodec/jpeg2000dec.h | 7 + > libavcodec/jpeg2000htdec.c | 225 ++++++++++-------- > libavcodec/jpeg2000htdec.h | 2 +- > 5 files changed, 518 insertions(+), 180 deletions(-) this breaks decoding of tickets/4631/199.jp2 https://trac.ffmpeg.org/attachment/ticket/4631/199.jp2 and others thx [...]
diff --git a/libavcodec/jpeg2000.h b/libavcodec/jpeg2000.h index d004c08f10..93221d90ca 100644 --- a/libavcodec/jpeg2000.h +++ b/libavcodec/jpeg2000.h @@ -37,12 +37,14 @@ enum Jpeg2000Markers { JPEG2000_SOC = 0xff4f, // start of codestream + JPEG2000_CAP = 0xff50, // extended capabilities JPEG2000_SIZ = 0xff51, // image and tile size JPEG2000_COD, // coding style default JPEG2000_COC, // coding style component JPEG2000_TLM = 0xff55, // tile-part length, main header JPEG2000_PLM = 0xff57, // packet length, main header JPEG2000_PLT, // packet length, tile-part header + JPEG2000_CPF, // corresponding profile JPEG2000_QCD = 0xff5c, // quantization default JPEG2000_QCC, // quantization component JPEG2000_RGN, // region of interest @@ -58,6 +60,12 @@ enum Jpeg2000Markers { JPEG2000_EOC = 0xffd9, // end of codestream }; +enum JPEG2000_Ccap15_b14_15_params { + HTJ2K_HTONLY = 0, // HTONLY, bit 14 and 15 are 0 + HTJ2K_HTDECLARED, // HTDECLARED, bit 14 = 1 and bit 15 = 0 + HTJ2K_MIXED = 3, // MIXED, bit 14 and 15 are 1 +}; + #define JPEG2000_SOP_FIXED_BYTES 0xFF910004 #define JPEG2000_SOP_BYTE_LENGTH 6 @@ -192,6 +200,8 @@ typedef struct Jpeg2000Cblk { /* specific to HT code-blocks */ int zbp; int pass_lengths[2]; + uint8_t modes; // copy of SPcod/SPcoc field to parse HT-MIXED mode + uint8_t ht_plhd; // are we looking for HT placeholder passes? } Jpeg2000Cblk; // code block typedef struct Jpeg2000Prec { diff --git a/libavcodec/jpeg2000dec.c b/libavcodec/jpeg2000dec.c index d15502a527..d299c67cc7 100644 --- a/libavcodec/jpeg2000dec.c +++ b/libavcodec/jpeg2000dec.c @@ -54,6 +54,15 @@ #define HAD_COC 0x01 #define HAD_QCC 0x02 +// Values of flag for placeholder passes +enum HT_PLHD_STATUS { + HT_PLHD_OFF, + HT_PLHD_ON +}; + +#define HT_MIXED 0x80 // bit 7 of SPcod/SPcoc + + /* get_bits functions for JPEG2000 packet bitstream * It is a get_bit function with a bit-stuffing routine. If the value of the * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB. @@ -382,6 +391,9 @@ static int get_siz(Jpeg2000DecoderContext *s) } else if (ncomponents == 1 && s->precision == 8) { s->avctx->pix_fmt = AV_PIX_FMT_GRAY8; i = 0; + } else if (ncomponents == 1 && s->precision == 12) { + s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE; + i = 0; } } @@ -408,6 +420,73 @@ static int get_siz(Jpeg2000DecoderContext *s) s->avctx->bits_per_raw_sample = s->precision; return 0; } +/* get extended capabilities (CAP) marker segment */ +static int get_cap(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c) +{ + uint32_t Pcap; + uint16_t Ccap_i[32] = { 0 }; + uint16_t Ccap_15; + uint8_t P; + + if (bytestream2_get_bytes_left(&s->g) < 6) { + av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for CAP\n"); + return AVERROR_INVALIDDATA; + } + + Pcap = bytestream2_get_be32u(&s->g); + s->isHT = (Pcap >> (31 - (15 - 1))) & 1; + for (int i = 0; i < 32; i++) { + if ((Pcap >> (31 - i)) & 1) + Ccap_i[i] = bytestream2_get_be16u(&s->g); + } + Ccap_15 = Ccap_i[14]; + if (s->isHT == 1) { + av_log(s->avctx, AV_LOG_INFO, "This is an HTJ2K codestream.\n"); + // Bits 14-15 + switch ((Ccap_15 >> 14) & 0x3) { + case 0x3: + s->Ccap15_b14_15 = HTJ2K_MIXED; + break; + case 0x1: + s->Ccap15_b14_15 = HTJ2K_HTDECLARED; + break; + case 0x0: + s->Ccap15_b14_15 = HTJ2K_HTONLY; + break; + default: + av_log(s->avctx, AV_LOG_ERROR, "Unknown CCap value.\n"); + return AVERROR(EINVAL); + break; + } + // Bit 13 + if ((Ccap_15 >> 13) & 1) { + av_log(s->avctx, AV_LOG_ERROR, "MULTIHT set is not supported.\n"); + return AVERROR_PATCHWELCOME; + } + // Bit 12 + s->Ccap15_b12 = (Ccap_15 >> 12) & 1; + // Bit 11 + s->Ccap15_b11 = (Ccap_15 >> 11) & 1; + // Bit 5 + s->Ccap15_b05 = (Ccap_15 >> 5) & 1; + // Bit 0-4 + P = Ccap_15 & 0x1F; + if (!P) + s->HT_MAGB = 8; + else if (P < 20) + s->HT_MAGB = P + 8; + else if (P < 31) + s->HT_MAGB = 4 * (P - 19) + 27; + else + s->HT_MAGB = 74; + + if (s->HT_MAGB > 31) { + av_log(s->avctx, AV_LOG_ERROR, "Available internal precision is exceeded (MAGB> 31).\n"); + return AVERROR_PATCHWELCOME; + } + } + return 0; +} /* get common part for COD and COC segments */ static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c) @@ -802,6 +881,15 @@ static int read_crg(Jpeg2000DecoderContext *s, int n) bytestream2_skip(&s->g, n - 2); return 0; } + +static int read_cpf(Jpeg2000DecoderContext *s, int n) +{ + if (bytestream2_get_bytes_left(&s->g) < (n - 2)) + return AVERROR_INVALIDDATA; + bytestream2_skip(&s->g, n - 2); + return 0; +} + /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1 * Used to know the number of tile parts and lengths. * There may be multiple TLMs in the header. @@ -965,6 +1053,10 @@ static int init_tile(Jpeg2000DecoderContext *s, int tileno) comp->roi_shift = s->roi_shift[compno]; if (!codsty->init) return AVERROR_INVALIDDATA; + if (s->isHT && (!s->Ccap15_b05) && (!codsty->transform)) + av_log(s->avctx, AV_LOG_WARNING, "Transformation = 0 (lossy DWT) is found in HTREV HT set\n"); + if (s->isHT && s->Ccap15_b14_15 != (codsty->cblk_style >> 6) && s->Ccap15_b14_15 != HTJ2K_HTONLY) + av_log(s->avctx, AV_LOG_WARNING, "SPcod/SPcoc value does not match bit 14-15 values of Ccap15\n"); if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty, s->cbps[compno], s->cdx[compno], s->cdy[compno], s->avctx)) @@ -1067,100 +1159,275 @@ static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int incl, newpasses, llen; void *tmp; - if (cblk->npasses) - incl = get_bits(s, 1); - else + if (!cblk->incl) { + incl = 0; + cblk->modes = codsty->cblk_style; + if (cblk->modes >= JPEG2000_CTSY_HTJ2K_F) + cblk->ht_plhd = HT_PLHD_ON; + if (layno > 0) + incl = tag_tree_decode(s, prec->cblkincl + cblkno, 0 + 1) == 0; incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno; - if (!incl) - continue; - else if (incl < 0) - return incl; - - if (!cblk->npasses) { - int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100); - int v = expn[bandno] + numgbits - 1 - zbp; - if (v < 0 || v > 30) { - av_log(s->avctx, AV_LOG_ERROR, - "nonzerobits %d invalid or unsupported\n", v); - return AVERROR_INVALIDDATA; + if (incl) { + int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100); + int v = expn[bandno] + numgbits - 1 - (zbp - tile->comp->roi_shift); + if (v < 0 || v > 30) { + av_log(s->avctx, AV_LOG_ERROR, + "nonzerobits %d invalid or unsupported\n", v); + return AVERROR_INVALIDDATA; + } + cblk->incl = 1; + cblk->nonzerobits = v; + cblk->zbp = zbp; + cblk->lblock = 3; } - cblk->zbp = zbp; - cblk->nonzerobits = v; - } - if ((newpasses = getnpasses(s)) < 0) - return newpasses; - av_assert2(newpasses > 0); - if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) { - avpriv_request_sample(s->avctx, "Too many passes"); - return AVERROR_PATCHWELCOME; - } - if ((llen = getlblockinc(s)) < 0) - return llen; - if (cblk->lblock + llen + av_log2(newpasses) > 16) { - avpriv_request_sample(s->avctx, - "Block with length beyond 16 bits"); - return AVERROR_PATCHWELCOME; + } else { + incl = get_bits(s, 1); } - cblk->lblock += llen; - - cblk->nb_lengthinc = 0; - cblk->nb_terminationsinc = 0; - av_free(cblk->lengthinc); - cblk->lengthinc = av_calloc(newpasses, sizeof(*cblk->lengthinc)); - if (!cblk->lengthinc) - return AVERROR(ENOMEM); - tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start)); - if (!tmp) - return AVERROR(ENOMEM); - cblk->data_start = tmp; - do { - int newpasses1 = 0; - - while (newpasses1 < newpasses) { - newpasses1 ++; - if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) { - cblk->nb_terminationsinc ++; - break; + if (incl) { + uint8_t bypass_term_threshold = 0; + uint8_t bits_to_read = 0; + uint32_t segment_bytes = 0; + int32_t segment_passes = 0; + uint8_t next_segment_passes = 0; + int32_t href_passes, pass_bound; + uint32_t tmp_length = 0; + + if ((newpasses = getnpasses(s)) <= 0) + return newpasses; + if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) { + avpriv_request_sample(s->avctx, "Too many passes"); + return AVERROR_PATCHWELCOME; + } + if ((llen = getlblockinc(s)) < 0) + return llen; + if (cblk->lblock + llen + av_log2(newpasses) > 16) { + avpriv_request_sample(s->avctx, + "Block with length beyond 16 bits"); + return AVERROR_PATCHWELCOME; + } + cblk->nb_lengthinc = 0; + cblk->nb_terminationsinc = 0; + av_free(cblk->lengthinc); + cblk->lengthinc = av_calloc(newpasses, sizeof(*cblk->lengthinc)); + if (!cblk->lengthinc) + return AVERROR(ENOMEM); + tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, + sizeof(*cblk->data_start)); + if (!tmp) + return AVERROR(ENOMEM); + cblk->data_start = tmp; + cblk->lblock += llen; + + if (cblk->ht_plhd) { + href_passes = (cblk->npasses + newpasses - 1) % 3; + segment_passes = newpasses - href_passes; + pass_bound = 2; + bits_to_read = cblk->lblock; + if (segment_passes < 1) { + // No possible HT Cleanup pass here; may have placeholder passes + // or an original J2K block bit-stream (in MIXED mode). + segment_passes = newpasses; + while (pass_bound <= segment_passes) { + bits_to_read++; + pass_bound += pass_bound; + } + segment_bytes = get_bits(s, bits_to_read); + if (segment_bytes) { + if (cblk->modes & HT_MIXED) { + cblk->ht_plhd = HT_PLHD_OFF; + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); + } + else { + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); + } + } + } else { + while (pass_bound <= segment_passes) { + bits_to_read++; + pass_bound += pass_bound; + } + segment_bytes = get_bits(s, bits_to_read); + if (segment_bytes) { + // No more placeholder passes + if (!(cblk->modes & HT_MIXED)) { + // Must be the first HT Cleanup pass + if (segment_bytes < 2) + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); + next_segment_passes = 2; + cblk->ht_plhd = HT_PLHD_OFF; + // Write length information for HT CleanUp segment + cblk->pass_lengths[0] = segment_bytes; + } else if (cblk->lblock > 3 && segment_bytes > 1 + && (segment_bytes >> (bits_to_read - 1)) == 0) { + // Must be the first HT Cleanup pass, since length MSB is 0 + next_segment_passes = 2; + cblk->ht_plhd = HT_PLHD_OFF; + // Write length information for HT CleanUp segment + cblk->pass_lengths[0] = segment_bytes; + } else { + // Must have an original (non-HT) block coding pass + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); + cblk->ht_plhd = HT_PLHD_OFF; + segment_passes = newpasses; + while (pass_bound <= segment_passes) { + bits_to_read++; + pass_bound += pass_bound; + segment_bytes <<= 1; + segment_bytes += get_bits(s, 1); + } + } + } else { + // Probably parsing placeholder passes, but we need to read an + // extra length bit to verify this, since prior to the first + // HT Cleanup pass, the number of length bits read for a + // contributing code-block is dependent on the number of passes + // being included, as if it were a non-HT code-block. + segment_passes = newpasses; + if (pass_bound <= segment_passes) { + while (1) { + bits_to_read++; + pass_bound += pass_bound; + segment_bytes <<= 1; + segment_bytes += get_bits(s, 1); + if (pass_bound > segment_passes) + break; + } + if (segment_bytes) { + if (cblk->modes & HT_MIXED) { + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); + cblk->ht_plhd = HT_PLHD_OFF; + } else { + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); + } + } + } + } } + } else if (cblk->modes & JPEG2000_CTSY_HTJ2K_F) { + // Quality layer commences with a non-initial HT coding pass + if(bits_to_read != 0) + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); + segment_passes = cblk->npasses % 3; + if (segment_passes == 0) { + // newpasses is a HT Cleanup pass; next segment has refinement passes + segment_passes = 1; + next_segment_passes = 2; + if (segment_bytes == 1) + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); + } else { + // newpasses = 1 means npasses is HT SigProp; 2 means newpasses is + // HT MagRef pass + segment_passes = newpasses > 1 ? 3 - segment_passes : 1; + next_segment_passes = 1; + bits_to_read = av_log2(segment_passes); + } + bits_to_read = (uint8_t) (bits_to_read + cblk->lblock); + segment_bytes = get_bits(s, bits_to_read); + // Write length information for HT Refinment segment + cblk->pass_lengths[1] += segment_bytes; + } else if (!(cblk->modes & (JPEG2000_CBLK_TERMALL | JPEG2000_CBLK_BYPASS))) { + // Common case for non-HT code-blocks; we have only one segment + bits_to_read = (uint8_t) cblk->lblock + av_log2((uint8_t) newpasses); + segment_bytes = get_bits(s, bits_to_read); + segment_passes = newpasses; + } else if (cblk->modes & JPEG2000_CBLK_TERMALL) { + // RESTART MODE + bits_to_read = cblk->lblock; + segment_bytes = get_bits(s, bits_to_read); + segment_passes = 1; + next_segment_passes = 1; + cblk->nb_terminationsinc++; + } else { + // BYPASS MODE + bypass_term_threshold = 10; + if(bits_to_read != 0) + av_log(s->avctx, AV_LOG_WARNING, "Length information for a codeblock is invalid\n"); + if (cblk->npasses < bypass_term_threshold) { + // May have from 1 to 10 uninterrupted passes before 1st RAW SigProp + segment_passes = bypass_term_threshold - cblk->npasses; + if (segment_passes > newpasses) + segment_passes = newpasses; + while ((2 << bits_to_read) <= segment_passes) + bits_to_read++; + next_segment_passes = 2; + } else if ((cblk->npasses - bypass_term_threshold) % 3 < 2) { + // 0 means newpasses is a RAW SigProp; 1 means newpasses is a RAW MagRef pass + segment_passes = newpasses > 1 ? 2 - (cblk->npasses - bypass_term_threshold) % 3 : 1; + bits_to_read = av_log2(segment_passes); + next_segment_passes = 1; + } else { + // newpasses is an isolated Cleanup pass that precedes a RAW SigProp pass + segment_passes = 1; + next_segment_passes = 2; + } + bits_to_read = (uint8_t) (bits_to_read + cblk->lblock); + segment_bytes = get_bits(s, bits_to_read); } - - if (newpasses > 1 && (codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F)) { - // Retrieve pass lengths for each pass - int href_passes = (cblk->npasses + newpasses - 1) % 3; - int eb = av_log2(newpasses - href_passes); - int extra_bit = newpasses > 2 ? 1 : 0; - if ((ret = get_bits(s, llen + eb + 3)) < 0) - return ret; - cblk->pass_lengths[0] = ret; - if ((ret = get_bits(s, llen + 3 + extra_bit)) < 0) - return ret; - cblk->pass_lengths[1] = ret; - ret = cblk->pass_lengths[0] + cblk->pass_lengths[1]; + // Update cblk->npasses and write length information + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; + + if ((cblk->modes & JPEG2000_CTSY_HTJ2K_F) && cblk->ht_plhd == HT_PLHD_OFF) { + newpasses -= (uint8_t) segment_passes; + while (newpasses > 0) { + segment_passes = newpasses > 1 ? next_segment_passes : 1; + next_segment_passes = (uint8_t) (3 - next_segment_passes); + bits_to_read = (uint8_t) (cblk->lblock + av_log2(segment_passes)); + segment_bytes = get_bits(s, bits_to_read); + newpasses -= (uint8_t) (segment_passes); + // This is a FAST Refinement pass + // Write length information for HT Refinement segment + cblk->pass_lengths[1] += segment_bytes; + // Update cblk->npasses and write length information + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; + } } else { - if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0) - return ret; - cblk->pass_lengths[0] = ret; + newpasses -= (uint8_t) (segment_passes); + while (newpasses > 0) { + if (bypass_term_threshold != 0) { + segment_passes = newpasses > 1 ? next_segment_passes : 1; + next_segment_passes = (uint8_t) (3 - next_segment_passes); + bits_to_read = (uint8_t) (cblk->lblock + av_log2(segment_passes)); + } else { + if ((cblk->modes & JPEG2000_CBLK_TERMALL) == 0) + av_log(s->avctx, AV_LOG_WARNING, "Corrupted packet header is found.\n"); + segment_passes = 1; + bits_to_read = cblk->lblock; + } + segment_bytes = get_bits(s, bits_to_read); + newpasses -= (uint8_t) (segment_passes); + + // Update cblk->npasses and write length information + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; + cblk->nb_terminationsinc++; + } } - if (ret > cblk->data_allocated) { - size_t new_size = FFMAX(2*cblk->data_allocated, ret); + + for (int i = 0; i < cblk->nb_lengthinc; ++i) + tmp_length = (tmp_length < cblk->lengthinc[i]) ? cblk->lengthinc[i] : tmp_length; + + if (tmp_length > cblk->data_allocated) { + size_t new_size = FFMAX(2 * cblk->data_allocated, tmp_length); void *new = av_realloc(cblk->data, new_size); if (new) { cblk->data = new; cblk->data_allocated = new_size; } } - if (ret > cblk->data_allocated) { + if (tmp_length > cblk->data_allocated) { avpriv_request_sample(s->avctx, "Block with lengthinc greater than %"SIZE_SPECIFIER"", cblk->data_allocated); return AVERROR_PATCHWELCOME; } - cblk->lengthinc[cblk->nb_lengthinc++] = ret; - cblk->npasses += newpasses1; - newpasses -= newpasses1; - } while(newpasses); + } else { + // This codeblock has no contribution to the current packet + continue; + } } } jpeg2000_flush(s); @@ -1695,7 +1962,7 @@ static int decode_cblk(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *cod Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, int height, int bandpos, uint8_t roi_shift) { - int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1 + roi_shift; + int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1; int pass_cnt = 0; int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC; int term_cnt = 0; @@ -1909,7 +2176,7 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile Jpeg2000Band *band = rlevel->band + bandno; int cblkno = 0, bandpos; /* See Rec. ITU-T T.800, Equation E-2 */ - int magp = quantsty->expn[subbandno] + quantsty->nguardbits - 1; + int M_b = quantsty->expn[subbandno] + quantsty->nguardbits - 1; bandpos = bandno + (reslevelno > 0); @@ -1917,8 +2184,8 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile band->coord[1][0] == band->coord[1][1]) continue; - if ((codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) && magp >= 31) { - avpriv_request_sample(s->avctx, "JPEG2000_CTSY_HTJ2K_F and magp >= 31"); + if ((codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) && M_b >= 31) { + avpriv_request_sample(s->avctx, "JPEG2000_CTSY_HTJ2K_F and M_b >= 31"); return AVERROR_PATCHWELCOME; } @@ -1935,11 +2202,11 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile Jpeg2000Cblk *cblk = prec->cblk + cblkno; - if (codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) + if (cblk->modes & JPEG2000_CTSY_HTJ2K_F) ret = ff_jpeg2000_decode_htj2k(s, codsty, &t1, cblk, cblk->coord[0][1] - cblk->coord[0][0], cblk->coord[1][1] - cblk->coord[1][0], - magp, comp->roi_shift); + M_b, comp->roi_shift); else ret = decode_cblk(s, codsty, &t1, cblk, cblk->coord[0][1] - cblk->coord[0][0], @@ -2178,22 +2445,42 @@ static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s) if (!s->tile) s->numXtiles = s->numYtiles = 0; break; + case JPEG2000_CAP: + if (!s->ncomponents) { + av_log(s->avctx, AV_LOG_WARNING, "CAP marker segment shall come after SIZ\n"); + } + ret = get_cap(s, codsty); + break; case JPEG2000_COC: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) + av_log(s->avctx, AV_LOG_WARNING, "COC marker is found in HOMOGENEOUS HT set\n"); ret = get_coc(s, codsty, properties); break; case JPEG2000_COD: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) + av_log(s->avctx, AV_LOG_WARNING, "COD marker is found in HOMOGENEOUS HT set\n"); ret = get_cod(s, codsty, properties); break; case JPEG2000_RGN: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) + av_log(s->avctx, AV_LOG_WARNING, "RGB marker is found in HOMOGENEOUS HT set\n"); ret = get_rgn(s, len); + if ((!s->Ccap15_b12) && s->isHT) + av_log(s->avctx, AV_LOG_WARNING, "RGN marker is found in RGNFREE HT set\n"); break; case JPEG2000_QCC: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) + av_log(s->avctx, AV_LOG_WARNING, "QCC marker is found in HOMOGENEOUS HT set\n"); ret = get_qcc(s, len, qntsty, properties); break; case JPEG2000_QCD: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) + av_log(s->avctx, AV_LOG_WARNING, "QCD marker is found in HOMOGENEOUS HT set\n"); ret = get_qcd(s, len, qntsty, properties); break; case JPEG2000_POC: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) + av_log(s->avctx, AV_LOG_WARNING, "POC marker is found in HOMOGENEOUS HT set\n"); ret = get_poc(s, len, poc); break; case JPEG2000_SOT: @@ -2243,9 +2530,14 @@ static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s) "Cannot have both PPT and PPM marker.\n"); return AVERROR_INVALIDDATA; } - + if ((!s->Ccap15_b11) && s->isHT) + av_log(s->avctx, AV_LOG_WARNING, "PPT marker is found in HOMOGENEOUS HT set\n"); ret = get_ppt(s, len); break; + case JPEG2000_CPF: + // Corresponding profile marker + ret = read_cpf(s, len); + break; default: av_log(s->avctx, AV_LOG_ERROR, "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n", diff --git a/libavcodec/jpeg2000dec.h b/libavcodec/jpeg2000dec.h index d0ca6e7a79..326a572722 100644 --- a/libavcodec/jpeg2000dec.h +++ b/libavcodec/jpeg2000dec.h @@ -112,6 +112,13 @@ typedef struct Jpeg2000DecoderContext { Jpeg2000Tile *tile; Jpeg2000DSPContext dsp; + uint8_t isHT; // HTJ2K? + uint8_t Ccap15_b14_15; // HTONLY(= 0) or HTDECLARED(= 1) or MIXED(= 3) ? + uint8_t Ccap15_b12; // RGNFREE(= 0) or RGN(= 1)? + uint8_t Ccap15_b11; // HOMOGENEOUS(= 0) or HETEROGENEOUS(= 1) ? + uint8_t Ccap15_b05; // HTREV(= 0) or HTIRV(= 1) ? + uint8_t HT_MAGB; // MAGB value + /*options parameters*/ int reduction_factor; } Jpeg2000DecoderContext; diff --git a/libavcodec/jpeg2000htdec.c b/libavcodec/jpeg2000htdec.c index eba0936089..beb4a386b0 100644 --- a/libavcodec/jpeg2000htdec.c +++ b/libavcodec/jpeg2000htdec.c @@ -122,7 +122,7 @@ static void jpeg2000_init_mel(StateVars *s, uint32_t Pcup) static void jpeg2000_init_mag_ref(StateVars *s, uint32_t Lref) { - s->pos = Lref - 2; + s->pos = Lref - 1; s->bits = 0; s->last = 0xFF; s->tmp = 0; @@ -145,9 +145,10 @@ static void jpeg2000_init_mel_decoder(MelDecoderState *mel_state) static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *array) { uint64_t tmp = 0; - int32_t position = buffer->pos - 4; uint32_t new_bits = 32; + buffer->last = array[buffer->pos + 1]; + if (buffer->bits_left >= 32) return 0; // enough data, no need to pull in more bits @@ -157,9 +158,24 @@ static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *ar * the bottom most bits. */ - for(int i = FFMAX(0, position + 1); i <= buffer->pos + 1; i++) - tmp = 256*tmp + array[i]; - + if (buffer->pos >= 3) { // Common case; we have at least 4 bytes available + tmp = array[buffer->pos - 3]; + tmp = (tmp << 8) | array[buffer->pos - 2]; + tmp = (tmp << 8) | array[buffer->pos - 1]; + tmp = (tmp << 8) | array[buffer->pos]; + tmp = (tmp << 8) | buffer->last; // For stuffing bit detection + buffer->pos -= 4; + } else { + if (buffer->pos >= 2) + tmp = array[buffer->pos - 2]; + if (buffer->pos >= 1) + tmp = (tmp << 8) | array[buffer->pos - 1]; + if (buffer->pos >= 0) + tmp = (tmp << 8) | array[buffer->pos]; + buffer->pos = 0; + tmp = (tmp << 8) | buffer->last; // For stuffing bit detection + } + // Now remove any stuffing bits, shifting things down as we go if ((tmp & 0x7FFF000000) > 0x7F8F000000) { tmp &= 0x7FFFFFFFFF; new_bits--; @@ -176,13 +192,11 @@ static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *ar tmp = (tmp & 0x0000007FFF) + ((tmp & 0xFFFFFF0000) >> 1); new_bits--; } - - tmp >>= 8; // Remove temporary byte loaded + tmp >>= 8; // Shifts away the extra byte we imported /* Add bits to the MSB of the bit buffer */ buffer->bit_buf |= tmp << buffer->bits_left; buffer->bits_left += new_bits; - buffer->pos = FFMAX(0, position); return 0; } @@ -406,6 +420,7 @@ static void recover_mag_sgn(StateVars *mag_sgn, uint8_t pos, uint16_t q, int32_t E[n] = 32 - ff_clz(v[pos][i] | 1); mu_n[n] = (v[pos][i] >> 1) + 1; mu_n[n] <<= pLSB; + mu_n[n] |= (1 << (pLSB - 1)); // Add 0.5 (reconstruction parameter = 1/2) mu_n[n] |= ((uint32_t) (v[pos][i] & 1)) << 31; // sign bit. } } @@ -414,7 +429,7 @@ static void recover_mag_sgn(StateVars *mag_sgn, uint8_t pos, uint16_t q, int32_t static int jpeg2000_import_bit(StateVars *stream, const uint8_t *array, uint32_t length) { int cond = stream->pos < length; - int pos = FFMIN(stream->pos, length); + int pos = FFMIN(stream->pos, length - 1); if (stream->bits == 0) { stream->bits = (stream->tmp == 0xFF) ? 7 : 8; stream->pos += cond; @@ -426,14 +441,22 @@ static int jpeg2000_import_bit(StateVars *stream, const uint8_t *array, uint32_t static int jpeg2000_peek_bit(StateVars *stream, const uint8_t *array, uint32_t length) { + uint8_t bit; + if (stream->bits == 0) { - int cond = stream->pos < length; - int pos = FFMIN(stream->pos, length); - stream->bits = (stream->tmp == 0xFF) ? 7 : 8; - stream->pos += cond; - stream->tmp = cond ? array[pos] : 0xFF; + stream->bits = (stream->last == 0xFF) ? 7 : 8; + if (stream->pos < length) { + stream->tmp = array[stream->pos]; + stream->pos++; + } else { + stream->tmp = 0; + } + stream->last = stream->tmp; } - return (stream->tmp >> stream->bits) & 1; + bit = stream->tmp & 1; + stream->tmp >>= 1; + stream->bits--; + return bit; } static int jpeg2000_decode_mel_sym(MelDecoderState *mel_state, @@ -994,66 +1017,63 @@ static void jpeg2000_calc_mbr(uint8_t *mbr, const uint16_t i, const uint16_t j, const uint32_t mbr_info, uint8_t causal_cond, uint8_t *block_states, int stride) { - int local_mbr = 0; - - local_mbr |= jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SIGMA, block_states); - local_mbr |= jpeg2000_get_state(i - 1, j + 0, stride, HT_SHIFT_SIGMA, block_states); - local_mbr |= jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_SIGMA, block_states); - - local_mbr |= jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_SIGMA, block_states); - local_mbr |= jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_SIGMA, block_states); - - local_mbr |= jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; - local_mbr |= jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; - local_mbr |= jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; - - local_mbr |= jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SCAN, block_states); - local_mbr |= jpeg2000_get_state(i - 1, j + 0, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SCAN, block_states); - local_mbr |= jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_SCAN, block_states); - - local_mbr |= jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_SCAN, block_states); - local_mbr |= jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_SCAN, block_states); - - local_mbr |= jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_SCAN, block_states) * causal_cond; - local_mbr |= jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_SCAN, block_states) * causal_cond; - local_mbr |= jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_SCAN, block_states) * causal_cond; - - *mbr |= local_mbr; + uint8_t *state_p0 = block_states + i * stride + j; + uint8_t *state_p1 = block_states + (i + 1) * stride + j; + uint8_t *state_p2 = block_states + (i + 2) * stride + j; + + uint8_t mbr0 = state_p0[0] | state_p0[1] | state_p0[2]; + uint8_t mbr1 = state_p1[0] | state_p1[2]; + uint8_t mbr2 = state_p2[0] | state_p2[1] | state_p2[2]; + *mbr = mbr0 | mbr1 | (mbr2 & causal_cond); + *mbr |= (mbr0 >> HT_SHIFT_REF) & (mbr0 >> HT_SHIFT_SCAN); + *mbr |= (mbr1 >> HT_SHIFT_REF) & (mbr1 >> HT_SHIFT_SCAN); + *mbr |= (mbr2 >> HT_SHIFT_REF) & (mbr2 >> HT_SHIFT_SCAN) & causal_cond; + *mbr &= 1; } static void jpeg2000_process_stripes_block(StateVars *sig_prop, int i_s, int j_s, int width, int height, int stride, int pLSB, int32_t *sample_buf, uint8_t *block_states, - uint8_t *magref_segment, uint32_t magref_length) + uint8_t *magref_segment, uint32_t magref_length, + uint8_t is_causal) { for (int j = j_s; j < j_s + width; j++) { uint32_t mbr_info = 0; for (int i = i_s; i < i_s + height; i++) { - int modify_state, cond; + int modify_state; uint8_t bit; - uint8_t causal_cond = i != (i_s + height - 1); + uint8_t causal_cond = (is_causal == 0) || (i != (i_s + height - 1)); int32_t *sp = &sample_buf[j + (i * (stride))]; uint8_t mbr = 0; - if (jpeg2000_get_state(i, j, stride - 2, HT_SHIFT_SIGMA, block_states) == 0) + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) == 0) jpeg2000_calc_mbr(&mbr, i, j, mbr_info & 0x1EF, causal_cond, block_states, stride); mbr_info >>= 3; - cond = mbr != 0; - bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); - *sp |= (bit * cond) << pLSB; - sig_prop->bits -= cond; - modify_state = (((1 << HT_SHIFT_REF_IND) | (1 << HT_SHIFT_REF)) * cond) | 1 << HT_SHIFT_SCAN; + + modify_state = block_states[(i + 1) * stride + (j + 1)]; + modify_state |= 1 << HT_SHIFT_SCAN; + if (mbr != 0) { + modify_state |= 1 << HT_SHIFT_REF_IND; + bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); + modify_state |= bit << HT_SHIFT_REF; + *sp |= bit << pLSB; + *sp |= bit << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) + } jpeg2000_modify_state(i, j, stride, modify_state, block_states); } } + // decode sign + for (int j = j_s; j < j_s + width; j++) { + for (int i = i_s; i < i_s + height; i++) { + uint8_t bit; + int32_t *sp = &sample_buf[j + (i * (stride))]; + uint8_t *state_p = block_states + (i + 1) * stride + (j + 1); + if ((state_p[0] >> HT_SHIFT_REF) & 1) { + bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); + *sp |= (int32_t)bit << 31; + } + } + } } /** @@ -1074,6 +1094,7 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, int last_width; uint16_t i = 0, j = 0; + uint8_t is_causal = cblk->modes & JPEG2000_CBLK_VSC; jpeg2000_init_zero(&sp_dec); @@ -1082,14 +1103,14 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, for (int n2 = 0; n2 < num_h_stripe; n2++) { jpeg2000_process_stripes_block(&sp_dec, i, j, b_width, b_height, stride, pLSB, sample_buf, block_states, magref_segment, - magref_length); + magref_length, is_causal); j += 4; } last_width = width % 4; if (last_width) jpeg2000_process_stripes_block(&sp_dec, i, j, last_width, b_height, stride, pLSB, sample_buf, block_states, magref_segment, - magref_length); + magref_length, is_causal); i += 4; } @@ -1099,20 +1120,20 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, for (int n2 = 0; n2 < num_h_stripe; n2++) { jpeg2000_process_stripes_block(&sp_dec, i, j, b_width, b_height, stride, pLSB, sample_buf, block_states, magref_segment, - magref_length); + magref_length, is_causal); j += 4; } last_width = width % 4; if (last_width) jpeg2000_process_stripes_block(&sp_dec, i, j, last_width, b_height, stride, pLSB, sample_buf, block_states, magref_segment, - magref_length); + magref_length, is_causal); } /** * See procedure decodeSigPropMag at Rec. ITU-T T.814, 7.5. */ -static int +static void jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int stride, uint8_t *magref_segment,uint32_t magref_length, uint8_t pLSB, int32_t *sample_buf, uint8_t *block_states) @@ -1123,7 +1144,8 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int uint16_t height = 4; uint16_t i_start = 0; int32_t *sp; - + int32_t bit; + int32_t tmp; jpeg2000_init_mag_ref(&mag_ref, magref_length); for (int n1 = 0; n1 < num_v_stripe; n1++) { @@ -1134,9 +1156,13 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int * Rec. ITU-T T.814, Figure 7. */ sp = &sample_buf[j + i * stride]; - if (jpeg2000_get_state(i, j, width, HT_SHIFT_SIGMA, block_states) != 0) { - jpeg2000_modify_state(i, j, width, 1 << HT_SHIFT_REF_IND, block_states); - *sp |= jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length) << pLSB; + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) != 0) { + jpeg2000_modify_state(i, j, stride, 1 << HT_SHIFT_REF_IND, block_states); + bit = jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length); + tmp = 0xFFFFFFFE | (uint32_t)bit; + tmp <<= pLSB; + sp[0] &= tmp; + sp[0] |= 1 << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) } } } @@ -1146,21 +1172,24 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int for (int j = 0; j < width; j++) { for (int i = i_start; i < i_start + height; i++) { sp = &sample_buf[j + i * stride]; - if (jpeg2000_get_state(i, j, width, HT_SHIFT_SIGMA, block_states) != 0) { - jpeg2000_modify_state(i, j, width, 1 << HT_SHIFT_REF_IND, block_states); - *sp |= jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length) << pLSB; + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) != 0) { + jpeg2000_modify_state(i, j, stride, 1 << HT_SHIFT_REF_IND, block_states); + bit = jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length); + tmp = 0xFFFFFFFE | (uint32_t)bit; + tmp <<= pLSB; + sp[0] &= tmp; + sp[0] |= 1 << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) } } } - return 1; } int ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, - int width, int height, int magp, uint8_t roi_shift) + int width, int height, int M_b, uint8_t roi_shift) { - uint8_t p0 = 0; // Number of placeholder passes + uint8_t p0 = 0; // 3 * p0 = Number of placeholder passes uint32_t Lcup; // Length of HT cleanup segment uint32_t Lref; // Length of Refinement segment uint32_t Scup; // HT cleanup segment suffix length @@ -1174,7 +1203,7 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c int z_blk; // Number of ht coding pass - uint8_t empty_passes; + uint8_t num_plhd_passes; // Number of placeholder passes StateVars mag_sgn; // Magnitude and Sign StateVars mel; // Adaptive run-length coding @@ -1190,8 +1219,8 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c uint8_t *block_states = NULL; int32_t n, val; // Post-processing - - int32_t M_b = magp; + const uint32_t mask = UINT32_MAX >> (M_b + 1); // bit mask for ROI detection + uint8_t num_rempass; const int quad_buf_width = width + 4; const int quad_buf_height = height + 4; @@ -1201,22 +1230,17 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c av_assert0(width * height <= 4096); av_assert0(width * height > 0); - if (roi_shift) - avpriv_report_missing_feature(s->avctx, "ROI shift"); - memset(t1->data, 0, t1->stride * height * sizeof(*t1->data)); memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags)); if (cblk->npasses == 0) return 0; - if (cblk->npasses > 3) - p0 = 0; - else if (cblk->length == 0) - p0 = 1; - - empty_passes = p0 * 3; - z_blk = cblk->npasses - empty_passes; + num_rempass = cblk->npasses % 3; // Number of remainder passes + num_plhd_passes = num_rempass ? cblk->npasses - num_rempass : cblk->npasses - 3; + av_assert0(num_plhd_passes % 3 == 0); + p0 = num_plhd_passes / 3; + z_blk = cblk->npasses - num_plhd_passes; if (z_blk <= 0) return 0; // No passes within this set, continue @@ -1231,7 +1255,11 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c } Dcup = cblk->data; Dref = cblk->data + Lcup; // Dref comes after the refinement segment + + cblk->data[cblk->length] = 0xFF; // an extra byte for refinement segment (buffer->last) + S_blk = p0 + cblk->zbp; + cblk->zbp = S_blk - 1; pLSB = 30 - S_blk; Scup = (Dcup[Lcup - 1] << 4) + (Dcup[Lcup - 2] & 0x0F); @@ -1277,31 +1305,32 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c goto free; } - if (cblk->npasses > 1) + if (z_blk > 1) jpeg2000_decode_sigprop_segment(cblk, width, height, quad_buf_width, Dref, Lref, pLSB - 1, sample_buf, block_states); - if (cblk->npasses > 2) { - - if (Lref < 2){ - av_log(s->avctx,AV_LOG_ERROR,"Invalid magnitude refinement length\n"); - ret = AVERROR_INVALIDDATA; - goto free; - } - if ((ret = jpeg2000_decode_magref_segment(width, height, quad_buf_width, Dref, Lref, - pLSB - 1, sample_buf, block_states)) < 0) - goto free; - } + if (z_blk > 2) + jpeg2000_decode_magref_segment(width, height, quad_buf_width, Dref, Lref, + pLSB - 1, sample_buf, block_states); pLSB = 31 - M_b; /* Reconstruct the sample values */ for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { + int32_t sign; + n = x + (y * t1->stride); val = sample_buf[x + (y * quad_buf_width)]; + sign = val & INT32_MIN; + val &= INT32_MAX; + /* ROI shift, if necessary */ + if (roi_shift && (((uint32_t)val & ~mask) == 0)) + val <<= roi_shift; /* Convert sign-magnitude to two's complement. */ - val = val >> 31 ? 0x80000000 - val : val; + if (sign) + val = -val; + /* Shift down to 1 bit upper from decimal point for reconstruction value (= 0.5) */ val >>= (pLSB - 1); t1->data[n] = val; } diff --git a/libavcodec/jpeg2000htdec.h b/libavcodec/jpeg2000htdec.h index 572d095c92..8d6919a0de 100644 --- a/libavcodec/jpeg2000htdec.h +++ b/libavcodec/jpeg2000htdec.h @@ -29,6 +29,6 @@ int ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, - int height, int magp, uint8_t roi_shift); + int height, int M_b, uint8_t roi_shift); #endif /* AVCODEC_JPEG2000HTDEC_H */
Signed-off-by: Osamu Watanabe <owatanab@es.takushoku-u.ac.jp> --- libavcodec/jpeg2000.h | 10 + libavcodec/jpeg2000dec.c | 454 ++++++++++++++++++++++++++++++------- libavcodec/jpeg2000dec.h | 7 + libavcodec/jpeg2000htdec.c | 225 ++++++++++-------- libavcodec/jpeg2000htdec.h | 2 +- 5 files changed, 518 insertions(+), 180 deletions(-)