1 //***************************************************************************/
2 // This software is released under the 2-Clause BSD license, included
5 // Copyright (c) 2021, Aous Naman
6 // Copyright (c) 2021, Kakadu Software Pty Ltd, Australia
7 // Copyright (c) 2021, The University of New South Wales, Australia
9 // Redistribution and use in source and binary forms, with or without
10 // modification, are permitted provided that the following conditions are
13 // 1. Redistributions of source code must retain the above copyright
14 // notice, this list of conditions and the following disclaimer.
16 // 2. Redistributions in binary form must reproduce the above copyright
17 // notice, this list of conditions and the following disclaimer in the
18 // documentation and/or other materials provided with the distribution.
20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
21 // IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 // TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
23 // PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 // HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
26 // TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 //***************************************************************************/
32 // This file is part of the OpenJpeg software implementation.
35 // Date: 01 September 2021
36 //***************************************************************************/
38 //***************************************************************************/
40 * @brief implements HTJ2K block decoder
45 #include "opj_includes.h"
47 #include "t1_ht_luts.h"
49 /////////////////////////////////////////////////////////////////////////////
51 /////////////////////////////////////////////////////////////////////////////
53 #define OPJ_COMPILER_MSVC
54 #elif (defined __GNUC__)
55 #define OPJ_COMPILER_GNUC
58 #if defined(OPJ_COMPILER_MSVC) && defined(_M_ARM64) \
59 && !defined(_M_ARM64EC) && !defined(_M_CEE_PURE) && !defined(__CUDACC__) \
60 && !defined(__INTEL_COMPILER) && !defined(__clang__)
61 #define MSVC_NEON_INTRINSICS
64 #ifdef MSVC_NEON_INTRINSICS
65 #include <arm64_neon.h>
68 //************************************************************************/
69 /** @brief Displays the error message for disabling the decoding of SPP and
72 static OPJ_BOOL only_cleanup_pass_is_decoded = OPJ_FALSE;
74 //************************************************************************/
75 /** @brief Generates population count (i.e., the number of set bits)
77 * @param [in] val is the value for which population count is sought
80 OPJ_UINT32 population_count(OPJ_UINT32 val)
82 #if defined(OPJ_COMPILER_MSVC) && (defined(_M_IX86) || defined(_M_AMD64))
83 return (OPJ_UINT32)__popcnt(val);
84 #elif defined(OPJ_COMPILER_MSVC) && defined(MSVC_NEON_INTRINSICS)
85 const __n64 temp = neon_cnt(__uint64ToN64_v(val));
86 return neon_addv8(temp).n8_i8[0];
87 #elif (defined OPJ_COMPILER_GNUC)
88 return (OPJ_UINT32)__builtin_popcount(val);
90 val -= ((val >> 1) & 0x55555555);
91 val = (((val >> 2) & 0x33333333) + (val & 0x33333333));
92 val = (((val >> 4) + val) & 0x0f0f0f0f);
95 return (OPJ_UINT32)(val & 0x0000003f);
99 //************************************************************************/
100 /** @brief Counts the number of leading zeros
102 * @param [in] val is the value for which leading zero count is sought
104 #ifdef OPJ_COMPILER_MSVC
105 #pragma intrinsic(_BitScanReverse)
108 OPJ_UINT32 count_leading_zeros(OPJ_UINT32 val)
110 #ifdef OPJ_COMPILER_MSVC
111 unsigned long result = 0;
112 _BitScanReverse(&result, val);
113 return 31U ^ (OPJ_UINT32)result;
114 #elif (defined OPJ_COMPILER_GNUC)
115 return (OPJ_UINT32)__builtin_clz(val);
122 return 32U - population_count(val);
126 //************************************************************************/
127 /** @brief Read a little-endian serialized UINT32.
129 * @param [in] dataIn pointer to byte stream to read from
131 static INLINE OPJ_UINT32 read_le_uint32(const void* dataIn)
133 #if defined(OPJ_BIG_ENDIAN)
134 const OPJ_UINT8* data = (const OPJ_UINT8*)dataIn;
135 return ((OPJ_UINT32)data[0]) | (OPJ_UINT32)(data[1] << 8) | (OPJ_UINT32)(
137 OPJ_UINT32)data[3]) <<
140 return *(OPJ_UINT32*)dataIn;
144 //************************************************************************/
145 /** @brief MEL state structure for reading and decoding the MEL bitstream
147 * A number of events is decoded from the MEL bitstream ahead of time
148 * and stored in run/num_runs.
149 * Each run represents the number of zero events before a one event.
151 typedef struct dec_mel {
152 // data decoding machinery
153 OPJ_UINT8* data; //!<the address of data (or bitstream)
154 OPJ_UINT64 tmp; //!<temporary buffer for read data
155 int bits; //!<number of bits stored in tmp
156 int size; //!<number of bytes in MEL code
157 OPJ_BOOL unstuff; //!<true if the next bit needs to be unstuffed
158 int k; //!<state of MEL decoder
160 // queue of decoded runs
161 int num_runs; //!<number of decoded runs left in runs (maximum 8)
162 OPJ_UINT64 runs; //!<runs of decoded MEL codewords (7 bits/run)
165 //************************************************************************/
166 /** @brief Reads and unstuffs the MEL bitstream
168 * This design needs more bytes in the codeblock buffer than the length
169 * of the cleanup pass by up to 2 bytes.
171 * Unstuffing removes the MSB of the byte following a byte whose
172 * value is 0xFF; this prevents sequences larger than 0xFF7F in value
173 * from appearing the bitstream.
175 * @param [in] melp is a pointer to dec_mel_t structure
178 void mel_read(dec_mel_t *melp)
185 if (melp->bits > 32) { //there are enough bits in the tmp variable
186 return; // return without reading new data
189 val = 0xFFFFFFFF; // feed in 0xFF if buffer is exhausted
190 if (melp->size > 4) { // if there is more than 4 bytes the MEL segment
191 val = read_le_uint32(melp->data); // read 32 bits from MEL data
192 melp->data += 4; // advance pointer
193 melp->size -= 4; // reduce counter
194 } else if (melp->size > 0) { // 4 or less
197 while (melp->size > 1) {
198 OPJ_UINT32 v = *melp->data++; // read one byte at a time
199 OPJ_UINT32 m = ~(0xFFu << i); // mask of location
200 val = (val & m) | (v << i); // put byte in its correct location
205 v = *melp->data++; // the one before the last is different
206 v |= 0xF; // MEL and VLC segments can overlap
208 val = (val & m) | (v << i);
212 // next we unstuff them before adding them to the buffer
213 bits = 32 - melp->unstuff; // number of bits in val, subtract 1 if
214 // the previously read byte requires
217 // data is unstuffed and accumulated in t
218 // bits has the number of bits in t
220 unstuff = ((val & 0xFF) == 0xFF); // true if the byte needs unstuffing
221 bits -= unstuff; // there is one less bit in t if unstuffing is needed
222 t = t << (8 - unstuff); // move up to make room for the next byte
224 //this is a repeat of the above
225 t |= (val >> 8) & 0xFF;
226 unstuff = (((val >> 8) & 0xFF) == 0xFF);
228 t = t << (8 - unstuff);
230 t |= (val >> 16) & 0xFF;
231 unstuff = (((val >> 16) & 0xFF) == 0xFF);
233 t = t << (8 - unstuff);
235 t |= (val >> 24) & 0xFF;
236 melp->unstuff = (((val >> 24) & 0xFF) == 0xFF);
238 // move t to tmp, and push the result all the way up, so we read from
240 melp->tmp |= ((OPJ_UINT64)t) << (64 - bits - melp->bits);
241 melp->bits += bits; //increment the number of bits in tmp
244 //************************************************************************/
245 /** @brief Decodes unstuffed MEL segment bits stored in tmp to runs
247 * Runs are stored in "runs" and the number of runs in "num_runs".
248 * Each run represents a number of zero events that may or may not
249 * terminate in a 1 event.
250 * Each run is stored in 7 bits. The LSB is 1 if the run terminates in
251 * a 1 event, 0 otherwise. The next 6 bits, for the case terminating
252 * with 1, contain the number of consecutive 0 zero events * 2; for the
253 * case terminating with 0, they store (number of consecutive 0 zero
255 * A total of 6 bits (made up of 1 + 5) should have been enough.
257 * @param [in] melp is a pointer to dec_mel_t structure
260 void mel_decode(dec_mel_t *melp)
262 static const int mel_exp[13] = { //MEL exponents
263 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5
266 if (melp->bits < 6) { // if there are less than 6 bits in tmp
267 mel_read(melp); // then read from the MEL bitstream
269 // 6 bits is the largest decodable MEL cwd
271 //repeat so long that there is enough decodable bits in tmp,
272 // and the runs store is not full (num_runs < 8)
273 while (melp->bits >= 6 && melp->num_runs < 8) {
274 int eval = mel_exp[melp->k]; // number of bits associated with state
276 if (melp->tmp & (1ull << 63)) { //The next bit to decode (stored in MSB)
279 run--; // consecutive runs of 0 events - 1
280 melp->k = melp->k + 1 < 12 ? melp->k + 1 : 12;//increment, max is 12
281 melp->tmp <<= 1; // consume one bit from tmp
283 run = run << 1; // a stretch of zeros not terminating in one
286 run = (int)(melp->tmp >> (63 - eval)) & ((1 << eval) - 1);
287 melp->k = melp->k - 1 > 0 ? melp->k - 1 : 0; //decrement, min is 0
288 melp->tmp <<= eval + 1; //consume eval + 1 bits (max is 6)
289 melp->bits -= eval + 1;
290 run = (run << 1) + 1; // a stretch of zeros terminating with one
292 eval = melp->num_runs * 7; // 7 bits per run
293 melp->runs &= ~((OPJ_UINT64)0x3F << eval); // 6 bits are sufficient
294 melp->runs |= ((OPJ_UINT64)run) << eval; // store the value in runs
295 melp->num_runs++; // increment count
299 //************************************************************************/
300 /** @brief Initiates a dec_mel_t structure for MEL decoding and reads
301 * some bytes in order to get the read address to a multiple
304 * @param [in] melp is a pointer to dec_mel_t structure
305 * @param [in] bbuf is a pointer to byte buffer
306 * @param [in] lcup is the length of MagSgn+MEL+VLC segments
307 * @param [in] scup is the length of MEL+VLC segments
310 OPJ_BOOL mel_init(dec_mel_t *melp, OPJ_UINT8* bbuf, int lcup, int scup)
315 melp->data = bbuf + lcup - scup; // move the pointer to the start of MEL
316 melp->bits = 0; // 0 bits in tmp
318 melp->unstuff = OPJ_FALSE; // no unstuffing
319 melp->size = scup - 1; // size is the length of MEL+VLC-1
320 melp->k = 0; // 0 for state
321 melp->num_runs = 0; // num_runs is 0
324 //This code is borrowed; original is for a different architecture
325 //These few lines take care of the case where data is not at a multiple
326 // of 4 boundary. It reads 1,2,3 up to 4 bytes from the MEL segment
327 num = 4 - (int)((intptr_t)(melp->data) & 0x3);
328 for (i = 0; i < num; ++i) { // this code is similar to mel_read
332 if (melp->unstuff == OPJ_TRUE && melp->data[0] > 0x8F) {
335 d = (melp->size > 0) ? *melp->data : 0xFF; // if buffer is consumed
337 if (melp->size == 1) {
338 d |= 0xF; //if this is MEL+VLC-1, set LSBs to 0xF
341 melp->data += melp->size-- > 0; //increment if the end is not reached
342 d_bits = 8 - melp->unstuff; //if unstuffing is needed, reduce by 1
343 melp->tmp = (melp->tmp << d_bits) | d; //store bits in tmp
344 melp->bits += d_bits; //increment tmp by number of bits
345 melp->unstuff = ((d & 0xFF) == 0xFF); //true of next byte needs
348 melp->tmp <<= (64 - melp->bits); //push all the way up so the first bit
353 //************************************************************************/
354 /** @brief Retrieves one run from dec_mel_t; if there are no runs stored
355 * MEL segment is decoded
357 * @param [in] melp is a pointer to dec_mel_t structure
360 int mel_get_run(dec_mel_t *melp)
363 if (melp->num_runs == 0) { //if no runs, decode more bit from MEL segment
367 t = melp->runs & 0x7F; //retrieve one run
368 melp->runs >>= 7; // remove the retrieved run
370 return t; // return run
373 //************************************************************************/
374 /** @brief A structure for reading and unstuffing a segment that grows
375 * backward, such as VLC and MRP
377 typedef struct rev_struct {
379 OPJ_UINT8* data; //!<pointer to where to read data
380 OPJ_UINT64 tmp; //!<temporary buffer of read data
381 OPJ_UINT32 bits; //!<number of bits stored in tmp
382 int size; //!<number of bytes left
383 OPJ_BOOL unstuff; //!<true if the last byte is more than 0x8F
384 //!<then the current byte is unstuffed if it is 0x7F
387 //************************************************************************/
388 /** @brief Read and unstuff data from a backwardly-growing segment
390 * This reader can read up to 8 bytes from before the VLC segment.
391 * Care must be taken not read from unreadable memory, causing a
392 * segmentation fault.
394 * Note that there is another subroutine rev_read_mrp that is slightly
395 * different. The other one fills zeros when the buffer is exhausted.
396 * This one basically does not care if the bytes are consumed, because
397 * any extra data should not be used in the actual decoding.
399 * Unstuffing is needed to prevent sequences more than 0xFF8F from
400 * appearing in the bits stream; since we are reading backward, we keep
401 * watch when a value larger than 0x8F appears in the bitstream.
402 * If the byte following this is 0x7F, we unstuff this byte (ignore the
403 * MSB of that byte, which should be 0).
405 * @param [in] vlcp is a pointer to rev_struct_t structure
408 void rev_read(rev_struct_t *vlcp)
415 //process 4 bytes at a time
416 if (vlcp->bits > 32) { // if there are more than 32 bits in tmp, then
417 return; // reading 32 bits can overflow vlcp->tmp
420 //the next line (the if statement) needs to be tested first
421 if (vlcp->size > 3) { // if there are more than 3 bytes left in VLC
422 // (vlcp->data - 3) move pointer back to read 32 bits at once
423 val = read_le_uint32(vlcp->data - 3); // then read 32 bits
424 vlcp->data -= 4; // move data pointer back by 4
425 vlcp->size -= 4; // reduce available byte by 4
426 } else if (vlcp->size > 0) { // 4 or less
428 while (vlcp->size > 0) {
429 OPJ_UINT32 v = *vlcp->data--; // read one byte at a time
430 val |= (v << i); // put byte in its correct location
436 //accumulate in tmp, number of bits in tmp are stored in bits
437 tmp = val >> 24; //start with the MSB byte
439 // test unstuff (previous byte is >0x8F), and this byte is 0x7F
440 bits = 8u - ((vlcp->unstuff && (((val >> 24) & 0x7F) == 0x7F)) ? 1u : 0u);
441 unstuff = (val >> 24) > 0x8F; //this is for the next byte
443 tmp |= ((val >> 16) & 0xFF) << bits; //process the next byte
444 bits += 8u - ((unstuff && (((val >> 16) & 0x7F) == 0x7F)) ? 1u : 0u);
445 unstuff = ((val >> 16) & 0xFF) > 0x8F;
447 tmp |= ((val >> 8) & 0xFF) << bits;
448 bits += 8u - ((unstuff && (((val >> 8) & 0x7F) == 0x7F)) ? 1u : 0u);
449 unstuff = ((val >> 8) & 0xFF) > 0x8F;
451 tmp |= (val & 0xFF) << bits;
452 bits += 8u - ((unstuff && ((val & 0x7F) == 0x7F)) ? 1u : 0u);
453 unstuff = (val & 0xFF) > 0x8F;
455 // now move the read and unstuffed bits into vlcp->tmp
456 vlcp->tmp |= (OPJ_UINT64)tmp << vlcp->bits;
458 vlcp->unstuff = unstuff; // this for the next read
461 //************************************************************************/
462 /** @brief Initiates the rev_struct_t structure and reads a few bytes to
463 * move the read address to multiple of 4
465 * There is another similar rev_init_mrp subroutine. The difference is
466 * that this one, rev_init, discards the first 12 bits (they have the
467 * sum of the lengths of VLC and MEL segments), and first unstuff depends
470 * @param [in] vlcp is a pointer to rev_struct_t structure
471 * @param [in] data is a pointer to byte at the start of the cleanup pass
472 * @param [in] lcup is the length of MagSgn+MEL+VLC segments
473 * @param [in] scup is the length of MEL+VLC segments
476 void rev_init(rev_struct_t *vlcp, OPJ_UINT8* data, int lcup, int scup)
481 //first byte has only the upper 4 bits
482 vlcp->data = data + lcup - 2;
484 //size can not be larger than this, in fact it should be smaller
485 vlcp->size = scup - 2;
487 d = *vlcp->data--; // read one byte (this is a half byte)
488 vlcp->tmp = d >> 4; // both initialize and set
489 vlcp->bits = 4 - ((vlcp->tmp & 7) == 7); //check standard
490 vlcp->unstuff = (d | 0xF) > 0x8F; //this is useful for the next byte
492 //This code is designed for an architecture that read address should
493 // align to the read size (address multiple of 4 if read size is 4)
494 //These few lines take care of the case where data is not at a multiple
495 // of 4 boundary. It reads 1,2,3 up to 4 bytes from the VLC bitstream.
496 // To read 32 bits, read from (vlcp->data - 3)
497 num = 1 + (int)((intptr_t)(vlcp->data) & 0x3);
498 tnum = num < vlcp->size ? num : vlcp->size;
499 for (i = 0; i < tnum; ++i) {
502 d = *vlcp->data--; // read one byte and move read pointer
503 //check if the last byte was >0x8F (unstuff == true) and this is 0x7F
504 d_bits = 8u - ((vlcp->unstuff && ((d & 0x7F) == 0x7F)) ? 1u : 0u);
505 vlcp->tmp |= d << vlcp->bits; // move data to vlcp->tmp
506 vlcp->bits += d_bits;
507 vlcp->unstuff = d > 0x8F; // for next byte
510 rev_read(vlcp); // read another 32 buts
513 //************************************************************************/
514 /** @brief Retrieves 32 bits from the head of a rev_struct structure
516 * By the end of this call, vlcp->tmp must have no less than 33 bits
518 * @param [in] vlcp is a pointer to rev_struct structure
521 OPJ_UINT32 rev_fetch(rev_struct_t *vlcp)
523 if (vlcp->bits < 32) { // if there are less then 32 bits, read more
524 rev_read(vlcp); // read 32 bits, but unstuffing might reduce this
525 if (vlcp->bits < 32) { // if there is still space in vlcp->tmp for 32 bits
526 rev_read(vlcp); // read another 32
529 return (OPJ_UINT32)vlcp->tmp; // return the head (bottom-most) of vlcp->tmp
532 //************************************************************************/
533 /** @brief Consumes num_bits from a rev_struct structure
535 * @param [in] vlcp is a pointer to rev_struct structure
536 * @param [in] num_bits is the number of bits to be removed
539 OPJ_UINT32 rev_advance(rev_struct_t *vlcp, OPJ_UINT32 num_bits)
541 assert(num_bits <= vlcp->bits); // vlcp->tmp must have more than num_bits
542 vlcp->tmp >>= num_bits; // remove bits
543 vlcp->bits -= num_bits; // decrement the number of bits
544 return (OPJ_UINT32)vlcp->tmp;
547 //************************************************************************/
548 /** @brief Reads and unstuffs from rev_struct
550 * This is different than rev_read in that this fills in zeros when the
551 * the available data is consumed. The other does not care about the
552 * values when all data is consumed.
554 * See rev_read for more information about unstuffing
556 * @param [in] mrp is a pointer to rev_struct structure
559 void rev_read_mrp(rev_struct_t *mrp)
566 //process 4 bytes at a time
567 if (mrp->bits > 32) {
571 if (mrp->size > 3) { // If there are 3 byte or more
572 // (mrp->data - 3) move pointer back to read 32 bits at once
573 val = read_le_uint32(mrp->data - 3); // read 32 bits
574 mrp->data -= 4; // move back pointer
575 mrp->size -= 4; // reduce count
576 } else if (mrp->size > 0) {
578 while (mrp->size > 0) {
579 OPJ_UINT32 v = *mrp->data--; // read one byte at a time
580 val |= (v << i); // put byte in its correct location
587 //accumulate in tmp, and keep count in bits
590 //test if the last byte > 0x8F (unstuff must be true) and this is 0x7F
591 bits = 8u - ((mrp->unstuff && (((val >> 24) & 0x7F) == 0x7F)) ? 1u : 0u);
592 unstuff = (val >> 24) > 0x8F;
594 //process the next byte
595 tmp |= ((val >> 16) & 0xFF) << bits;
596 bits += 8u - ((unstuff && (((val >> 16) & 0x7F) == 0x7F)) ? 1u : 0u);
597 unstuff = ((val >> 16) & 0xFF) > 0x8F;
599 tmp |= ((val >> 8) & 0xFF) << bits;
600 bits += 8u - ((unstuff && (((val >> 8) & 0x7F) == 0x7F)) ? 1u : 0u);
601 unstuff = ((val >> 8) & 0xFF) > 0x8F;
603 tmp |= (val & 0xFF) << bits;
604 bits += 8u - ((unstuff && ((val & 0x7F) == 0x7F)) ? 1u : 0u);
605 unstuff = (val & 0xFF) > 0x8F;
607 mrp->tmp |= (OPJ_UINT64)tmp << mrp->bits; // move data to mrp pointer
609 mrp->unstuff = unstuff; // next byte
612 //************************************************************************/
613 /** @brief Initialized rev_struct structure for MRP segment, and reads
614 * a number of bytes such that the next 32 bits read are from
615 * an address that is a multiple of 4. Note this is designed for
616 * an architecture that read size must be compatible with the
617 * alignment of the read address
619 * There is another similar subroutine rev_init. This subroutine does
620 * NOT skip the first 12 bits, and starts with unstuff set to true.
622 * @param [in] mrp is a pointer to rev_struct structure
623 * @param [in] data is a pointer to byte at the start of the cleanup pass
624 * @param [in] lcup is the length of MagSgn+MEL+VLC segments
625 * @param [in] len2 is the length of SPP+MRP segments
628 void rev_init_mrp(rev_struct_t *mrp, OPJ_UINT8* data, int lcup, int len2)
632 mrp->data = data + lcup + len2 - 1;
634 mrp->unstuff = OPJ_TRUE;
638 //This code is designed for an architecture that read address should
639 // align to the read size (address multiple of 4 if read size is 4)
640 //These few lines take care of the case where data is not at a multiple
641 // of 4 boundary. It reads 1,2,3 up to 4 bytes from the MRP stream
642 num = 1 + (int)((intptr_t)(mrp->data) & 0x3);
643 for (i = 0; i < num; ++i) {
647 //read a byte, 0 if no more data
648 d = (mrp->size-- > 0) ? *mrp->data-- : 0;
649 //check if unstuffing is needed
650 d_bits = 8u - ((mrp->unstuff && ((d & 0x7F) == 0x7F)) ? 1u : 0u);
651 mrp->tmp |= d << mrp->bits; // move data to vlcp->tmp
653 mrp->unstuff = d > 0x8F; // for next byte
658 //************************************************************************/
659 /** @brief Retrieves 32 bits from the head of a rev_struct structure
661 * By the end of this call, mrp->tmp must have no less than 33 bits
663 * @param [in] mrp is a pointer to rev_struct structure
666 OPJ_UINT32 rev_fetch_mrp(rev_struct_t *mrp)
668 if (mrp->bits < 32) { // if there are less than 32 bits in mrp->tmp
669 rev_read_mrp(mrp); // read 30-32 bits from mrp
670 if (mrp->bits < 32) { // if there is a space of 32 bits
671 rev_read_mrp(mrp); // read more
674 return (OPJ_UINT32)mrp->tmp; // return the head of mrp->tmp
677 //************************************************************************/
678 /** @brief Consumes num_bits from a rev_struct structure
680 * @param [in] mrp is a pointer to rev_struct structure
681 * @param [in] num_bits is the number of bits to be removed
684 OPJ_UINT32 rev_advance_mrp(rev_struct_t *mrp, OPJ_UINT32 num_bits)
686 assert(num_bits <= mrp->bits); // we must not consume more than mrp->bits
687 mrp->tmp >>= num_bits; // discard the lowest num_bits bits
688 mrp->bits -= num_bits;
689 return (OPJ_UINT32)mrp->tmp; // return data after consumption
692 //************************************************************************/
693 /** @brief Decode initial UVLC to get the u value (or u_q)
695 * @param [in] vlc is the head of the VLC bitstream
696 * @param [in] mode is 0, 1, 2, 3, or 4. Values in 0 to 3 are composed of
697 * u_off of 1st quad and 2nd quad of a quad pair. The value
698 * 4 occurs when both bits are 1, and the event decoded
699 * from MEL bitstream is also 1.
700 * @param [out] u is the u value (or u_q) + 1. Note: we produce u + 1;
701 * this value is a partial calculation of u + kappa.
704 OPJ_UINT32 decode_init_uvlc(OPJ_UINT32 vlc, OPJ_UINT32 mode, OPJ_UINT32 *u)
706 //table stores possible decoding three bits from vlc
707 // there are 8 entries for xx1, x10, 100, 000, where x means do not care
708 // table value is made up of
709 // 2 bits in the LSB for prefix length
710 // 3 bits for suffix length
711 // 3 bits in the MSB for prefix value (u_pfx in Table 3 of ITU T.814)
712 static const OPJ_UINT8 dec[8] = { // the index is the prefix codeword
713 3 | (5 << 2) | (5 << 5), //000 == 000, prefix codeword "000"
714 1 | (0 << 2) | (1 << 5), //001 == xx1, prefix codeword "1"
715 2 | (0 << 2) | (2 << 5), //010 == x10, prefix codeword "01"
716 1 | (0 << 2) | (1 << 5), //011 == xx1, prefix codeword "1"
717 3 | (1 << 2) | (3 << 5), //100 == 100, prefix codeword "001"
718 1 | (0 << 2) | (1 << 5), //101 == xx1, prefix codeword "1"
719 2 | (0 << 2) | (2 << 5), //110 == x10, prefix codeword "01"
720 1 | (0 << 2) | (1 << 5) //111 == xx1, prefix codeword "1"
723 OPJ_UINT32 consumed_bits = 0;
724 if (mode == 0) { // both u_off are 0
725 u[0] = u[1] = 1; //Kappa is 1 for initial line
726 } else if (mode <= 2) { // u_off are either 01 or 10
728 OPJ_UINT32 suffix_len;
730 d = dec[vlc & 0x7]; //look at the least significant 3 bits
731 vlc >>= d & 0x3; //prefix length
732 consumed_bits += d & 0x3;
734 suffix_len = ((d >> 2) & 0x7);
735 consumed_bits += suffix_len;
737 d = (d >> 5) + (vlc & ((1U << suffix_len) - 1)); // u value
738 u[0] = (mode == 1) ? d + 1 : 1; // kappa is 1 for initial line
739 u[1] = (mode == 1) ? 1 : d + 1; // kappa is 1 for initial line
740 } else if (mode == 3) { // both u_off are 1, and MEL event is 0
741 OPJ_UINT32 d1 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword
742 vlc >>= d1 & 0x3; // Consume bits
743 consumed_bits += d1 & 0x3;
745 if ((d1 & 0x3) > 2) {
746 OPJ_UINT32 suffix_len;
749 u[1] = (vlc & 1) + 1 + 1; //Kappa is 1 for initial line
753 suffix_len = ((d1 >> 2) & 0x7);
754 consumed_bits += suffix_len;
755 d1 = (d1 >> 5) + (vlc & ((1U << suffix_len) - 1)); // u value
756 u[0] = d1 + 1; //Kappa is 1 for initial line
759 OPJ_UINT32 suffix_len;
761 d2 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword
762 vlc >>= d2 & 0x3; // Consume bits
763 consumed_bits += d2 & 0x3;
765 suffix_len = ((d1 >> 2) & 0x7);
766 consumed_bits += suffix_len;
768 d1 = (d1 >> 5) + (vlc & ((1U << suffix_len) - 1)); // u value
769 u[0] = d1 + 1; //Kappa is 1 for initial line
772 suffix_len = ((d2 >> 2) & 0x7);
773 consumed_bits += suffix_len;
775 d2 = (d2 >> 5) + (vlc & ((1U << suffix_len) - 1)); // u value
776 u[1] = d2 + 1; //Kappa is 1 for initial line
778 } else if (mode == 4) { // both u_off are 1, and MEL event is 1
781 OPJ_UINT32 suffix_len;
783 d1 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword
784 vlc >>= d1 & 0x3; // Consume bits
785 consumed_bits += d1 & 0x3;
787 d2 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword
788 vlc >>= d2 & 0x3; // Consume bits
789 consumed_bits += d2 & 0x3;
791 suffix_len = ((d1 >> 2) & 0x7);
792 consumed_bits += suffix_len;
794 d1 = (d1 >> 5) + (vlc & ((1U << suffix_len) - 1)); // u value
795 u[0] = d1 + 3; // add 2+kappa
798 suffix_len = ((d2 >> 2) & 0x7);
799 consumed_bits += suffix_len;
801 d2 = (d2 >> 5) + (vlc & ((1U << suffix_len) - 1)); // u value
802 u[1] = d2 + 3; // add 2+kappa
804 return consumed_bits;
807 //************************************************************************/
808 /** @brief Decode non-initial UVLC to get the u value (or u_q)
810 * @param [in] vlc is the head of the VLC bitstream
811 * @param [in] mode is 0, 1, 2, or 3. The 1st bit is u_off of 1st quad
812 * and 2nd for 2nd quad of a quad pair
813 * @param [out] u is the u value (or u_q) + 1. Note: we produce u + 1;
814 * this value is a partial calculation of u + kappa.
817 OPJ_UINT32 decode_noninit_uvlc(OPJ_UINT32 vlc, OPJ_UINT32 mode, OPJ_UINT32 *u)
819 //table stores possible decoding three bits from vlc
820 // there are 8 entries for xx1, x10, 100, 000, where x means do not care
821 // table value is made up of
822 // 2 bits in the LSB for prefix length
823 // 3 bits for suffix length
824 // 3 bits in the MSB for prefix value (u_pfx in Table 3 of ITU T.814)
825 static const OPJ_UINT8 dec[8] = {
826 3 | (5 << 2) | (5 << 5), //000 == 000, prefix codeword "000"
827 1 | (0 << 2) | (1 << 5), //001 == xx1, prefix codeword "1"
828 2 | (0 << 2) | (2 << 5), //010 == x10, prefix codeword "01"
829 1 | (0 << 2) | (1 << 5), //011 == xx1, prefix codeword "1"
830 3 | (1 << 2) | (3 << 5), //100 == 100, prefix codeword "001"
831 1 | (0 << 2) | (1 << 5), //101 == xx1, prefix codeword "1"
832 2 | (0 << 2) | (2 << 5), //110 == x10, prefix codeword "01"
833 1 | (0 << 2) | (1 << 5) //111 == xx1, prefix codeword "1"
836 OPJ_UINT32 consumed_bits = 0;
838 u[0] = u[1] = 1; //for kappa
839 } else if (mode <= 2) { //u_off are either 01 or 10
841 OPJ_UINT32 suffix_len;
843 d = dec[vlc & 0x7]; //look at the least significant 3 bits
844 vlc >>= d & 0x3; //prefix length
845 consumed_bits += d & 0x3;
847 suffix_len = ((d >> 2) & 0x7);
848 consumed_bits += suffix_len;
850 d = (d >> 5) + (vlc & ((1U << suffix_len) - 1)); // u value
851 u[0] = (mode == 1) ? d + 1 : 1; //for kappa
852 u[1] = (mode == 1) ? 1 : d + 1; //for kappa
853 } else if (mode == 3) { // both u_off are 1
856 OPJ_UINT32 suffix_len;
858 d1 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword
859 vlc >>= d1 & 0x3; // Consume bits
860 consumed_bits += d1 & 0x3;
862 d2 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword
863 vlc >>= d2 & 0x3; // Consume bits
864 consumed_bits += d2 & 0x3;
866 suffix_len = ((d1 >> 2) & 0x7);
867 consumed_bits += suffix_len;
869 d1 = (d1 >> 5) + (vlc & ((1U << suffix_len) - 1)); // u value
870 u[0] = d1 + 1; //1 for kappa
873 suffix_len = ((d2 >> 2) & 0x7);
874 consumed_bits += suffix_len;
876 d2 = (d2 >> 5) + (vlc & ((1U << suffix_len) - 1)); // u value
877 u[1] = d2 + 1; //1 for kappa
879 return consumed_bits;
882 //************************************************************************/
883 /** @brief State structure for reading and unstuffing of forward-growing
884 * bitstreams; these are: MagSgn and SPP bitstreams
886 typedef struct frwd_struct {
887 const OPJ_UINT8* data; //!<pointer to bitstream
888 OPJ_UINT64 tmp; //!<temporary buffer of read data
889 OPJ_UINT32 bits; //!<number of bits stored in tmp
890 OPJ_BOOL unstuff; //!<true if a bit needs to be unstuffed from next byte
891 int size; //!<size of data
892 OPJ_UINT32 X; //!<0 or 0xFF, X's are inserted at end of bitstream
895 //************************************************************************/
896 /** @brief Read and unstuffs 32 bits from forward-growing bitstream
898 * A subroutine to read from both the MagSgn or SPP bitstreams;
899 * in particular, when MagSgn bitstream is consumed, 0xFF's are fed,
900 * while when SPP is exhausted 0's are fed in.
901 * X controls this value.
903 * Unstuffing prevent sequences that are more than 0xFF7F from appearing
904 * in the conpressed sequence. So whenever a value of 0xFF is coded, the
905 * MSB of the next byte is set 0 and must be ignored during decoding.
907 * Reading can go beyond the end of buffer by up to 3 bytes.
909 * @param [in] msp is a pointer to frwd_struct_t structure
913 void frwd_read(frwd_struct_t *msp)
920 assert(msp->bits <= 32); // assert that there is a space for 32 bits
924 val = read_le_uint32(msp->data); // read 32 bits
925 msp->data += 4; // increment pointer
926 msp->size -= 4; // reduce size
927 } else if (msp->size > 0) {
929 val = msp->X != 0 ? 0xFFFFFFFFu : 0;
930 while (msp->size > 0) {
931 OPJ_UINT32 v = *msp->data++; // read one byte at a time
932 OPJ_UINT32 m = ~(0xFFu << i); // mask of location
933 val = (val & m) | (v << i); // put one byte in its correct location
938 val = msp->X != 0 ? 0xFFFFFFFFu : 0;
941 // we accumulate in t and keep a count of the number of bits in bits
942 bits = 8u - (msp->unstuff ? 1u : 0u);
944 unstuff = ((val & 0xFF) == 0xFF); // Do we need unstuffing next?
946 t |= ((val >> 8) & 0xFF) << bits;
947 bits += 8u - (unstuff ? 1u : 0u);
948 unstuff = (((val >> 8) & 0xFF) == 0xFF);
950 t |= ((val >> 16) & 0xFF) << bits;
951 bits += 8u - (unstuff ? 1u : 0u);
952 unstuff = (((val >> 16) & 0xFF) == 0xFF);
954 t |= ((val >> 24) & 0xFF) << bits;
955 bits += 8u - (unstuff ? 1u : 0u);
956 msp->unstuff = (((val >> 24) & 0xFF) == 0xFF); // for next byte
958 msp->tmp |= ((OPJ_UINT64)t) << msp->bits; // move data to msp->tmp
962 //************************************************************************/
963 /** @brief Initialize frwd_struct_t struct and reads some bytes
965 * @param [in] msp is a pointer to frwd_struct_t
966 * @param [in] data is a pointer to the start of data
967 * @param [in] size is the number of byte in the bitstream
968 * @param [in] X is the value fed in when the bitstream is exhausted.
972 void frwd_init(frwd_struct_t *msp, const OPJ_UINT8* data, int size,
980 msp->unstuff = OPJ_FALSE;
983 assert(msp->X == 0 || msp->X == 0xFF);
985 //This code is designed for an architecture that read address should
986 // align to the read size (address multiple of 4 if read size is 4)
987 //These few lines take care of the case where data is not at a multiple
988 // of 4 boundary. It reads 1,2,3 up to 4 bytes from the bitstream
989 num = 4 - (int)((intptr_t)(msp->data) & 0x3);
990 for (i = 0; i < num; ++i) {
992 //read a byte if the buffer is not exhausted, otherwise set it to X
993 d = msp->size-- > 0 ? *msp->data++ : msp->X;
994 msp->tmp |= (d << msp->bits); // store data in msp->tmp
995 msp->bits += 8u - (msp->unstuff ? 1u : 0u); // number of bits added to msp->tmp
996 msp->unstuff = ((d & 0xFF) == 0xFF); // unstuffing for next byte
998 frwd_read(msp); // read 32 bits more
1001 //************************************************************************/
1002 /** @brief Consume num_bits bits from the bitstream of frwd_struct_t
1004 * @param [in] msp is a pointer to frwd_struct_t
1005 * @param [in] num_bits is the number of bit to consume
1008 void frwd_advance(frwd_struct_t *msp, OPJ_UINT32 num_bits)
1010 assert(num_bits <= msp->bits);
1011 msp->tmp >>= num_bits; // consume num_bits
1012 msp->bits -= num_bits;
1015 //************************************************************************/
1016 /** @brief Fetches 32 bits from the frwd_struct_t bitstream
1018 * @param [in] msp is a pointer to frwd_struct_t
1021 OPJ_UINT32 frwd_fetch(frwd_struct_t *msp)
1023 if (msp->bits < 32) {
1025 if (msp->bits < 32) { //need to test
1029 return (OPJ_UINT32)msp->tmp;
1032 //************************************************************************/
1033 /** @brief Allocates T1 buffers
1035 * @param [in, out] t1 is codeblock cofficients storage
1036 * @param [in] w is codeblock width
1037 * @param [in] h is codeblock height
1039 static OPJ_BOOL opj_t1_allocate_buffers(
1044 OPJ_UINT32 flagssize;
1046 /* No risk of overflow. Prior checks ensure those assert are met */
1047 /* They are per the specification */
1050 assert(w * h <= 4096);
1052 /* encoder uses tile buffer, so no need to allocate */
1054 OPJ_UINT32 datasize = w * h;
1056 if (datasize > t1->datasize) {
1057 opj_aligned_free(t1->data);
1058 t1->data = (OPJ_INT32*)
1059 opj_aligned_malloc(datasize * sizeof(OPJ_INT32));
1061 /* FIXME event manager error callback */
1064 t1->datasize = datasize;
1066 /* memset first arg is declared to never be null by gcc */
1067 if (t1->data != NULL) {
1068 memset(t1->data, 0, datasize * sizeof(OPJ_INT32));
1072 // We expand these buffers to multiples of 16 bytes.
1073 // We need 4 buffers of 129 integers each, expanded to 132 integers each
1074 // We also need 514 bytes of buffer, expanded to 528 bytes
1075 flagssize = 132U * sizeof(OPJ_UINT32) * 4U; // expanded to multiple of 16
1076 flagssize += 528U; // 514 expanded to multiples of 16
1079 if (flagssize > t1->flagssize) {
1081 opj_aligned_free(t1->flags);
1082 t1->flags = (opj_flag_t*) opj_aligned_malloc(flagssize * sizeof(opj_flag_t));
1084 /* FIXME event manager error callback */
1088 t1->flagssize = flagssize;
1090 memset(t1->flags, 0, flagssize * sizeof(opj_flag_t));
1100 Decode 1 HT code-block
1102 @param cblk Code-block coding parameters
1104 @param roishift Region of interest shifting value
1105 @param cblksty Code-block style
1106 @param p_manager the event manager
1107 @param p_manager_mutex mutex for the event manager
1108 @param check_pterm whether PTERM correct termination should be checked
1110 OPJ_BOOL opj_t1_ht_decode_cblk(opj_t1_t *t1,
1111 opj_tcd_cblk_dec_t* cblk,
1113 OPJ_UINT32 roishift,
1115 opj_event_mgr_t *p_manager,
1116 opj_mutex_t* p_manager_mutex,
1117 OPJ_BOOL check_pterm);
1119 //************************************************************************/
1120 /** @brief Decodes one codeblock, processing the cleanup, siginificance
1121 * propagation, and magnitude refinement pass
1123 * @param [in, out] t1 is codeblock cofficients storage
1124 * @param [in] cblk is codeblock properties
1125 * @param [in] orient is the subband to which the codeblock belongs (not needed)
1126 * @param [in] roishift is region of interest shift
1127 * @param [in] cblksty is codeblock style
1128 * @param [in] p_manager is events print manager
1129 * @param [in] p_manager_mutex a mutex to control access to p_manager
1130 * @param [in] check_pterm: check termination (not used)
1132 OPJ_BOOL opj_t1_ht_decode_cblk(opj_t1_t *t1,
1133 opj_tcd_cblk_dec_t* cblk,
1135 OPJ_UINT32 roishift,
1137 opj_event_mgr_t *p_manager,
1138 opj_mutex_t* p_manager_mutex,
1139 OPJ_BOOL check_pterm)
1141 OPJ_BYTE* cblkdata = NULL;
1142 OPJ_UINT8* coded_data;
1143 OPJ_UINT32* decoded_data;
1144 OPJ_UINT32 zero_bplanes;
1145 OPJ_UINT32 num_passes;
1146 OPJ_UINT32 lengths1;
1147 OPJ_UINT32 lengths2;
1151 OPJ_UINT32 *pflags, *sigma1, *sigma2, *mbr1, *mbr2, *sip, sip_shift;
1153 OPJ_UINT32 zero_bplanes_p1;
1157 frwd_struct_t magsgn;
1158 frwd_struct_t sigprop;
1159 rev_struct_t magref;
1160 OPJ_UINT8 *lsp, *line_state;
1162 OPJ_UINT32 vlc_val; // fetched data from VLC bitstream
1166 OPJ_INT32 x, y; // loop indices
1167 OPJ_BOOL stripe_causal = (cblksty & J2K_CCP_CBLKSTY_VSC) != 0;
1168 OPJ_UINT32 cblk_len = 0;
1170 (void)(orient); // stops unused parameter message
1171 (void)(check_pterm); // stops unused parameter message
1173 // We ignor orient, because the same decoder is used for all subbands
1174 // We also ignore check_pterm, because I am not sure how it applies
1175 if (roishift != 0) {
1176 if (p_manager_mutex) {
1177 opj_mutex_lock(p_manager_mutex);
1179 opj_event_msg(p_manager, EVT_ERROR, "We do not support ROI in decoding "
1181 if (p_manager_mutex) {
1182 opj_mutex_unlock(p_manager_mutex);
1187 if (!opj_t1_allocate_buffers(
1189 (OPJ_UINT32)(cblk->x1 - cblk->x0),
1190 (OPJ_UINT32)(cblk->y1 - cblk->y0))) {
1194 if (cblk->Mb == 0) {
1198 /* numbps = Mb + 1 - zero_bplanes, Mb = Kmax, zero_bplanes = missing_msbs */
1199 zero_bplanes = (cblk->Mb + 1) - cblk->numbps;
1201 /* Compute whole codeblock length from chunk lengths */
1205 for (i = 0; i < cblk->numchunks; i++) {
1206 cblk_len += cblk->chunks[i].len;
1210 if (cblk->numchunks > 1 || t1->mustuse_cblkdatabuffer) {
1213 /* Allocate temporary memory if needed */
1214 if (cblk_len > t1->cblkdatabuffersize) {
1215 cblkdata = (OPJ_BYTE*)opj_realloc(
1216 t1->cblkdatabuffer, cblk_len);
1217 if (cblkdata == NULL) {
1220 t1->cblkdatabuffer = cblkdata;
1221 t1->cblkdatabuffersize = cblk_len;
1224 /* Concatenate all chunks */
1225 cblkdata = t1->cblkdatabuffer;
1226 if (cblkdata == NULL) {
1230 for (i = 0; i < cblk->numchunks; i++) {
1231 memcpy(cblkdata + cblk_len, cblk->chunks[i].data, cblk->chunks[i].len);
1232 cblk_len += cblk->chunks[i].len;
1234 } else if (cblk->numchunks == 1) {
1235 cblkdata = cblk->chunks[0].data;
1237 /* Not sure if that can happen in practice, but avoid Coverity to */
1238 /* think we will dereference a null cblkdta pointer */
1242 // OPJ_BYTE* coded_data is a pointer to bitstream
1243 coded_data = cblkdata;
1244 // OPJ_UINT32* decoded_data is a pointer to decoded codeblock data buf.
1245 decoded_data = (OPJ_UINT32*)t1->data;
1246 // OPJ_UINT32 num_passes is the number of passes: 1 if CUP only, 2 for
1247 // CUP+SPP, and 3 for CUP+SPP+MRP
1248 num_passes = cblk->numsegs > 0 ? cblk->segs[0].real_num_passes : 0;
1249 num_passes += cblk->numsegs > 1 ? cblk->segs[1].real_num_passes : 0;
1250 // OPJ_UINT32 lengths1 is the length of cleanup pass
1251 lengths1 = num_passes > 0 ? cblk->segs[0].len : 0;
1252 // OPJ_UINT32 lengths2 is the length of refinement passes (either SPP only or SPP+MRP)
1253 lengths2 = num_passes > 1 ? cblk->segs[1].len : 0;
1254 // OPJ_INT32 width is the decoded codeblock width
1255 width = cblk->x1 - cblk->x0;
1256 // OPJ_INT32 height is the decoded codeblock height
1257 height = cblk->y1 - cblk->y0;
1258 // OPJ_INT32 stride is the decoded codeblock buffer stride
1261 /* sigma1 and sigma2 contains significant (i.e., non-zero) pixel
1262 * locations. The buffers are used interchangeably, because we need
1263 * more than 4 rows of significance information at a given time.
1264 * Each 32 bits contain significance information for 4 rows of 8
1265 * columns each. If we denote 32 bits by 0xaaaaaaaa, the each "a" is
1266 * called a nibble and has significance information for 4 rows.
1267 * The least significant nibble has information for the first column,
1268 * and so on. The nibble's LSB is for the first row, and so on.
1269 * Since, at most, we can have 1024 columns in a quad, we need 128
1270 * entries; we added 1 for convenience when propagation of signifcance
1271 * goes outside the structure
1272 * To work in OpenJPEG these buffers has been expanded to 132.
1274 // OPJ_UINT32 *pflags, *sigma1, *sigma2, *mbr1, *mbr2, *sip, sip_shift;
1275 pflags = (OPJ_UINT32 *)t1->flags;
1277 sigma2 = sigma1 + 132;
1278 // mbr arrangement is similar to sigma; mbr contains locations
1279 // that become significant during significance propagation pass
1280 mbr1 = sigma2 + 132;
1282 //a pointer to sigma
1283 sip = sigma1; //pointers to arrays to be used interchangeably
1284 sip_shift = 0; //the amount of shift needed for sigma
1286 if (num_passes > 1 && lengths2 == 0) {
1287 if (p_manager_mutex) {
1288 opj_mutex_lock(p_manager_mutex);
1290 opj_event_msg(p_manager, EVT_WARNING, "A malformed codeblock that has "
1291 "more than one coding pass, but zero length for "
1292 "2nd and potentially the 3rd pass in an HT codeblock.\n");
1293 if (p_manager_mutex) {
1294 opj_mutex_unlock(p_manager_mutex);
1298 if (num_passes > 3) {
1299 if (p_manager_mutex) {
1300 opj_mutex_lock(p_manager_mutex);
1302 opj_event_msg(p_manager, EVT_ERROR, "We do not support more than 3 "
1303 "coding passes in an HT codeblock; This codeblocks has "
1304 "%d passes.\n", num_passes);
1305 if (p_manager_mutex) {
1306 opj_mutex_unlock(p_manager_mutex);
1311 if (cblk->Mb > 30) {
1312 /* This check is better moved to opj_t2_read_packet_header() in t2.c
1313 We do not have enough precision to decode any passes
1314 The design of openjpeg assumes that the bits of a 32-bit integer are
1315 assigned as follows:
1317 bits 30-1 are for magnitude
1318 bit 0 is for the center of the quantization bin
1319 Therefore we can only do values of cblk->Mb <= 30
1321 if (p_manager_mutex) {
1322 opj_mutex_lock(p_manager_mutex);
1324 opj_event_msg(p_manager, EVT_ERROR, "32 bits are not enough to "
1325 "decode this codeblock, since the number of "
1326 "bitplane, %d, is larger than 30.\n", cblk->Mb);
1327 if (p_manager_mutex) {
1328 opj_mutex_unlock(p_manager_mutex);
1332 if (zero_bplanes > cblk->Mb) {
1333 /* This check is better moved to opj_t2_read_packet_header() in t2.c,
1334 in the line "l_cblk->numbps = (OPJ_UINT32)l_band->numbps + 1 - i;"
1335 where i is the zero bitplanes, and should be no larger than cblk->Mb
1336 We cannot have more zero bitplanes than there are planes. */
1337 if (p_manager_mutex) {
1338 opj_mutex_lock(p_manager_mutex);
1340 opj_event_msg(p_manager, EVT_ERROR, "Malformed HT codeblock. "
1341 "Decoding this codeblock is stopped. There are "
1342 "%d zero bitplanes in %d bitplanes.\n",
1343 zero_bplanes, cblk->Mb);
1345 if (p_manager_mutex) {
1346 opj_mutex_unlock(p_manager_mutex);
1349 } else if (zero_bplanes == cblk->Mb && num_passes > 1) {
1350 /* When the number of zero bitplanes is equal to the number of bitplanes,
1351 only the cleanup pass makes sense*/
1352 if (only_cleanup_pass_is_decoded == OPJ_FALSE) {
1353 if (p_manager_mutex) {
1354 opj_mutex_lock(p_manager_mutex);
1356 /* We have a second check to prevent the possibility of an overrun condition,
1357 in the very unlikely event of a second thread discovering that
1358 only_cleanup_pass_is_decoded is false before the first thread changing
1360 if (only_cleanup_pass_is_decoded == OPJ_FALSE) {
1361 only_cleanup_pass_is_decoded = OPJ_TRUE;
1362 opj_event_msg(p_manager, EVT_WARNING, "Malformed HT codeblock. "
1363 "When the number of zero planes bitplanes is "
1364 "equal to the number of bitplanes, only the cleanup "
1365 "pass makes sense, but we have %d passes in this "
1366 "codeblock. Therefore, only the cleanup pass will be "
1367 "decoded. This message will not be displayed again.\n",
1370 if (p_manager_mutex) {
1371 opj_mutex_unlock(p_manager_mutex);
1380 // OPJ_UINT32 zero planes plus 1
1381 zero_bplanes_p1 = zero_bplanes + 1;
1383 if (lengths1 < 2 || (OPJ_UINT32)lengths1 > cblk_len ||
1384 (OPJ_UINT32)(lengths1 + lengths2) > cblk_len) {
1385 if (p_manager_mutex) {
1386 opj_mutex_lock(p_manager_mutex);
1388 opj_event_msg(p_manager, EVT_ERROR, "Malformed HT codeblock. "
1389 "Invalid codeblock length values.\n");
1391 if (p_manager_mutex) {
1392 opj_mutex_unlock(p_manager_mutex);
1396 // read scup and fix the bytes there
1397 lcup = (int)lengths1; // length of CUP
1398 //scup is the length of MEL + VLC
1399 scup = (((int)coded_data[lcup - 1]) << 4) + (coded_data[lcup - 2] & 0xF);
1400 if (scup < 2 || scup > lcup || scup > 4079) { //something is wrong
1401 /* The standard stipulates 2 <= Scup <= min(Lcup, 4079) */
1402 if (p_manager_mutex) {
1403 opj_mutex_lock(p_manager_mutex);
1405 opj_event_msg(p_manager, EVT_ERROR, "Malformed HT codeblock. "
1406 "One of the following condition is not met: "
1407 "2 <= Scup <= min(Lcup, 4079)\n");
1409 if (p_manager_mutex) {
1410 opj_mutex_unlock(p_manager_mutex);
1416 if (mel_init(&mel, coded_data, lcup, scup) == OPJ_FALSE) {
1417 if (p_manager_mutex) {
1418 opj_mutex_lock(p_manager_mutex);
1420 opj_event_msg(p_manager, EVT_ERROR, "Malformed HT codeblock. "
1421 "Incorrect MEL segment sequence.\n");
1422 if (p_manager_mutex) {
1423 opj_mutex_unlock(p_manager_mutex);
1427 rev_init(&vlc, coded_data, lcup, scup);
1428 frwd_init(&magsgn, coded_data, lcup - scup, 0xFF);
1429 if (num_passes > 1) { // needs to be tested
1430 frwd_init(&sigprop, coded_data + lengths1, (int)lengths2, 0);
1432 if (num_passes > 2) {
1433 rev_init_mrp(&magref, coded_data, (int)lengths1, (int)lengths2);
1437 * One byte per quad; for 1024 columns, or 512 quads, we need
1438 * 512 bytes. We are using 2 extra bytes one on the left and one on
1439 * the right for convenience.
1441 * The MSB bit in each byte is (\sigma^nw | \sigma^n), and the 7 LSBs
1442 * contain max(E^nw | E^n)
1445 // 514 is enough for a block width of 1024, +2 extra
1446 // here expanded to 528
1447 line_state = (OPJ_UINT8 *)(mbr2 + 132);
1451 lsp = line_state; // point to line state
1452 lsp[0] = 0; // for initial row of quad, we set to 0
1453 run = mel_get_run(&mel); // decode runs of events from MEL bitstrm
1454 // data represented as runs of 0 events
1455 // See mel_decode description
1456 qinf[0] = qinf[1] = 0; // quad info decoded from VLC bitstream
1457 c_q = 0; // context for quad q
1458 sp = decoded_data; // decoded codeblock samples
1459 // vlc_val; // fetched data from VLC bitstream
1461 for (x = 0; x < width; x += 4) { // one iteration per quad pair
1462 OPJ_UINT32 U_q[2]; // u values for the quad pair
1463 OPJ_UINT32 uvlc_mode;
1464 OPJ_UINT32 consumed_bits;
1465 OPJ_UINT32 m_n, v_n;
1473 // Get the head of the VLC bitstream. One fetch is enough for two
1474 // quads, since the largest VLC code is 7 bits, and maximum number of
1475 // bits used for u is 8. Therefore for two quads we need 30 bits
1476 // (if we include unstuffing, then 32 bits are enough, since we have
1477 // a maximum of one stuffing per two bytes)
1478 vlc_val = rev_fetch(&vlc);
1480 //decode VLC using the context c_q and the head of the VLC bitstream
1481 qinf[0] = vlc_tbl0[(c_q << 7) | (vlc_val & 0x7F) ];
1483 if (c_q == 0) { // if zero context, we need to use one MEL event
1484 run -= 2; //the number of 0 events is multiplied by 2, so subtract 2
1486 // Is the run terminated in 1? if so, use decoded VLC code,
1487 // otherwise, discard decoded data, since we will decoded again
1488 // using a different context
1489 qinf[0] = (run == -1) ? qinf[0] : 0;
1491 // is run -1 or -2? this means a run has been consumed
1493 run = mel_get_run(&mel); // get another run
1497 // prepare context for the next quad; eqn. 1 in ITU T.814
1498 c_q = ((qinf[0] & 0x10) >> 4) | ((qinf[0] & 0xE0) >> 5);
1500 //remove data from vlc stream (0 bits are removed if qinf is not used)
1501 vlc_val = rev_advance(&vlc, qinf[0] & 0x7);
1504 // The update depends on the value of x; consider one OPJ_UINT32
1505 // if x is 0, 8, 16 and so on, then this line update c locations
1506 // nibble (4 bits) number 0 1 2 3 4 5 6 7
1507 // LSB c c 0 0 0 0 0 0
1511 // if x is 4, 12, 20, then this line update locations c
1512 // nibble (4 bits) number 0 1 2 3 4 5 6 7
1513 // LSB 0 0 0 0 c c 0 0
1517 *sip |= (((qinf[0] & 0x30) >> 4) | ((qinf[0] & 0xC0) >> 2)) << sip_shift;
1521 if (x + 2 < width) { // do not run if codeblock is narrower
1522 //decode VLC using the context c_q and the head of the VLC bitstream
1523 qinf[1] = vlc_tbl0[(c_q << 7) | (vlc_val & 0x7F)];
1525 // if context is zero, use one MEL event
1526 if (c_q == 0) { //zero context
1527 run -= 2; //subtract 2, since events number if multiplied by 2
1529 // if event is 0, discard decoded qinf
1530 qinf[1] = (run == -1) ? qinf[1] : 0;
1532 if (run < 0) { // have we consumed all events in a run
1533 run = mel_get_run(&mel); // if yes, then get another run
1537 //prepare context for the next quad, eqn. 1 in ITU T.814
1538 c_q = ((qinf[1] & 0x10) >> 4) | ((qinf[1] & 0xE0) >> 5);
1540 //remove data from vlc stream, if qinf is not used, cwdlen is 0
1541 vlc_val = rev_advance(&vlc, qinf[1] & 0x7);
1545 // The update depends on the value of x; consider one OPJ_UINT32
1546 // if x is 0, 8, 16 and so on, then this line update c locations
1547 // nibble (4 bits) number 0 1 2 3 4 5 6 7
1548 // LSB 0 0 c c 0 0 0 0
1552 // if x is 4, 12, 20, then this line update locations c
1553 // nibble (4 bits) number 0 1 2 3 4 5 6 7
1554 // LSB 0 0 0 0 0 0 c c
1558 *sip |= (((qinf[1] & 0x30) | ((qinf[1] & 0xC0) << 2))) << (4 + sip_shift);
1560 sip += x & 0x7 ? 1 : 0; // move sigma pointer to next entry
1561 sip_shift ^= 0x10; // increment/decrement sip_shift by 16
1566 // uvlc_mode is made up of u_offset bits from the quad pair
1567 uvlc_mode = ((qinf[0] & 0x8) >> 3) | ((qinf[1] & 0x8) >> 2);
1568 if (uvlc_mode == 3) { // if both u_offset are set, get an event from
1569 // the MEL run of events
1570 run -= 2; //subtract 2, since events number if multiplied by 2
1571 uvlc_mode += (run == -1) ? 1 : 0; //increment uvlc_mode if event is 1
1572 if (run < 0) { // if run is consumed (run is -1 or -2), get another run
1573 run = mel_get_run(&mel);
1576 //decode uvlc_mode to get u for both quads
1577 consumed_bits = decode_init_uvlc(vlc_val, uvlc_mode, U_q);
1578 if (U_q[0] > zero_bplanes_p1 || U_q[1] > zero_bplanes_p1) {
1579 if (p_manager_mutex) {
1580 opj_mutex_lock(p_manager_mutex);
1582 opj_event_msg(p_manager, EVT_ERROR, "Malformed HT codeblock. Decoding "
1583 "this codeblock is stopped. U_q is larger than zero "
1584 "bitplanes + 1 \n");
1585 if (p_manager_mutex) {
1586 opj_mutex_unlock(p_manager_mutex);
1591 //consume u bits in the VLC code
1592 vlc_val = rev_advance(&vlc, consumed_bits);
1594 //decode magsgn and update line_state
1595 /////////////////////////////////////
1597 //We obtain a mask for the samples locations that needs evaluation
1599 if (x + 4 > width) {
1600 locs >>= (x + 4 - width) << 1; // limits width
1602 locs = height > 1 ? locs : (locs & 0x55); // limits height
1604 if ((((qinf[0] & 0xF0) >> 4) | (qinf[1] & 0xF0)) & ~locs) {
1605 if (p_manager_mutex) {
1606 opj_mutex_lock(p_manager_mutex);
1608 opj_event_msg(p_manager, EVT_ERROR, "Malformed HT codeblock. "
1609 "VLC code produces significant samples outside "
1610 "the codeblock area.\n");
1611 if (p_manager_mutex) {
1612 opj_mutex_unlock(p_manager_mutex);
1617 //first quad, starting at first sample in quad and moving on
1618 if (qinf[0] & 0x10) { //is it significant? (sigma_n)
1621 ms_val = frwd_fetch(&magsgn); //get 32 bits of magsgn data
1622 m_n = U_q[0] - ((qinf[0] >> 12) & 1); //evaluate m_n (number of bits
1623 // to read from bitstream), using EMB e_k
1624 frwd_advance(&magsgn, m_n); //consume m_n
1625 val = ms_val << 31; //get sign bit
1626 v_n = ms_val & ((1U << m_n) - 1); //keep only m_n bits
1627 v_n |= ((qinf[0] & 0x100) >> 8) << m_n; //add EMB e_1 as MSB
1628 v_n |= 1; //add center of bin
1629 //v_n now has 2 * (\mu - 1) + 0.5 with correct sign bit
1630 //add 2 to make it 2*\mu+0.5, shift it up to missing MSBs
1631 sp[0] = val | ((v_n + 2) << (p - 1));
1632 } else if (locs & 0x1) { // if this is inside the codeblock, set the
1633 sp[0] = 0; // sample to zero
1636 if (qinf[0] & 0x20) { //sigma_n
1639 ms_val = frwd_fetch(&magsgn); //get 32 bits
1640 m_n = U_q[0] - ((qinf[0] >> 13) & 1); //m_n, uses EMB e_k
1641 frwd_advance(&magsgn, m_n); //consume m_n
1642 val = ms_val << 31; //get sign bit
1643 v_n = ms_val & ((1U << m_n) - 1); //keep only m_n bits
1644 v_n |= ((qinf[0] & 0x200) >> 9) << m_n; //add EMB e_1
1645 v_n |= 1; //bin center
1646 //v_n now has 2 * (\mu - 1) + 0.5 with correct sign bit
1647 //add 2 to make it 2*\mu+0.5, shift it up to missing MSBs
1648 sp[stride] = val | ((v_n + 2) << (p - 1));
1650 //update line_state: bit 7 (\sigma^N), and E^N
1651 t = lsp[0] & 0x7F; // keep E^NW
1652 v_n = 32 - count_leading_zeros(v_n);
1653 lsp[0] = (OPJ_UINT8)(0x80 | (t > v_n ? t : v_n)); //max(E^NW, E^N) | s
1654 } else if (locs & 0x2) { // if this is inside the codeblock, set the
1655 sp[stride] = 0; // sample to zero
1658 ++lsp; // move to next quad information
1659 ++sp; // move to next column of samples
1661 //this is similar to the above two samples
1662 if (qinf[0] & 0x40) {
1665 ms_val = frwd_fetch(&magsgn);
1666 m_n = U_q[0] - ((qinf[0] >> 14) & 1);
1667 frwd_advance(&magsgn, m_n);
1669 v_n = ms_val & ((1U << m_n) - 1);
1670 v_n |= (((qinf[0] & 0x400) >> 10) << m_n);
1672 sp[0] = val | ((v_n + 2) << (p - 1));
1673 } else if (locs & 0x4) {
1678 if (qinf[0] & 0x80) {
1680 ms_val = frwd_fetch(&magsgn);
1681 m_n = U_q[0] - ((qinf[0] >> 15) & 1); //m_n
1682 frwd_advance(&magsgn, m_n);
1684 v_n = ms_val & ((1U << m_n) - 1);
1685 v_n |= ((qinf[0] & 0x800) >> 11) << m_n;
1686 v_n |= 1; //center of bin
1687 sp[stride] = val | ((v_n + 2) << (p - 1));
1689 //line_state: bit 7 (\sigma^NW), and E^NW for next quad
1690 lsp[0] = (OPJ_UINT8)(0x80 | (32 - count_leading_zeros(v_n)));
1691 } else if (locs & 0x8) { //if outside set to 0
1695 ++sp; //move to next column
1698 if (qinf[1] & 0x10) {
1701 ms_val = frwd_fetch(&magsgn);
1702 m_n = U_q[1] - ((qinf[1] >> 12) & 1); //m_n
1703 frwd_advance(&magsgn, m_n);
1705 v_n = ms_val & ((1U << m_n) - 1);
1706 v_n |= (((qinf[1] & 0x100) >> 8) << m_n);
1708 sp[0] = val | ((v_n + 2) << (p - 1));
1709 } else if (locs & 0x10) {
1713 if (qinf[1] & 0x20) {
1716 ms_val = frwd_fetch(&magsgn);
1717 m_n = U_q[1] - ((qinf[1] >> 13) & 1); //m_n
1718 frwd_advance(&magsgn, m_n);
1720 v_n = ms_val & ((1U << m_n) - 1);
1721 v_n |= (((qinf[1] & 0x200) >> 9) << m_n);
1723 sp[stride] = val | ((v_n + 2) << (p - 1));
1725 //update line_state: bit 7 (\sigma^N), and E^N
1726 t = lsp[0] & 0x7F; //E^NW
1727 v_n = 32 - count_leading_zeros(v_n); //E^N
1728 lsp[0] = (OPJ_UINT8)(0x80 | (t > v_n ? t : v_n)); //max(E^NW, E^N) | s
1729 } else if (locs & 0x20) {
1730 sp[stride] = 0; //no need to update line_state
1733 ++lsp; //move line state to next quad
1734 ++sp; //move to next sample
1736 if (qinf[1] & 0x40) {
1739 ms_val = frwd_fetch(&magsgn);
1740 m_n = U_q[1] - ((qinf[1] >> 14) & 1); //m_n
1741 frwd_advance(&magsgn, m_n);
1743 v_n = ms_val & ((1U << m_n) - 1);
1744 v_n |= (((qinf[1] & 0x400) >> 10) << m_n);
1746 sp[0] = val | ((v_n + 2) << (p - 1));
1747 } else if (locs & 0x40) {
1752 if (qinf[1] & 0x80) {
1755 ms_val = frwd_fetch(&magsgn);
1756 m_n = U_q[1] - ((qinf[1] >> 15) & 1); //m_n
1757 frwd_advance(&magsgn, m_n);
1759 v_n = ms_val & ((1U << m_n) - 1);
1760 v_n |= (((qinf[1] & 0x800) >> 11) << m_n);
1761 v_n |= 1; //center of bin
1762 sp[stride] = val | ((v_n + 2) << (p - 1));
1764 //line_state: bit 7 (\sigma^NW), and E^NW for next quad
1765 lsp[0] = (OPJ_UINT8)(0x80 | (32 - count_leading_zeros(v_n)));
1766 } else if (locs & 0x80) {
1774 //////////////////////////
1775 for (y = 2; y < height; /*done at the end of loop*/) {
1780 sip_shift ^= 0x2; // shift sigma to the upper half od the nibble
1781 sip_shift &= 0xFFFFFFEFU; //move back to 0 (it might have been at 0x10)
1782 sip = y & 0x4 ? sigma2 : sigma1; //choose sigma array
1785 ls0 = lsp[0]; // read the line state value
1786 lsp[0] = 0; // and set it to zero
1787 sp = decoded_data + y * stride; // generated samples
1789 for (x = 0; x < width; x += 4) {
1791 OPJ_UINT32 uvlc_mode, consumed_bits;
1792 OPJ_UINT32 m_n, v_n;
1800 // get context, eqn. 2 ITU T.814
1801 // c_q has \sigma^W | \sigma^SW
1802 c_q |= (ls0 >> 7); //\sigma^NW | \sigma^N
1803 c_q |= (lsp[1] >> 5) & 0x4; //\sigma^NE | \sigma^NF
1805 //the following is very similar to previous code, so please refer to
1807 vlc_val = rev_fetch(&vlc);
1808 qinf[0] = vlc_tbl1[(c_q << 7) | (vlc_val & 0x7F)];
1809 if (c_q == 0) { //zero context
1811 qinf[0] = (run == -1) ? qinf[0] : 0;
1813 run = mel_get_run(&mel);
1816 //prepare context for the next quad, \sigma^W | \sigma^SW
1817 c_q = ((qinf[0] & 0x40) >> 5) | ((qinf[0] & 0x80) >> 6);
1819 //remove data from vlc stream
1820 vlc_val = rev_advance(&vlc, qinf[0] & 0x7);
1823 // The update depends on the value of x and y; consider one OPJ_UINT32
1824 // if x is 0, 8, 16 and so on, and y is 2, 6, etc., then this
1825 // line update c locations
1826 // nibble (4 bits) number 0 1 2 3 4 5 6 7
1827 // LSB 0 0 0 0 0 0 0 0
1831 *sip |= (((qinf[0] & 0x30) >> 4) | ((qinf[0] & 0xC0) >> 2)) << sip_shift;
1835 if (x + 2 < width) {
1836 c_q |= (lsp[1] >> 7);
1837 c_q |= (lsp[2] >> 5) & 0x4;
1838 qinf[1] = vlc_tbl1[(c_q << 7) | (vlc_val & 0x7F)];
1839 if (c_q == 0) { //zero context
1841 qinf[1] = (run == -1) ? qinf[1] : 0;
1843 run = mel_get_run(&mel);
1846 //prepare context for the next quad
1847 c_q = ((qinf[1] & 0x40) >> 5) | ((qinf[1] & 0x80) >> 6);
1848 //remove data from vlc stream
1849 vlc_val = rev_advance(&vlc, qinf[1] & 0x7);
1853 *sip |= (((qinf[1] & 0x30) | ((qinf[1] & 0xC0) << 2))) << (4 + sip_shift);
1855 sip += x & 0x7 ? 1 : 0;
1860 uvlc_mode = ((qinf[0] & 0x8) >> 3) | ((qinf[1] & 0x8) >> 2);
1861 consumed_bits = decode_noninit_uvlc(vlc_val, uvlc_mode, U_q);
1862 vlc_val = rev_advance(&vlc, consumed_bits);
1864 //calculate E^max and add it to U_q, eqns 5 and 6 in ITU T.814
1865 if ((qinf[0] & 0xF0) & ((qinf[0] & 0xF0) - 1)) { // is \gamma_q 1?
1866 OPJ_UINT32 E = (ls0 & 0x7Fu);
1867 E = E > (lsp[1] & 0x7Fu) ? E : (lsp[1] & 0x7Fu); //max(E, E^NE, E^NF)
1868 //since U_q already has u_q + 1, we subtract 2 instead of 1
1869 U_q[0] += E > 2 ? E - 2 : 0;
1872 if ((qinf[1] & 0xF0) & ((qinf[1] & 0xF0) - 1)) { //is \gamma_q 1?
1873 OPJ_UINT32 E = (lsp[1] & 0x7Fu);
1874 E = E > (lsp[2] & 0x7Fu) ? E : (lsp[2] & 0x7Fu); //max(E, E^NE, E^NF)
1875 //since U_q already has u_q + 1, we subtract 2 instead of 1
1876 U_q[1] += E > 2 ? E - 2 : 0;
1879 if (U_q[0] > zero_bplanes_p1 || U_q[1] > zero_bplanes_p1) {
1880 if (p_manager_mutex) {
1881 opj_mutex_lock(p_manager_mutex);
1883 opj_event_msg(p_manager, EVT_ERROR, "Malformed HT codeblock. "
1884 "Decoding this codeblock is stopped. U_q is"
1885 "larger than bitplanes + 1 \n");
1886 if (p_manager_mutex) {
1887 opj_mutex_unlock(p_manager_mutex);
1892 ls0 = lsp[2]; //for next double quad
1893 lsp[1] = lsp[2] = 0;
1895 //decode magsgn and update line_state
1896 /////////////////////////////////////
1898 //locations where samples need update
1900 if (x + 4 > width) {
1901 locs >>= (x + 4 - width) << 1;
1903 locs = y + 2 <= height ? locs : (locs & 0x55);
1905 if ((((qinf[0] & 0xF0) >> 4) | (qinf[1] & 0xF0)) & ~locs) {
1906 if (p_manager_mutex) {
1907 opj_mutex_lock(p_manager_mutex);
1909 opj_event_msg(p_manager, EVT_ERROR, "Malformed HT codeblock. "
1910 "VLC code produces significant samples outside "
1911 "the codeblock area.\n");
1912 if (p_manager_mutex) {
1913 opj_mutex_unlock(p_manager_mutex);
1920 if (qinf[0] & 0x10) { //sigma_n
1923 ms_val = frwd_fetch(&magsgn);
1924 m_n = U_q[0] - ((qinf[0] >> 12) & 1); //m_n
1925 frwd_advance(&magsgn, m_n);
1927 v_n = ms_val & ((1U << m_n) - 1);
1928 v_n |= ((qinf[0] & 0x100) >> 8) << m_n;
1929 v_n |= 1; //center of bin
1930 sp[0] = val | ((v_n + 2) << (p - 1));
1931 } else if (locs & 0x1) {
1935 if (qinf[0] & 0x20) { //sigma_n
1938 ms_val = frwd_fetch(&magsgn);
1939 m_n = U_q[0] - ((qinf[0] >> 13) & 1); //m_n
1940 frwd_advance(&magsgn, m_n);
1942 v_n = ms_val & ((1U << m_n) - 1);
1943 v_n |= ((qinf[0] & 0x200) >> 9) << m_n;
1944 v_n |= 1; //center of bin
1945 sp[stride] = val | ((v_n + 2) << (p - 1));
1947 //update line_state: bit 7 (\sigma^N), and E^N
1948 t = lsp[0] & 0x7F; //E^NW
1949 v_n = 32 - count_leading_zeros(v_n);
1950 lsp[0] = (OPJ_UINT8)(0x80 | (t > v_n ? t : v_n));
1951 } else if (locs & 0x2) {
1952 sp[stride] = 0; //no need to update line_state
1958 if (qinf[0] & 0x40) { //sigma_n
1961 ms_val = frwd_fetch(&magsgn);
1962 m_n = U_q[0] - ((qinf[0] >> 14) & 1); //m_n
1963 frwd_advance(&magsgn, m_n);
1965 v_n = ms_val & ((1U << m_n) - 1);
1966 v_n |= (((qinf[0] & 0x400) >> 10) << m_n);
1967 v_n |= 1; //center of bin
1968 sp[0] = val | ((v_n + 2) << (p - 1));
1969 } else if (locs & 0x4) {
1973 if (qinf[0] & 0x80) { //sigma_n
1976 ms_val = frwd_fetch(&magsgn);
1977 m_n = U_q[0] - ((qinf[0] >> 15) & 1); //m_n
1978 frwd_advance(&magsgn, m_n);
1980 v_n = ms_val & ((1U << m_n) - 1);
1981 v_n |= ((qinf[0] & 0x800) >> 11) << m_n;
1982 v_n |= 1; //center of bin
1983 sp[stride] = val | ((v_n + 2) << (p - 1));
1985 //update line_state: bit 7 (\sigma^NW), and E^NW for next quad
1986 lsp[0] = (OPJ_UINT8)(0x80 | (32 - count_leading_zeros(v_n)));
1987 } else if (locs & 0x8) {
1993 if (qinf[1] & 0x10) { //sigma_n
1996 ms_val = frwd_fetch(&magsgn);
1997 m_n = U_q[1] - ((qinf[1] >> 12) & 1); //m_n
1998 frwd_advance(&magsgn, m_n);
2000 v_n = ms_val & ((1U << m_n) - 1);
2001 v_n |= (((qinf[1] & 0x100) >> 8) << m_n);
2002 v_n |= 1; //center of bin
2003 sp[0] = val | ((v_n + 2) << (p - 1));
2004 } else if (locs & 0x10) {
2008 if (qinf[1] & 0x20) { //sigma_n
2011 ms_val = frwd_fetch(&magsgn);
2012 m_n = U_q[1] - ((qinf[1] >> 13) & 1); //m_n
2013 frwd_advance(&magsgn, m_n);
2015 v_n = ms_val & ((1U << m_n) - 1);
2016 v_n |= (((qinf[1] & 0x200) >> 9) << m_n);
2017 v_n |= 1; //center of bin
2018 sp[stride] = val | ((v_n + 2) << (p - 1));
2020 //update line_state: bit 7 (\sigma^N), and E^N
2021 t = lsp[0] & 0x7F; //E^NW
2022 v_n = 32 - count_leading_zeros(v_n);
2023 lsp[0] = (OPJ_UINT8)(0x80 | (t > v_n ? t : v_n));
2024 } else if (locs & 0x20) {
2025 sp[stride] = 0; //no need to update line_state
2031 if (qinf[1] & 0x40) { //sigma_n
2034 ms_val = frwd_fetch(&magsgn);
2035 m_n = U_q[1] - ((qinf[1] >> 14) & 1); //m_n
2036 frwd_advance(&magsgn, m_n);
2038 v_n = ms_val & ((1U << m_n) - 1);
2039 v_n |= (((qinf[1] & 0x400) >> 10) << m_n);
2040 v_n |= 1; //center of bin
2041 sp[0] = val | ((v_n + 2) << (p - 1));
2042 } else if (locs & 0x40) {
2046 if (qinf[1] & 0x80) { //sigma_n
2049 ms_val = frwd_fetch(&magsgn);
2050 m_n = U_q[1] - ((qinf[1] >> 15) & 1); //m_n
2051 frwd_advance(&magsgn, m_n);
2053 v_n = ms_val & ((1U << m_n) - 1);
2054 v_n |= (((qinf[1] & 0x800) >> 11) << m_n);
2055 v_n |= 1; //center of bin
2056 sp[stride] = val | ((v_n + 2) << (p - 1));
2058 //update line_state: bit 7 (\sigma^NW), and E^NW for next quad
2059 lsp[0] = (OPJ_UINT8)(0x80 | (32 - count_leading_zeros(v_n)));
2060 } else if (locs & 0x80) {
2068 if (num_passes > 1 && (y & 3) == 0) { //executed at multiples of 4
2069 // This is for SPP and potentially MRP
2071 if (num_passes > 2) { //do MRP
2072 // select the current stripe
2073 OPJ_UINT32 *cur_sig = y & 0x4 ? sigma1 : sigma2;
2074 // the address of the data that needs updating
2075 OPJ_UINT32 *dpp = decoded_data + (y - 4) * stride;
2076 OPJ_UINT32 half = 1u << (p - 2); // half the center of the bin
2078 for (i = 0; i < width; i += 8) {
2079 //Process one entry from sigma array at a time
2080 // Each nibble (4 bits) in the sigma array represents 4 rows,
2081 // and the 32 bits contain 8 columns
2082 OPJ_UINT32 cwd = rev_fetch_mrp(&magref); // get 32 bit data
2083 OPJ_UINT32 sig = *cur_sig++; // 32 bit that will be processed now
2084 OPJ_UINT32 col_mask = 0xFu; // a mask for a column in sig
2085 OPJ_UINT32 *dp = dpp + i; // next column in decode samples
2086 if (sig) { // if any of the 32 bits are set
2088 for (j = 0; j < 8; ++j, dp++) { //one column at a time
2089 if (sig & col_mask) { // lowest nibble
2090 OPJ_UINT32 sample_mask = 0x11111111u & col_mask; //LSB
2092 if (sig & sample_mask) { //if LSB is set
2095 assert(dp[0] != 0); // decoded value cannot be zero
2096 sym = cwd & 1; // get it value
2097 // remove center of bin if sym is 0
2098 dp[0] ^= (1 - sym) << (p - 1);
2099 dp[0] |= half; // put half the center of bin
2100 cwd >>= 1; //consume word
2102 sample_mask += sample_mask; //next row
2104 if (sig & sample_mask) {
2107 assert(dp[stride] != 0);
2109 dp[stride] ^= (1 - sym) << (p - 1);
2113 sample_mask += sample_mask;
2115 if (sig & sample_mask) {
2118 assert(dp[2 * stride] != 0);
2120 dp[2 * stride] ^= (1 - sym) << (p - 1);
2121 dp[2 * stride] |= half;
2124 sample_mask += sample_mask;
2126 if (sig & sample_mask) {
2129 assert(dp[3 * stride] != 0);
2131 dp[3 * stride] ^= (1 - sym) << (p - 1);
2132 dp[3 * stride] |= half;
2135 sample_mask += sample_mask;
2137 col_mask <<= 4; //next column
2140 // consume data according to the number of bits set
2141 rev_advance_mrp(&magref, population_count(sig));
2145 if (y >= 4) { // update mbr array at the end of each stripe
2146 //generate mbr corresponding to a stripe
2147 OPJ_UINT32 *sig = y & 0x4 ? sigma1 : sigma2;
2148 OPJ_UINT32 *mbr = y & 0x4 ? mbr1 : mbr2;
2150 //data is processed in patches of 8 columns, each
2151 // each 32 bits in sigma1 or mbr1 represent 4 rows
2153 //integrate horizontally
2154 OPJ_UINT32 prev = 0; // previous columns
2156 for (i = 0; i < width; i += 8, mbr++, sig++) {
2159 mbr[0] = sig[0]; //start with significant samples
2160 mbr[0] |= prev >> 28; //for first column, left neighbors
2161 mbr[0] |= sig[0] << 4; //left neighbors
2162 mbr[0] |= sig[0] >> 4; //right neighbors
2163 mbr[0] |= sig[1] << 28; //for last column, right neighbors
2164 prev = sig[0]; // for next group of columns
2166 //integrate vertically
2167 t = mbr[0], z = mbr[0];
2168 z |= (t & 0x77777777) << 1; //above neighbors
2169 z |= (t & 0xEEEEEEEE) >> 1; //below neighbors
2170 mbr[0] = z & ~sig[0]; //remove already significance samples
2174 if (y >= 8) { //wait until 8 rows has been processed
2175 OPJ_UINT32 *cur_sig, *cur_mbr, *nxt_sig, *nxt_mbr;
2180 // add membership from the next stripe, obtained above
2181 cur_sig = y & 0x4 ? sigma2 : sigma1;
2182 cur_mbr = y & 0x4 ? mbr2 : mbr1;
2183 nxt_sig = y & 0x4 ? sigma1 : sigma2; //future samples
2184 prev = 0; // the columns before these group of 8 columns
2185 for (i = 0; i < width; i += 8, cur_mbr++, cur_sig++, nxt_sig++) {
2186 OPJ_UINT32 t = nxt_sig[0];
2187 t |= prev >> 28; //for first column, left neighbors
2188 t |= nxt_sig[0] << 4; //left neighbors
2189 t |= nxt_sig[0] >> 4; //right neighbors
2190 t |= nxt_sig[1] << 28; //for last column, right neighbors
2191 prev = nxt_sig[0]; // for next group of columns
2193 if (!stripe_causal) {
2194 cur_mbr[0] |= (t & 0x11111111u) << 3; //propagate up to cur_mbr
2196 cur_mbr[0] &= ~cur_sig[0]; //remove already significance samples
2199 //find new locations and get signs
2200 cur_sig = y & 0x4 ? sigma2 : sigma1;
2201 cur_mbr = y & 0x4 ? mbr2 : mbr1;
2202 nxt_sig = y & 0x4 ? sigma1 : sigma2; //future samples
2203 nxt_mbr = y & 0x4 ? mbr1 : mbr2; //future samples
2204 val = 3u << (p - 2); // sample values for newly discovered
2205 // significant samples including the bin center
2206 for (i = 0; i < width;
2207 i += 8, cur_sig++, cur_mbr++, nxt_sig++, nxt_mbr++) {
2209 OPJ_UINT32 mbr = *cur_mbr;
2210 OPJ_UINT32 new_sig = 0;
2211 if (mbr) { //are there any samples that might be significant
2213 for (n = 0; n < 8; n += 4) {
2214 OPJ_UINT32 col_mask;
2219 OPJ_UINT32 cwd = frwd_fetch(&sigprop); //get 32 bits
2222 OPJ_UINT32 *dp = decoded_data + (y - 8) * stride;
2223 dp += i + n; //address for decoded samples
2225 col_mask = 0xFu << (4 * n); //a mask to select a column
2227 inv_sig = ~cur_sig[0]; // insignificant samples
2229 //find the last sample we operate on
2230 end = n + 4 + i < width ? n + 4 : width - i;
2232 for (j = n; j < end; ++j, ++dp, col_mask <<= 4) {
2233 OPJ_UINT32 sample_mask;
2235 if ((col_mask & mbr) == 0) { //no samples need checking
2239 //scan mbr to find a new significant sample
2240 sample_mask = 0x11111111u & col_mask; // LSB
2241 if (mbr & sample_mask) {
2242 assert(dp[0] == 0); // the sample must have been 0
2243 if (cwd & 1) { //if this sample has become significant
2244 // must propagate it to nearby samples
2246 new_sig |= sample_mask; // new significant samples
2247 t = 0x32u << (j * 4);// propagation to neighbors
2248 mbr |= t & inv_sig; //remove already significant samples
2251 ++cnt; //consume bit and increment number of
2255 sample_mask += sample_mask; // next row
2256 if (mbr & sample_mask) {
2257 assert(dp[stride] == 0);
2260 new_sig |= sample_mask;
2261 t = 0x74u << (j * 4);
2268 sample_mask += sample_mask;
2269 if (mbr & sample_mask) {
2270 assert(dp[2 * stride] == 0);
2273 new_sig |= sample_mask;
2274 t = 0xE8u << (j * 4);
2281 sample_mask += sample_mask;
2282 if (mbr & sample_mask) {
2283 assert(dp[3 * stride] == 0);
2286 new_sig |= sample_mask;
2287 t = 0xC0u << (j * 4);
2296 if (new_sig & (0xFFFFu << (4 * n))) { //if any
2297 OPJ_UINT32 col_mask;
2299 OPJ_UINT32 *dp = decoded_data + (y - 8) * stride;
2300 dp += i + n; // decoded samples address
2301 col_mask = 0xFu << (4 * n); //mask to select a column
2303 for (j = n; j < end; ++j, ++dp, col_mask <<= 4) {
2304 OPJ_UINT32 sample_mask;
2306 if ((col_mask & new_sig) == 0) { //if non is significant
2311 sample_mask = 0x11111111u & col_mask;
2312 if (new_sig & sample_mask) {
2314 dp[0] |= ((cwd & 1) << 31) | val; //put value and sign
2316 ++cnt; //consume bit and increment number
2320 sample_mask += sample_mask;
2321 if (new_sig & sample_mask) {
2322 assert(dp[stride] == 0);
2323 dp[stride] |= ((cwd & 1) << 31) | val;
2328 sample_mask += sample_mask;
2329 if (new_sig & sample_mask) {
2330 assert(dp[2 * stride] == 0);
2331 dp[2 * stride] |= ((cwd & 1) << 31) | val;
2336 sample_mask += sample_mask;
2337 if (new_sig & sample_mask) {
2338 assert(dp[3 * stride] == 0);
2339 dp[3 * stride] |= ((cwd & 1) << 31) | val;
2346 frwd_advance(&sigprop, cnt); //consume the bits from bitstrm
2349 //update the next 8 columns
2352 OPJ_UINT32 t = new_sig >> 28;
2353 t |= ((t & 0xE) >> 1) | ((t & 7) << 1);
2354 cur_mbr[1] |= t & ~cur_sig[1];
2358 //update the next stripe (vertically propagation)
2359 new_sig |= cur_sig[0];
2360 ux = (new_sig & 0x88888888) >> 3;
2361 tx = ux | (ux << 4) | (ux >> 4); //left and right neighbors
2363 nxt_mbr[-1] |= (ux << 28) & ~nxt_sig[-1];
2365 nxt_mbr[0] |= tx & ~nxt_sig[0];
2366 nxt_mbr[1] |= (ux >> 28) & ~nxt_sig[1];
2369 //clear current sigma
2370 //mbr need not be cleared because it is overwritten
2371 cur_sig = y & 0x4 ? sigma2 : sigma1;
2372 memset(cur_sig, 0, ((((OPJ_UINT32)width + 7u) >> 3) + 1u) << 2);
2378 if (num_passes > 1) {
2381 if (num_passes > 2 && ((height & 3) == 1 || (height & 3) == 2)) {
2383 OPJ_UINT32 *cur_sig = height & 0x4 ? sigma2 : sigma1; //reversed
2384 OPJ_UINT32 *dpp = decoded_data + (height & 0xFFFFFC) * stride;
2385 OPJ_UINT32 half = 1u << (p - 2);
2387 for (i = 0; i < width; i += 8) {
2388 OPJ_UINT32 cwd = rev_fetch_mrp(&magref);
2389 OPJ_UINT32 sig = *cur_sig++;
2390 OPJ_UINT32 col_mask = 0xF;
2391 OPJ_UINT32 *dp = dpp + i;
2394 for (j = 0; j < 8; ++j, dp++) {
2395 if (sig & col_mask) {
2396 OPJ_UINT32 sample_mask = 0x11111111 & col_mask;
2398 if (sig & sample_mask) {
2402 dp[0] ^= (1 - sym) << (p - 1);
2406 sample_mask += sample_mask;
2408 if (sig & sample_mask) {
2410 assert(dp[stride] != 0);
2412 dp[stride] ^= (1 - sym) << (p - 1);
2416 sample_mask += sample_mask;
2418 if (sig & sample_mask) {
2420 assert(dp[2 * stride] != 0);
2422 dp[2 * stride] ^= (1 - sym) << (p - 1);
2423 dp[2 * stride] |= half;
2426 sample_mask += sample_mask;
2428 if (sig & sample_mask) {
2430 assert(dp[3 * stride] != 0);
2432 dp[3 * stride] ^= (1 - sym) << (p - 1);
2433 dp[3 * stride] |= half;
2436 sample_mask += sample_mask;
2441 rev_advance_mrp(&magref, population_count(sig));
2445 //do the last incomplete stripe
2446 // for cases of (height & 3) == 0 and 3
2447 // the should have been processed previously
2448 if ((height & 3) == 1 || (height & 3) == 2) {
2449 //generate mbr of first stripe
2450 OPJ_UINT32 *sig = height & 0x4 ? sigma2 : sigma1;
2451 OPJ_UINT32 *mbr = height & 0x4 ? mbr2 : mbr1;
2452 //integrate horizontally
2453 OPJ_UINT32 prev = 0;
2455 for (i = 0; i < width; i += 8, mbr++, sig++) {
2459 mbr[0] |= prev >> 28; //for first column, left neighbors
2460 mbr[0] |= sig[0] << 4; //left neighbors
2461 mbr[0] |= sig[0] >> 4; //left neighbors
2462 mbr[0] |= sig[1] << 28; //for last column, right neighbors
2465 //integrate vertically
2466 t = mbr[0], z = mbr[0];
2467 z |= (t & 0x77777777) << 1; //above neighbors
2468 z |= (t & 0xEEEEEEEE) >> 1; //below neighbors
2469 mbr[0] = z & ~sig[0]; //remove already significance samples
2474 st -= height > 6 ? (((height + 1) & 3) + 3) : height;
2475 for (y = st; y < height; y += 4) {
2476 OPJ_UINT32 *cur_sig, *cur_mbr, *nxt_sig, *nxt_mbr;
2480 OPJ_UINT32 pattern = 0xFFFFFFFFu; // a pattern needed samples
2481 if (height - y == 3) {
2482 pattern = 0x77777777u;
2483 } else if (height - y == 2) {
2484 pattern = 0x33333333u;
2485 } else if (height - y == 1) {
2486 pattern = 0x11111111u;
2489 //add membership from the next stripe, obtained above
2490 if (height - y > 4) {
2491 OPJ_UINT32 prev = 0;
2493 cur_sig = y & 0x4 ? sigma2 : sigma1;
2494 cur_mbr = y & 0x4 ? mbr2 : mbr1;
2495 nxt_sig = y & 0x4 ? sigma1 : sigma2;
2496 for (i = 0; i < width; i += 8, cur_mbr++, cur_sig++, nxt_sig++) {
2497 OPJ_UINT32 t = nxt_sig[0];
2498 t |= prev >> 28; //for first column, left neighbors
2499 t |= nxt_sig[0] << 4; //left neighbors
2500 t |= nxt_sig[0] >> 4; //left neighbors
2501 t |= nxt_sig[1] << 28; //for last column, right neighbors
2504 if (!stripe_causal) {
2505 cur_mbr[0] |= (t & 0x11111111u) << 3;
2507 //remove already significance samples
2508 cur_mbr[0] &= ~cur_sig[0];
2512 //find new locations and get signs
2513 cur_sig = y & 0x4 ? sigma2 : sigma1;
2514 cur_mbr = y & 0x4 ? mbr2 : mbr1;
2515 nxt_sig = y & 0x4 ? sigma1 : sigma2;
2516 nxt_mbr = y & 0x4 ? mbr1 : mbr2;
2517 val = 3u << (p - 2);
2518 for (i = 0; i < width; i += 8,
2519 cur_sig++, cur_mbr++, nxt_sig++, nxt_mbr++) {
2520 OPJ_UINT32 mbr = *cur_mbr & pattern; //skip unneeded samples
2521 OPJ_UINT32 new_sig = 0;
2525 for (n = 0; n < 8; n += 4) {
2526 OPJ_UINT32 col_mask;
2531 OPJ_UINT32 cwd = frwd_fetch(&sigprop);
2534 OPJ_UINT32 *dp = decoded_data + y * stride;
2537 col_mask = 0xFu << (4 * n);
2539 inv_sig = ~cur_sig[0] & pattern;
2541 end = n + 4 + i < width ? n + 4 : width - i;
2542 for (j = n; j < end; ++j, ++dp, col_mask <<= 4) {
2543 OPJ_UINT32 sample_mask;
2545 if ((col_mask & mbr) == 0) {
2550 sample_mask = 0x11111111u & col_mask;
2551 if (mbr & sample_mask) {
2555 new_sig |= sample_mask;
2556 t = 0x32u << (j * 4);
2563 sample_mask += sample_mask;
2564 if (mbr & sample_mask) {
2565 assert(dp[stride] == 0);
2568 new_sig |= sample_mask;
2569 t = 0x74u << (j * 4);
2576 sample_mask += sample_mask;
2577 if (mbr & sample_mask) {
2578 assert(dp[2 * stride] == 0);
2581 new_sig |= sample_mask;
2582 t = 0xE8u << (j * 4);
2589 sample_mask += sample_mask;
2590 if (mbr & sample_mask) {
2591 assert(dp[3 * stride] == 0);
2594 new_sig |= sample_mask;
2595 t = 0xC0u << (j * 4);
2604 if (new_sig & (0xFFFFu << (4 * n))) {
2605 OPJ_UINT32 col_mask;
2607 OPJ_UINT32 *dp = decoded_data + y * stride;
2609 col_mask = 0xFu << (4 * n);
2611 for (j = n; j < end; ++j, ++dp, col_mask <<= 4) {
2612 OPJ_UINT32 sample_mask;
2613 if ((col_mask & new_sig) == 0) {
2618 sample_mask = 0x11111111u & col_mask;
2619 if (new_sig & sample_mask) {
2621 dp[0] |= ((cwd & 1) << 31) | val;
2626 sample_mask += sample_mask;
2627 if (new_sig & sample_mask) {
2628 assert(dp[stride] == 0);
2629 dp[stride] |= ((cwd & 1) << 31) | val;
2634 sample_mask += sample_mask;
2635 if (new_sig & sample_mask) {
2636 assert(dp[2 * stride] == 0);
2637 dp[2 * stride] |= ((cwd & 1) << 31) | val;
2642 sample_mask += sample_mask;
2643 if (new_sig & sample_mask) {
2644 assert(dp[3 * stride] == 0);
2645 dp[3 * stride] |= ((cwd & 1) << 31) | val;
2652 frwd_advance(&sigprop, cnt);
2655 //update next columns
2658 OPJ_UINT32 t = new_sig >> 28;
2659 t |= ((t & 0xE) >> 1) | ((t & 7) << 1);
2660 cur_mbr[1] |= t & ~cur_sig[1];
2664 //propagate down (vertically propagation)
2665 new_sig |= cur_sig[0];
2666 ux = (new_sig & 0x88888888) >> 3;
2667 tx = ux | (ux << 4) | (ux >> 4);
2669 nxt_mbr[-1] |= (ux << 28) & ~nxt_sig[-1];
2671 nxt_mbr[0] |= tx & ~nxt_sig[0];
2672 nxt_mbr[1] |= (ux >> 28) & ~nxt_sig[1];
2679 for (y = 0; y < height; ++y) {
2680 OPJ_INT32* sp = (OPJ_INT32*)decoded_data + y * stride;
2681 for (x = 0; x < width; ++x, ++sp) {
2682 OPJ_INT32 val = (*sp & 0x7FFFFFFF);
2683 *sp = ((OPJ_UINT32) * sp & 0x80000000) ? -val : val;