Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

avcodec/jpeg2000dec: Add support for placeholder passes

Browse Source 
See Rec. ITU-T T.814 | ISO/IEC 15444-15, Annex B.

Signed-off-by: Pierre-Anthony Lemieux <pal@palemieux.com>
release/7.1
Osamu Watanabe 5 months ago committed by Pierre-Anthony Lemieux
parent fe1b196499
commit 48b14732d8
No known key found for this signature in database
GPG Key ID: 698FA1F0F8D4EED4
4 changed files with 326 additions and 118 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      libavcodec/jpeg2000.h
  2. 292
      libavcodec/jpeg2000dec.c
  3. 2
      libavcodec/jpeg2000dec.h
  4. 86
      libavcodec/jpeg2000htdec.c

2
libavcodec/jpeg2000.h
Unescape View File

@ -200,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 {

292
libavcodec/jpeg2000dec.c
Unescape View File

@ -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.
@ -1160,30 +1169,44 @@ 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) {
if (incl) {
int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100);
int v = expn[bandno] + numgbits - 1 - zbp;
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->zbp = zbp;
cblk->incl = 1;
cblk->nonzerobits = v;
cblk->zbp = zbp;
cblk->lblock = 3;
}
if ((newpasses = getnpasses(s)) < 0)
} else {
incl = get_bits(s, 1);
}
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;
int32_t newpasses_copy, npasses_copy;
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;
@ -1195,65 +1218,244 @@ static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
"Block with length beyond 16 bits");
return AVERROR_PATCHWELCOME;
}
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));
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;
// Count number of necessary terminations for non HT code block
newpasses_copy = newpasses;
npasses_copy = cblk->npasses;
if (!(cblk->modes & JPEG2000_CTSY_HTJ2K_F)) {
do {
int newpasses1 = 0;
while (newpasses1 < newpasses) {
newpasses1 ++;
if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
cblk->nb_terminationsinc ++;
while (newpasses1 < newpasses_copy) {
newpasses1++;
if (needs_termination(codsty->cblk_style, npasses_copy + newpasses1 - 1)) {
cblk->nb_terminationsinc++;
break;
}
}
npasses_copy += newpasses1;
newpasses_copy -= newpasses1;
} while (newpasses_copy);
}
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];
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 {
if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
return ret;
cblk->pass_lengths[0] = ret;
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");
}
}
}
}
if (ret > cblk->data_allocated) {
size_t new_size = FFMAX(2*cblk->data_allocated, ret);
}
} 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;
} 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);
}
// 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 {
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;
}
}
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);
@ -1788,7 +1990,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;
@ -2028,7 +2230,7 @@ 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],

2
libavcodec/jpeg2000dec.h
Unescape View File

@ -117,7 +117,7 @@ typedef struct Jpeg2000DecoderContext {
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_B; // MAGB value
uint8_t HT_B; // The parameter B for MAGBp value (see Table 4 in the Rec. ITU-T T.814 | ISO/IEC 15444-15)
/*options parameters*/
int reduction_factor;

86
libavcodec/jpeg2000htdec.c
Unescape View File

@ -1032,25 +1032,31 @@ static void jpeg2000_calc_mbr(uint8_t *mbr, const uint16_t i, const uint16_t j,
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;
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);
*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 |= 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);
}
}
@ -1074,6 +1080,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 +1089,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 +1106,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)
@ -1152,15 +1159,14 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int
}
}
}
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 +1180,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 +1196,9 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c
uint8_t *block_states = NULL;
int32_t n, val; // Post-processing
const uint32_t mask = UINT32_MAX >> (M_b + 1); // bit mask for ROI detection
int32_t M_b = magp;
uint8_t num_rempass;
const int quad_buf_width = width + 4;
const int quad_buf_height = height + 4;
@ -1201,22 +1208,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
@ -1232,6 +1234,7 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c
Dcup = cblk->data;
Dref = cblk->data + Lcup; // Dref comes after the refinement segment
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 +1280,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;
}

Write Preview
Loading…
Cancel
Save