2 * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
\r
3 * Copyright (c) 2002-2007, Professor Benoit Macq
\r
4 * Copyright (c) 2001-2003, David Janssens
\r
5 * Copyright (c) 2002-2003, Yannick Verschueren
\r
6 * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
\r
7 * Copyright (c) 2005, Herve Drolon, FreeImage Team
\r
8 * Copyright (c) 2006-2007, Parvatha Elangovan
\r
9 * Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
\r
10 * All rights reserved.
\r
12 * Redistribution and use in source and binary forms, with or without
\r
13 * modification, are permitted provided that the following conditions
\r
15 * 1. Redistributions of source code must retain the above copyright
\r
16 * notice, this list of conditions and the following disclaimer.
\r
17 * 2. Redistributions in binary form must reproduce the above copyright
\r
18 * notice, this list of conditions and the following disclaimer in the
\r
19 * documentation and/or other materials provided with the distribution.
\r
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
\r
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
\r
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
\r
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
\r
25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
\r
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
\r
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
\r
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
\r
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
\r
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
\r
31 * POSSIBILITY OF SUCH DAMAGE.
\r
35 #include "opj_malloc.h"
\r
36 #include "opj_includes.h"
\r
42 #include "function_list.h"
\r
48 /** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
\r
52 /***************************************************************************
\r
53 ********************** TYPEDEFS *******************************************
\r
54 ***************************************************************************/
\r
56 * Correspondance prog order <-> string representation
\r
58 typedef struct j2k_prog_order
\r
60 OPJ_PROG_ORDER enum_prog;
\r
61 OPJ_CHAR str_prog[4];
\r
65 typedef struct opj_dec_memory_marker_handler
\r
69 /** value of the state when the marker can appear */
\r
71 /** action linked to the marker */
\r
74 OPJ_BYTE * p_header_data,
\r
75 OPJ_UINT32 p_header_size,
\r
76 struct opj_event_mgr * p_manager
\r
79 opj_dec_memory_marker_handler_t;
\r
83 /** @name Local static functions */
\r
86 * Writes a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
\r
88 * @param p_comp_no the component number to output.
\r
89 * @param p_stream the stream to write data to.
\r
90 * @param p_j2k J2K codec.
\r
91 * @param p_manager the user event manager.
\r
94 static bool j2k_write_SPCod_SPCoc(
\r
96 OPJ_UINT32 p_tile_no,
\r
97 OPJ_UINT32 p_comp_no,
\r
99 OPJ_UINT32 * p_header_size,
\r
100 struct opj_event_mgr * p_manager
\r
104 * Reads a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
\r
105 * @param p_header_data the data contained in the COM box.
\r
106 * @param p_j2k the jpeg2000 codec.
\r
107 * @param p_header_size the size of the data contained in the COM marker.
\r
108 * @param p_manager the user event manager.
\r
110 static bool j2k_read_SPCod_SPCoc(
\r
113 OPJ_BYTE * p_header_data,
\r
114 OPJ_UINT32 * p_header_size,
\r
115 struct opj_event_mgr * p_manager
\r
119 * Gets the size taken by writting a SPCod or SPCoc for the given tile and component.
\r
121 * @param p_tile_no the tile indix.
\r
122 * @param p_comp_no the component being outputted.
\r
123 * @param p_j2k the J2K codec.
\r
125 * @return the number of bytes taken by the SPCod element.
\r
127 static OPJ_UINT32 j2k_get_SPCod_SPCoc_size (
\r
129 OPJ_UINT32 p_tile_no,
\r
130 OPJ_UINT32 p_comp_no
\r
134 * Writes a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
\r
136 * @param p_tile_no the tile to output.
\r
137 * @param p_comp_no the component number to output.
\r
138 * @param p_data the data buffer.
\r
139 * @param p_header_size pointer to the size of the data buffer, it is changed by the function.
\r
140 * @param p_j2k J2K codec.
\r
141 * @param p_manager the user event manager.
\r
144 static bool j2k_write_SQcd_SQcc(
\r
146 OPJ_UINT32 p_tile_no,
\r
147 OPJ_UINT32 p_comp_no,
\r
149 OPJ_UINT32 * p_header_size,
\r
150 struct opj_event_mgr * p_manager
\r
154 * Reads a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
\r
156 * @param p_tile_no the tile to output.
\r
157 * @param p_comp_no the component number to output.
\r
158 * @param p_data the data buffer.
\r
159 * @param p_header_size pointer to the size of the data buffer, it is changed by the function.
\r
160 * @param p_j2k J2K codec.
\r
161 * @param p_manager the user event manager.
\r
164 static bool j2k_read_SQcd_SQcc(
\r
167 OPJ_BYTE * p_header_data,
\r
168 OPJ_UINT32 * p_header_size,
\r
169 struct opj_event_mgr * p_manager
\r
172 * Updates the Tile Length Marker.
\r
174 static void j2k_update_tlm (
\r
175 opj_j2k_t * p_j2k,
\r
176 OPJ_UINT32 p_tile_part_size);
\r
179 * Gets the size taken by writting SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
\r
181 * @param p_tile_no the tile indix.
\r
182 * @param p_comp_no the component being outputted.
\r
183 * @param p_j2k the J2K codec.
\r
185 * @return the number of bytes taken by the SPCod element.
\r
187 static OPJ_UINT32 j2k_get_SQcd_SQcc_size (
\r
189 OPJ_UINT32 p_tile_no,
\r
190 OPJ_UINT32 p_comp_no
\r
195 * Copies the tile component parameters of all the component from the first tile component.
\r
197 * @param p_j2k the J2k codec.
\r
199 static void j2k_copy_tile_component_parameters(
\r
204 * Writes the SOC marker (Start Of Codestream)
\r
206 * @param p_stream the stream to write data to.
\r
207 * @param p_j2k J2K codec.
\r
208 * @param p_manager the user event manager.
\r
211 static bool j2k_write_soc(
\r
213 struct opj_stream_private *p_stream,
\r
214 struct opj_event_mgr * p_manager
\r
217 * Reads a SOC marker (Start of Codestream)
\r
218 * @param p_header_data the data contained in the SOC box.
\r
219 * @param jp2 the jpeg2000 file codec.
\r
220 * @param p_header_size the size of the data contained in the SOC marker.
\r
221 * @param p_manager the user event manager.
\r
223 static bool j2k_read_soc(
\r
225 struct opj_stream_private *p_stream,
\r
226 struct opj_event_mgr * p_manager
\r
229 * Writes the SIZ marker (image and tile size)
\r
231 * @param p_stream the stream to write data to.
\r
232 * @param p_j2k J2K codec.
\r
233 * @param p_manager the user event manager.
\r
235 static bool j2k_write_siz(
\r
237 struct opj_stream_private *p_stream,
\r
238 struct opj_event_mgr * p_manager
\r
241 * Writes the CBD-MCT-MCC-MCO markers (Multi components transform)
\r
243 * @param p_stream the stream to write data to.
\r
244 * @param p_j2k J2K codec.
\r
245 * @param p_manager the user event manager.
\r
247 static bool j2k_write_mct_data_group(
\r
249 struct opj_stream_private *p_stream,
\r
250 struct opj_event_mgr * p_manager
\r
254 * Reads a SIZ marker (image and tile size)
\r
255 * @param p_header_data the data contained in the SIZ box.
\r
256 * @param jp2 the jpeg2000 file codec.
\r
257 * @param p_header_size the size of the data contained in the SIZ marker.
\r
258 * @param p_manager the user event manager.
\r
260 static bool j2k_read_siz (
\r
262 OPJ_BYTE * p_header_data,
\r
263 OPJ_UINT32 p_header_size,
\r
264 struct opj_event_mgr * p_manager
\r
267 * Writes the COM marker (comment)
\r
269 * @param p_stream the stream to write data to.
\r
270 * @param p_j2k J2K codec.
\r
271 * @param p_manager the user event manager.
\r
273 static bool j2k_write_com(
\r
275 struct opj_stream_private *p_stream,
\r
276 struct opj_event_mgr * p_manager
\r
279 * Reads a COM marker (comments)
\r
280 * @param p_header_data the data contained in the COM box.
\r
281 * @param jp2 the jpeg2000 file codec.
\r
282 * @param p_header_size the size of the data contained in the COM marker.
\r
283 * @param p_manager the user event manager.
\r
285 static bool j2k_read_com (
\r
287 OPJ_BYTE * p_header_data,
\r
288 OPJ_UINT32 p_header_size,
\r
289 struct opj_event_mgr * p_manager
\r
295 * Writes the COD marker (Coding style default)
\r
297 * @param p_stream the stream to write data to.
\r
298 * @param p_j2k J2K codec.
\r
299 * @param p_manager the user event manager.
\r
301 static bool j2k_write_cod(
\r
303 struct opj_stream_private *p_stream,
\r
304 struct opj_event_mgr * p_manager
\r
307 * Reads a COD marker (Coding Styke defaults)
\r
308 * @param p_header_data the data contained in the COD box.
\r
309 * @param p_j2k the jpeg2000 codec.
\r
310 * @param p_header_size the size of the data contained in the COD marker.
\r
311 * @param p_manager the user event manager.
\r
313 static bool j2k_read_cod (
\r
315 OPJ_BYTE * p_header_data,
\r
316 OPJ_UINT32 p_header_size,
\r
317 struct opj_event_mgr * p_manager
\r
321 * Writes the COC marker (Coding style component)
\r
323 * @param p_comp_number the index of the component to output.
\r
324 * @param p_stream the stream to write data to.
\r
325 * @param p_j2k J2K codec.
\r
326 * @param p_manager the user event manager.
\r
328 static bool j2k_write_coc(
\r
330 OPJ_UINT32 p_comp_number,
\r
331 struct opj_stream_private *p_stream,
\r
332 struct opj_event_mgr * p_manager
\r
336 * Writes the COC marker (Coding style component)
\r
338 * @param p_comp_no the index of the component to output.
\r
339 * @param p_stream the stream to write data to.
\r
340 * @param p_j2k J2K codec.
\r
341 * @param p_manager the user event manager.
\r
343 static void j2k_write_coc_in_memory(
\r
345 OPJ_UINT32 p_comp_no,
\r
347 OPJ_UINT32 * p_data_written,
\r
348 struct opj_event_mgr * p_manager
\r
351 * Gets the maximum size taken by a coc.
\r
353 * @param p_j2k the jpeg2000 codec to use.
\r
355 static OPJ_UINT32 j2k_get_max_coc_size(opj_j2k_t *p_j2k);
\r
358 * Reads a COC marker (Coding Style Component)
\r
359 * @param p_header_data the data contained in the COC box.
\r
360 * @param p_j2k the jpeg2000 codec.
\r
361 * @param p_header_size the size of the data contained in the COC marker.
\r
362 * @param p_manager the user event manager.
\r
364 static bool j2k_read_coc (
\r
366 OPJ_BYTE * p_header_data,
\r
367 OPJ_UINT32 p_header_size,
\r
368 struct opj_event_mgr * p_manager
\r
372 * Writes the QCD marker (quantization default)
\r
374 * @param p_comp_number the index of the component to output.
\r
375 * @param p_stream the stream to write data to.
\r
376 * @param p_j2k J2K codec.
\r
377 * @param p_manager the user event manager.
\r
379 static bool j2k_write_qcd(
\r
381 struct opj_stream_private *p_stream,
\r
382 struct opj_event_mgr * p_manager
\r
387 * Reads a QCD marker (Quantization defaults)
\r
388 * @param p_header_data the data contained in the QCD box.
\r
389 * @param p_j2k the jpeg2000 codec.
\r
390 * @param p_header_size the size of the data contained in the QCD marker.
\r
391 * @param p_manager the user event manager.
\r
393 static bool j2k_read_qcd (
\r
395 OPJ_BYTE * p_header_data,
\r
396 OPJ_UINT32 p_header_size,
\r
397 struct opj_event_mgr * p_manager
\r
400 * Writes the QCC marker (quantization component)
\r
402 * @param p_comp_no the index of the component to output.
\r
403 * @param p_stream the stream to write data to.
\r
404 * @param p_j2k J2K codec.
\r
405 * @param p_manager the user event manager.
\r
407 static bool j2k_write_qcc(
\r
409 OPJ_UINT32 p_comp_no,
\r
410 struct opj_stream_private *p_stream,
\r
411 struct opj_event_mgr * p_manager
\r
414 * Writes the QCC marker (quantization component)
\r
416 * @param p_comp_no the index of the component to output.
\r
417 * @param p_stream the stream to write data to.
\r
418 * @param p_j2k J2K codec.
\r
419 * @param p_manager the user event manager.
\r
421 static void j2k_write_qcc_in_memory(
\r
423 OPJ_UINT32 p_comp_no,
\r
425 OPJ_UINT32 * p_data_written,
\r
426 struct opj_event_mgr * p_manager
\r
429 * Gets the maximum size taken by a qcc.
\r
431 static OPJ_UINT32 j2k_get_max_qcc_size (opj_j2k_t *p_j2k);
\r
434 * Reads a QCC marker (Quantization component)
\r
435 * @param p_header_data the data contained in the QCC box.
\r
436 * @param p_j2k the jpeg2000 codec.
\r
437 * @param p_header_size the size of the data contained in the QCC marker.
\r
438 * @param p_manager the user event manager.
\r
440 static bool j2k_read_qcc(
\r
442 OPJ_BYTE * p_header_data,
\r
443 OPJ_UINT32 p_header_size,
\r
444 struct opj_event_mgr * p_manager);
\r
446 * Writes the POC marker (Progression Order Change)
\r
448 * @param p_stream the stream to write data to.
\r
449 * @param p_j2k J2K codec.
\r
450 * @param p_manager the user event manager.
\r
452 static bool j2k_write_poc(
\r
454 struct opj_stream_private *p_stream,
\r
455 struct opj_event_mgr * p_manager
\r
459 * Writes the updated tlm.
\r
461 * @param p_stream the stream to write data to.
\r
462 * @param p_j2k J2K codec.
\r
463 * @param p_manager the user event manager.
\r
465 static bool j2k_write_updated_tlm(
\r
467 struct opj_stream_private *p_stream,
\r
468 struct opj_event_mgr * p_manager
\r
472 * Writes the POC marker (Progression Order Change)
\r
474 * @param p_stream the stream to write data to.
\r
475 * @param p_j2k J2K codec.
\r
476 * @param p_manager the user event manager.
\r
478 static void j2k_write_poc_in_memory(
\r
481 OPJ_UINT32 * p_data_written,
\r
482 struct opj_event_mgr * p_manager
\r
486 * Gets the maximum size taken by the writting of a POC.
\r
488 static OPJ_UINT32 j2k_get_max_poc_size(opj_j2k_t *p_j2k);
\r
491 * Gets the maximum size taken by the toc headers of all the tile parts of any given tile.
\r
493 static OPJ_UINT32 j2k_get_max_toc_size (opj_j2k_t *p_j2k);
\r
496 * Gets the maximum size taken by the headers of the SOT.
\r
498 * @param p_j2k the jpeg2000 codec to use.
\r
500 static OPJ_UINT32 j2k_get_specific_header_sizes(opj_j2k_t *p_j2k);
\r
503 * Reads a POC marker (Progression Order Change)
\r
505 * @param p_header_data the data contained in the POC box.
\r
506 * @param p_j2k the jpeg2000 codec.
\r
507 * @param p_header_size the size of the data contained in the POC marker.
\r
508 * @param p_manager the user event manager.
\r
510 static bool j2k_read_poc (
\r
512 OPJ_BYTE * p_header_data,
\r
513 OPJ_UINT32 p_header_size,
\r
514 struct opj_event_mgr * p_manager
\r
517 * Reads a CRG marker (Component registration)
\r
519 * @param p_header_data the data contained in the TLM box.
\r
520 * @param p_j2k the jpeg2000 codec.
\r
521 * @param p_header_size the size of the data contained in the TLM marker.
\r
522 * @param p_manager the user event manager.
\r
524 static bool j2k_read_crg (
\r
526 OPJ_BYTE * p_header_data,
\r
527 OPJ_UINT32 p_header_size,
\r
528 struct opj_event_mgr * p_manager
\r
531 * Reads a TLM marker (Tile Length Marker)
\r
533 * @param p_header_data the data contained in the TLM box.
\r
534 * @param p_j2k the jpeg2000 codec.
\r
535 * @param p_header_size the size of the data contained in the TLM marker.
\r
536 * @param p_manager the user event manager.
\r
538 static bool j2k_read_tlm (
\r
540 OPJ_BYTE * p_header_data,
\r
541 OPJ_UINT32 p_header_size,
\r
542 struct opj_event_mgr * p_manager
\r
545 * Reads a PLM marker (Packet length, main header marker)
\r
547 * @param p_header_data the data contained in the TLM box.
\r
548 * @param p_j2k the jpeg2000 codec.
\r
549 * @param p_header_size the size of the data contained in the TLM marker.
\r
550 * @param p_manager the user event manager.
\r
552 static bool j2k_read_plm (
\r
554 OPJ_BYTE * p_header_data,
\r
555 OPJ_UINT32 p_header_size,
\r
556 struct opj_event_mgr * p_manager
\r
559 * Reads a PLT marker (Packet length, tile-part header)
\r
561 * @param p_header_data the data contained in the PLT box.
\r
562 * @param p_j2k the jpeg2000 codec.
\r
563 * @param p_header_size the size of the data contained in the PLT marker.
\r
564 * @param p_manager the user event manager.
\r
566 static bool j2k_read_plt (
\r
568 OPJ_BYTE * p_header_data,
\r
569 OPJ_UINT32 p_header_size,
\r
570 struct opj_event_mgr * p_manager
\r
573 * Reads a PPM marker (Packed packet headers, main header)
\r
575 * @param p_header_data the data contained in the POC box.
\r
576 * @param p_j2k the jpeg2000 codec.
\r
577 * @param p_header_size the size of the data contained in the POC marker.
\r
578 * @param p_manager the user event manager.
\r
580 static bool j2k_read_ppm (
\r
582 OPJ_BYTE * p_header_data,
\r
583 OPJ_UINT32 p_header_size,
\r
584 struct opj_event_mgr * p_manager
\r
587 * Reads a PPT marker (Packed packet headers, tile-part header)
\r
589 * @param p_header_data the data contained in the PPT box.
\r
590 * @param p_j2k the jpeg2000 codec.
\r
591 * @param p_header_size the size of the data contained in the PPT marker.
\r
592 * @param p_manager the user event manager.
\r
594 static bool j2k_read_ppt (
\r
596 OPJ_BYTE * p_header_data,
\r
597 OPJ_UINT32 p_header_size,
\r
598 struct opj_event_mgr * p_manager
\r
601 * Writes the TLM marker (Tile Length Marker)
\r
603 * @param p_stream the stream to write data to.
\r
604 * @param p_j2k J2K codec.
\r
605 * @param p_manager the user event manager.
\r
607 static bool j2k_write_tlm(
\r
609 struct opj_stream_private *p_stream,
\r
610 struct opj_event_mgr * p_manager
\r
613 * Writes the SOT marker (Start of tile-part)
\r
615 * @param p_stream the stream to write data to.
\r
616 * @param p_j2k J2K codec.
\r
617 * @param p_manager the user event manager.
\r
619 static bool j2k_write_sot(
\r
622 OPJ_UINT32 * p_data_written,
\r
623 const struct opj_stream_private *p_stream,
\r
624 struct opj_event_mgr * p_manager
\r
627 * Reads a PPT marker (Packed packet headers, tile-part header)
\r
629 * @param p_header_data the data contained in the PPT box.
\r
630 * @param p_j2k the jpeg2000 codec.
\r
631 * @param p_header_size the size of the data contained in the PPT marker.
\r
632 * @param p_manager the user event manager.
\r
634 static bool j2k_read_sot (
\r
636 OPJ_BYTE * p_header_data,
\r
637 OPJ_UINT32 p_header_size,
\r
638 struct opj_event_mgr * p_manager
\r
641 * Writes the SOD marker (Start of data)
\r
643 * @param p_stream the stream to write data to.
\r
644 * @param p_j2k J2K codec.
\r
645 * @param p_manager the user event manager.
\r
647 static bool j2k_write_sod(
\r
649 struct opj_tcd * p_tile_coder,
\r
651 OPJ_UINT32 * p_data_written,
\r
652 OPJ_UINT32 p_total_data_size,
\r
653 const struct opj_stream_private *p_stream,
\r
654 struct opj_event_mgr * p_manager
\r
657 * Reads a SOD marker (Start Of Data)
\r
659 * @param p_header_data the data contained in the SOD box.
\r
660 * @param p_j2k the jpeg2000 codec.
\r
661 * @param p_header_size the size of the data contained in the SOD marker.
\r
662 * @param p_manager the user event manager.
\r
664 static bool j2k_read_sod (
\r
666 struct opj_stream_private *p_stream,
\r
667 struct opj_event_mgr * p_manager
\r
670 * Writes the RGN marker (Region Of Interest)
\r
672 * @param p_tile_no the tile to output
\r
673 * @param p_comp_no the component to output
\r
674 * @param p_stream the stream to write data to.
\r
675 * @param p_j2k J2K codec.
\r
676 * @param p_manager the user event manager.
\r
678 static bool j2k_write_rgn(
\r
680 OPJ_UINT32 p_tile_no,
\r
681 OPJ_UINT32 p_comp_no,
\r
682 struct opj_stream_private *p_stream,
\r
683 struct opj_event_mgr * p_manager
\r
686 * Reads a RGN marker (Region Of Interest)
\r
688 * @param p_header_data the data contained in the POC box.
\r
689 * @param p_j2k the jpeg2000 codec.
\r
690 * @param p_header_size the size of the data contained in the POC marker.
\r
691 * @param p_manager the user event manager.
\r
693 static bool j2k_read_rgn (
\r
695 OPJ_BYTE * p_header_data,
\r
696 OPJ_UINT32 p_header_size,
\r
697 struct opj_event_mgr * p_manager
\r
700 * Writes the EOC marker (End of Codestream)
\r
702 * @param p_stream the stream to write data to.
\r
703 * @param p_j2k J2K codec.
\r
704 * @param p_manager the user event manager.
\r
706 static bool j2k_write_eoc(
\r
708 struct opj_stream_private *p_stream,
\r
709 struct opj_event_mgr * p_manager
\r
713 * Copies the tile component parameters of all the component from the first tile component.
\r
715 * @param p_j2k the J2k codec.
\r
717 static void j2k_copy_tile_quantization_parameters(
\r
722 * Reads a EOC marker (End Of Codestream)
\r
724 * @param p_header_data the data contained in the SOD box.
\r
725 * @param p_j2k the jpeg2000 codec.
\r
726 * @param p_header_size the size of the data contained in the SOD marker.
\r
727 * @param p_manager the user event manager.
\r
729 static bool j2k_read_eoc (
\r
731 struct opj_stream_private *p_stream,
\r
732 struct opj_event_mgr * p_manager
\r
738 * @param p_stream the stream to write data to.
\r
739 * @param p_j2k J2K codec.
\r
740 * @param p_manager the user event manager.
\r
742 static bool j2k_init_info(
\r
744 struct opj_stream_private *p_stream,
\r
745 struct opj_event_mgr * p_manager
\r
748 * Reads an unknown marker
\r
750 * @param p_stream the stream object to read from.
\r
751 * @param p_j2k the jpeg2000 codec.
\r
752 * @param p_manager the user event manager.
\r
754 * @return true if the marker could be deduced.
\r
756 static bool j2k_read_unk (
\r
758 struct opj_stream_private *p_stream,
\r
759 struct opj_event_mgr * p_manager
\r
762 * Ends the encoding, i.e. frees memory.
\r
764 * @param p_stream the stream to write data to.
\r
765 * @param p_j2k J2K codec.
\r
766 * @param p_manager the user event manager.
\r
768 static bool j2k_end_encoding(
\r
770 struct opj_stream_private *p_stream,
\r
771 struct opj_event_mgr * p_manager
\r
775 * Writes the CBD marker (Component bit depth definition)
\r
777 * @param p_stream the stream to write data to.
\r
778 * @param p_j2k J2K codec.
\r
779 * @param p_manager the user event manager.
\r
781 static bool j2k_write_cbd(
\r
783 struct opj_stream_private *p_stream,
\r
784 struct opj_event_mgr * p_manager
\r
788 * Reads a CBD marker (Component bit depth definition)
\r
789 * @param p_header_data the data contained in the CBD box.
\r
790 * @param p_j2k the jpeg2000 codec.
\r
791 * @param p_header_size the size of the data contained in the CBD marker.
\r
792 * @param p_manager the user event manager.
\r
794 static bool j2k_read_cbd (
\r
796 OPJ_BYTE * p_header_data,
\r
797 OPJ_UINT32 p_header_size,
\r
798 struct opj_event_mgr * p_manager);
\r
801 * Writes the MCT marker (Multiple Component Transform)
\r
803 * @param p_stream the stream to write data to.
\r
804 * @param p_j2k J2K codec.
\r
805 * @param p_manager the user event manager.
\r
807 static bool j2k_write_mct_record(
\r
809 opj_mct_data_t * p_mct_record,
\r
810 struct opj_stream_private *p_stream,
\r
811 struct opj_event_mgr * p_manager
\r
815 * Reads a MCT marker (Multiple Component Transform)
\r
817 * @param p_header_data the data contained in the MCT box.
\r
818 * @param p_j2k the jpeg2000 codec.
\r
819 * @param p_header_size the size of the data contained in the MCT marker.
\r
820 * @param p_manager the user event manager.
\r
822 static bool j2k_read_mct (
\r
824 OPJ_BYTE * p_header_data,
\r
825 OPJ_UINT32 p_header_size,
\r
826 struct opj_event_mgr * p_manager
\r
830 * Writes the MCC marker (Multiple Component Collection)
\r
832 * @param p_stream the stream to write data to.
\r
833 * @param p_j2k J2K codec.
\r
834 * @param p_manager the user event manager.
\r
836 static bool j2k_write_mcc_record(
\r
838 struct opj_simple_mcc_decorrelation_data * p_mcc_record,
\r
839 struct opj_stream_private *p_stream,
\r
840 struct opj_event_mgr * p_manager
\r
844 * Reads a MCC marker (Multiple Component Collection)
\r
846 * @param p_header_data the data contained in the MCC box.
\r
847 * @param p_j2k the jpeg2000 codec.
\r
848 * @param p_header_size the size of the data contained in the MCC marker.
\r
849 * @param p_manager the user event manager.
\r
851 static bool j2k_read_mcc (
\r
853 OPJ_BYTE * p_header_data,
\r
854 OPJ_UINT32 p_header_size,
\r
855 struct opj_event_mgr * p_manager
\r
859 * Writes the MCO marker (Multiple component transformation ordering)
\r
861 * @param p_stream the stream to write data to.
\r
862 * @param p_j2k J2K codec.
\r
863 * @param p_manager the user event manager.
\r
865 static bool j2k_write_mco(
\r
867 struct opj_stream_private *p_stream,
\r
868 struct opj_event_mgr * p_manager
\r
872 * Reads a MCO marker (Multiple Component Transform Ordering)
\r
874 * @param p_header_data the data contained in the MCO box.
\r
875 * @param p_j2k the jpeg2000 codec.
\r
876 * @param p_header_size the size of the data contained in the MCO marker.
\r
877 * @param p_manager the user event manager.
\r
879 static bool j2k_read_mco (
\r
881 OPJ_BYTE * p_header_data,
\r
882 OPJ_UINT32 p_header_size,
\r
883 struct opj_event_mgr * p_manager
\r
886 * Writes the image components.
\r
888 * @param p_stream the stream to write data to.
\r
889 * @param p_j2k J2K codec.
\r
890 * @param p_manager the user event manager.
\r
892 static bool j2k_write_image_components(
\r
894 struct opj_stream_private *p_stream,
\r
895 struct opj_event_mgr * p_manager
\r
899 * Writes regions of interests.
\r
901 * @param p_stream the stream to write data to.
\r
902 * @param p_j2k J2K codec.
\r
903 * @param p_manager the user event manager.
\r
905 static bool j2k_write_regions(
\r
907 struct opj_stream_private *p_stream,
\r
908 struct opj_event_mgr * p_manager
\r
913 * @param p_stream the stream to write data to.
\r
914 * @param p_j2k J2K codec.
\r
915 * @param p_manager the user event manager.
\r
917 static bool j2k_write_epc(
\r
919 struct opj_stream_private *p_stream,
\r
920 struct opj_event_mgr * p_manager
\r
924 * Checks the progression order changes values. Tells of the poc given as input are valid.
\r
925 * A nice message is outputted at errors.
\r
927 * @param p_pocs the progression order changes.
\r
928 * @param p_nb_pocs the number of progression order changes.
\r
929 * @param p_nb_resolutions the number of resolutions.
\r
930 * @param numcomps the number of components
\r
931 * @param numlayers the number of layers.
\r
933 * @return true if the pocs are valid.
\r
935 static bool j2k_check_poc_val(
\r
936 const opj_poc_t *p_pocs,
\r
937 OPJ_UINT32 p_nb_pocs,
\r
938 OPJ_UINT32 p_nb_resolutions,
\r
939 OPJ_UINT32 numcomps,
\r
940 OPJ_UINT32 numlayers,
\r
941 opj_event_mgr_t * p_manager);
\r
944 * Gets the number of tile parts used for the given change of progression (if any) and the given tile.
\r
946 * @param cp the coding parameters.
\r
947 * @param pino the offset of the given poc (i.e. its position in the coding parameter).
\r
948 * @param tileno the given tile.
\r
950 * @return the number of tile parts.
\r
952 static OPJ_UINT32 j2k_get_num_tp(
\r
955 OPJ_UINT32 tileno);
\r
957 * Calculates the total number of tile parts needed by the encoder to
\r
958 * encode such an image. If not enough memory is available, then the function return false.
\r
960 * @param p_nb_tiles pointer that will hold the number of tile parts.
\r
961 * @param cp the coding parameters for the image.
\r
962 * @param image the image to encode.
\r
963 * @param p_j2k the p_j2k encoder.
\r
964 * @param p_manager the user event manager.
\r
966 * @return true if the function was successful, false else.
\r
968 static bool j2k_calculate_tp(
\r
971 OPJ_UINT32 * p_nb_tiles,
\r
972 opj_image_t *image,
\r
973 opj_event_mgr_t * p_manager);
\r
975 static bool j2k_write_first_tile_part (
\r
978 OPJ_UINT32 * p_data_written,
\r
979 OPJ_UINT32 p_total_data_size,
\r
980 opj_stream_private_t *p_stream,
\r
981 struct opj_event_mgr * p_manager
\r
983 static bool j2k_write_all_tile_parts(
\r
986 OPJ_UINT32 * p_data_written,
\r
987 OPJ_UINT32 p_total_data_size,
\r
988 opj_stream_private_t *p_stream,
\r
989 struct opj_event_mgr * p_manager
\r
993 * Reads the lookup table containing all the marker, status and action, and returns the handler associated
\r
994 * with the marker value.
\r
995 * @param p_id Marker value to look up
\r
997 * @return the handler associated with the id.
\r
999 static const struct opj_dec_memory_marker_handler * j2k_get_marker_handler (OPJ_UINT32 p_id);
\r
1002 * Destroys a tile coding parameter structure.
\r
1004 * @param p_tcp the tile coding parameter to destroy.
\r
1006 static void j2k_tcp_destroy (opj_tcp_t *p_tcp);
\r
1008 static void j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data);
\r
1011 * Destroys a coding parameter structure.
\r
1013 * @param p_cp the coding parameter to destroy.
\r
1015 static void j2k_cp_destroy (opj_cp_t *p_cp);
\r
1018 * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
\r
1019 * are valid. Developpers wanting to extend the library can add their own validation procedures.
\r
1021 static void j2k_setup_encoding_validation (opj_j2k_t *p_j2k);
\r
1024 * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
\r
1025 * are valid. Developpers wanting to extend the library can add their own validation procedures.
\r
1027 static void j2k_setup_decoding_validation (opj_j2k_t *p_j2k);
\r
1030 * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
\r
1031 * are valid. Developpers wanting to extend the library can add their own validation procedures.
\r
1033 static void j2k_setup_end_compress (opj_j2k_t *p_j2k);
\r
1036 * Creates a tile-coder decoder.
\r
1038 * @param p_stream the stream to write data to.
\r
1039 * @param p_j2k J2K codec.
\r
1040 * @param p_manager the user event manager.
\r
1042 static bool j2k_create_tcd(
\r
1044 struct opj_stream_private *p_stream,
\r
1045 struct opj_event_mgr * p_manager
\r
1049 * Excutes the given procedures on the given codec.
\r
1051 * @param p_procedure_list the list of procedures to execute
\r
1052 * @param p_j2k the jpeg2000 codec to execute the procedures on.
\r
1053 * @param p_stream the stream to execute the procedures on.
\r
1054 * @param p_manager the user manager.
\r
1056 * @return true if all the procedures were successfully executed.
\r
1058 static bool j2k_exec (
\r
1059 opj_j2k_t * p_j2k,
\r
1060 opj_procedure_list_t * p_procedure_list,
\r
1061 opj_stream_private_t *p_stream,
\r
1062 opj_event_mgr_t * p_manager
\r
1065 * Updates the rates of the tcp.
\r
1067 * @param p_stream the stream to write data to.
\r
1068 * @param p_j2k J2K codec.
\r
1069 * @param p_manager the user event manager.
\r
1071 static bool j2k_update_rates(
\r
1073 struct opj_stream_private *p_stream,
\r
1074 struct opj_event_mgr * p_manager
\r
1078 * The default encoding validation procedure without any extension.
\r
1080 * @param p_j2k the jpeg2000 codec to validate.
\r
1081 * @param p_stream the input stream to validate.
\r
1082 * @param p_manager the user event manager.
\r
1084 * @return true if the parameters are correct.
\r
1086 bool j2k_encoding_validation (
\r
1087 opj_j2k_t * p_j2k,
\r
1088 opj_stream_private_t *p_stream,
\r
1089 opj_event_mgr_t * p_manager
\r
1092 * The read header procedure.
\r
1094 bool j2k_read_header_procedure(
\r
1096 struct opj_stream_private *p_stream,
\r
1097 struct opj_event_mgr * p_manager);
\r
1100 * The default decoding validation procedure without any extension.
\r
1102 * @param p_j2k the jpeg2000 codec to validate.
\r
1103 * @param p_stream the input stream to validate.
\r
1104 * @param p_manager the user event manager.
\r
1106 * @return true if the parameters are correct.
\r
1108 bool j2k_decoding_validation (
\r
1109 opj_j2k_t * p_j2k,
\r
1110 opj_stream_private_t *p_stream,
\r
1111 opj_event_mgr_t * p_manager
\r
1114 * Reads the tiles.
\r
1116 bool j2k_decode_tiles (
\r
1118 struct opj_stream_private *p_stream,
\r
1119 struct opj_event_mgr * p_manager);
\r
1122 * The mct encoding validation procedure.
\r
1124 * @param p_j2k the jpeg2000 codec to validate.
\r
1125 * @param p_stream the input stream to validate.
\r
1126 * @param p_manager the user event manager.
\r
1128 * @return true if the parameters are correct.
\r
1130 bool j2k_mct_validation (
\r
1131 opj_j2k_t * p_j2k,
\r
1132 opj_stream_private_t *p_stream,
\r
1133 opj_event_mgr_t * p_manager
\r
1136 * Builds the tcd decoder to use to decode tile.
\r
1138 bool j2k_build_decoder (
\r
1139 opj_j2k_t * p_j2k,
\r
1140 opj_stream_private_t *p_stream,
\r
1141 opj_event_mgr_t * p_manager
\r
1144 * Builds the tcd encoder to use to encode tile.
\r
1146 bool j2k_build_encoder (
\r
1147 opj_j2k_t * p_j2k,
\r
1148 opj_stream_private_t *p_stream,
\r
1149 opj_event_mgr_t * p_manager
\r
1152 * Copies the decoding tile parameters onto all the tile parameters.
\r
1153 * Creates also the tile decoder.
\r
1155 bool j2k_copy_default_tcp_and_create_tcd(
\r
1156 opj_j2k_t * p_j2k,
\r
1157 opj_stream_private_t *p_stream,
\r
1158 opj_event_mgr_t * p_manager
\r
1161 * Destroys the memory associated with the decoding of headers.
\r
1163 bool j2k_destroy_header_memory (
\r
1164 opj_j2k_t * p_j2k,
\r
1165 opj_stream_private_t *p_stream,
\r
1166 opj_event_mgr_t * p_manager
\r
1170 * Sets up the procedures to do on writting header. Developpers wanting to extend the library can add their own writting procedures.
\r
1172 void j2k_setup_header_writting (opj_j2k_t *p_j2k);
\r
1175 * Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures.
\r
1177 void j2k_setup_header_reading (opj_j2k_t *p_j2k);
\r
1181 * @param p_j2k the jpeg2000 codec.
\r
1182 * @param p_stream the stream to write data to.
\r
1183 * @param p_manager the user event manager.
\r
1185 static bool j2k_post_write_tile (
\r
1186 opj_j2k_t * p_j2k,
\r
1187 OPJ_BYTE * p_data,
\r
1188 OPJ_UINT32 p_data_size,
\r
1189 opj_stream_private_t *p_stream,
\r
1190 opj_event_mgr_t * p_manager
\r
1193 static bool j2k_pre_write_tile (
\r
1194 opj_j2k_t * p_j2k,
\r
1195 OPJ_UINT32 p_tile_index,
\r
1196 opj_stream_private_t *p_stream,
\r
1197 opj_event_mgr_t * p_manager
\r
1199 static bool j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data);
\r
1201 static bool j2k_add_mct(opj_tcp_t * p_tcp,opj_image_t * p_image, OPJ_UINT32 p_index);
\r
1203 * Gets the offset of the header.
\r
1205 * @param p_stream the stream to write data to.
\r
1206 * @param p_j2k J2K codec.
\r
1207 * @param p_manager the user event manager.
\r
1209 static bool j2k_get_end_header(
\r
1211 struct opj_stream_private *p_stream,
\r
1212 struct opj_event_mgr * p_manager
\r
1215 static void j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1216 static void j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1217 static void j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1218 static void j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1220 static void j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1221 static void j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1222 static void j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1223 static void j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1225 static void j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1226 static void j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1227 static void j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1228 static void j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1236 /* ----------------------------------------------------------------------- */
\r
1240 /****************************************************************************
\r
1241 ********************* CONSTANTS ********************************************
\r
1242 ****************************************************************************/
\r
1248 * List of progression orders.
\r
1250 const j2k_prog_order_t j2k_prog_order_list [] =
\r
1260 const OPJ_UINT32 MCT_ELEMENT_SIZE [] =
\r
1268 typedef void (* j2k_mct_function) (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
\r
1270 const j2k_mct_function j2k_mct_read_functions_to_float [] =
\r
1272 j2k_read_int16_to_float,
\r
1273 j2k_read_int32_to_float,
\r
1274 j2k_read_float32_to_float,
\r
1275 j2k_read_float64_to_float
\r
1278 const j2k_mct_function j2k_mct_read_functions_to_int32 [] =
\r
1280 j2k_read_int16_to_int32,
\r
1281 j2k_read_int32_to_int32,
\r
1282 j2k_read_float32_to_int32,
\r
1283 j2k_read_float64_to_int32
\r
1286 const j2k_mct_function j2k_mct_write_functions_from_float [] =
\r
1288 j2k_write_float_to_int16,
\r
1289 j2k_write_float_to_int32,
\r
1290 j2k_write_float_to_float,
\r
1291 j2k_write_float_to_float64
\r
1297 /*const opj_dec_stream_marker_handler_t j2k_stream_marker_handler_tab[] =
\r
1299 {J2K_MS_SOC, J2K_DEC_STATE_MHSOC, j2k_read_soc},
\r
1300 {J2K_MS_SOD, J2K_DEC_STATE_TPH, j2k_read_sod},
\r
1301 {J2K_MS_EOC, J2K_DEC_STATE_TPHSOT, j2k_read_eoc},
\r
1302 {J2K_MS_SOP, 0, 0},
\r
1304 {J2K_MS_EPC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_epc},
\r
1305 {J2K_MS_EPB, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_epb},
\r
1306 {J2K_MS_ESD, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_esd},
\r
1307 {J2K_MS_RED, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_red},
\r
1310 {J2K_MS_SEC, J2K_DEC_STATE_MH, j2k_read_sec},
\r
1311 {J2K_MS_INSEC, 0, j2k_read_insec},
\r
1314 {0, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_unk}
\r
1317 const opj_dec_memory_marker_handler_t j2k_memory_marker_handler_tab [] =
\r
1319 {J2K_MS_SOT, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPHSOT, j2k_read_sot},
\r
1320 {J2K_MS_COD, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_cod},
\r
1321 {J2K_MS_COC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_coc},
\r
1322 {J2K_MS_RGN, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_rgn},
\r
1323 {J2K_MS_QCD, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_qcd},
\r
1324 {J2K_MS_QCC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_qcc},
\r
1325 {J2K_MS_POC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_poc},
\r
1326 {J2K_MS_SIZ, J2K_DEC_STATE_MHSIZ , j2k_read_siz},
\r
1327 {J2K_MS_TLM, J2K_DEC_STATE_MH, j2k_read_tlm},
\r
1328 {J2K_MS_PLM, J2K_DEC_STATE_MH, j2k_read_plm},
\r
1329 {J2K_MS_PLT, J2K_DEC_STATE_TPH, j2k_read_plt},
\r
1330 {J2K_MS_PPM, J2K_DEC_STATE_MH, j2k_read_ppm},
\r
1331 {J2K_MS_PPT, J2K_DEC_STATE_TPH, j2k_read_ppt},
\r
1332 {J2K_MS_SOP, 0, 0},
\r
1333 {J2K_MS_CRG, J2K_DEC_STATE_MH, j2k_read_crg},
\r
1334 {J2K_MS_COM, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_com},
\r
1335 {J2K_MS_MCT, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_mct},
\r
1336 {J2K_MS_CBD, J2K_DEC_STATE_MH , j2k_read_cbd},
\r
1337 {J2K_MS_MCC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_mcc},
\r
1338 {J2K_MS_MCO, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_mco}
\r
1340 {J2K_MS_EPC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_epc},
\r
1341 {J2K_MS_EPB, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_epb},
\r
1342 {J2K_MS_ESD, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_esd},
\r
1343 {J2K_MS_RED, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_red},
\r
1344 #endif /* USE_JPWL */
\r
1346 {J2K_MS_SEC, J2K_DEC_STATE_MH, j2k_read_sec},
\r
1347 {J2K_MS_INSEC, 0, j2k_read_insec}
\r
1348 #endif /* USE_JPSEC */
\r
1351 void j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1353 OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
\r
1354 OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
\r
1356 OPJ_UINT32 l_temp;
\r
1359 (i=0;i<p_nb_elem;++i)
\r
1361 opj_read_bytes(l_src_data,&l_temp,2);
\r
1362 l_src_data+=sizeof(OPJ_INT16);
\r
1363 *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
\r
1367 void j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1369 OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
\r
1370 OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
\r
1372 OPJ_UINT32 l_temp;
\r
1375 (i=0;i<p_nb_elem;++i)
\r
1377 opj_read_bytes(l_src_data,&l_temp,4);
\r
1378 l_src_data+=sizeof(OPJ_INT32);
\r
1379 *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
\r
1382 void j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1384 OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
\r
1385 OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
\r
1387 OPJ_FLOAT32 l_temp;
\r
1390 (i=0;i<p_nb_elem;++i)
\r
1392 opj_read_float(l_src_data,&l_temp);
\r
1393 l_src_data+=sizeof(OPJ_FLOAT32);
\r
1394 *(l_dest_data++) = l_temp;
\r
1398 void j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1400 OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
\r
1401 OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
\r
1403 OPJ_FLOAT64 l_temp;
\r
1406 (i=0;i<p_nb_elem;++i)
\r
1408 opj_read_double(l_src_data,&l_temp);
\r
1409 l_src_data+=sizeof(OPJ_FLOAT64);
\r
1410 *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
\r
1415 void j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1417 OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
\r
1418 OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
\r
1420 OPJ_UINT32 l_temp;
\r
1423 (i=0;i<p_nb_elem;++i)
\r
1425 opj_read_bytes(l_src_data,&l_temp,2);
\r
1426 l_src_data+=sizeof(OPJ_INT16);
\r
1427 *(l_dest_data++) = (OPJ_INT32) l_temp;
\r
1431 void j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1433 OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
\r
1434 OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
\r
1436 OPJ_UINT32 l_temp;
\r
1439 (i=0;i<p_nb_elem;++i)
\r
1441 opj_read_bytes(l_src_data,&l_temp,4);
\r
1442 l_src_data+=sizeof(OPJ_INT32);
\r
1443 *(l_dest_data++) = (OPJ_INT32) l_temp;
\r
1446 void j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1448 OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
\r
1449 OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
\r
1451 OPJ_FLOAT32 l_temp;
\r
1454 (i=0;i<p_nb_elem;++i)
\r
1456 opj_read_float(l_src_data,&l_temp);
\r
1457 l_src_data+=sizeof(OPJ_FLOAT32);
\r
1458 *(l_dest_data++) = (OPJ_INT32) l_temp;
\r
1462 void j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1464 OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
\r
1465 OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
\r
1467 OPJ_FLOAT64 l_temp;
\r
1470 (i=0;i<p_nb_elem;++i)
\r
1472 opj_read_double(l_src_data,&l_temp);
\r
1473 l_src_data+=sizeof(OPJ_FLOAT64);
\r
1474 *(l_dest_data++) = (OPJ_INT32) l_temp;
\r
1479 void j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1481 OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
\r
1482 OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
\r
1484 OPJ_UINT32 l_temp;
\r
1487 (i=0;i<p_nb_elem;++i)
\r
1489 l_temp = (OPJ_UINT32) *(l_src_data++);
\r
1490 opj_write_bytes(l_dest_data,l_temp,sizeof(OPJ_INT16));
\r
1491 l_dest_data+=sizeof(OPJ_INT16);
\r
1495 void j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1497 OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
\r
1498 OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
\r
1500 OPJ_UINT32 l_temp;
\r
1503 (i=0;i<p_nb_elem;++i)
\r
1505 l_temp = (OPJ_UINT32) *(l_src_data++);
\r
1506 opj_write_bytes(l_dest_data,l_temp,sizeof(OPJ_INT32));
\r
1507 l_dest_data+=sizeof(OPJ_INT32);
\r
1511 void j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1513 OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
\r
1514 OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
\r
1516 OPJ_FLOAT32 l_temp;
\r
1519 (i=0;i<p_nb_elem;++i)
\r
1521 l_temp = (OPJ_FLOAT32) *(l_src_data++);
\r
1522 opj_write_float(l_dest_data,l_temp);
\r
1523 l_dest_data+=sizeof(OPJ_FLOAT32);
\r
1528 void j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
\r
1530 OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
\r
1531 OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
\r
1533 OPJ_FLOAT64 l_temp;
\r
1535 (i=0;i<p_nb_elem;++i)
\r
1537 l_temp = (OPJ_FLOAT64) *(l_src_data++);
\r
1538 opj_write_double(l_dest_data,l_temp);
\r
1539 l_dest_data+=sizeof(OPJ_FLOAT64);
\r
1547 * Converts an enum type progression order to string type.
\r
1549 * @param prg_order the progression order to get.
\r
1551 * @return the string representation of the gicen progression order.
\r
1553 const OPJ_CHAR * j2k_convert_progression_order(OPJ_PROG_ORDER p_prg_order)
\r
1555 const j2k_prog_order_t *po;
\r
1557 (po = j2k_prog_order_list; po->enum_prog != -1; ++po )
\r
1560 (po->enum_prog == p_prg_order)
\r
1562 return po->str_prog;
\r
1565 return po->str_prog;
\r
1575 * Checks the progression order changes values. Tells if the poc given as input are valid.
\r
1577 * @param p_pocs the progression order changes.
\r
1578 * @param p_nb_pocs the number of progression order changes.
\r
1579 * @param p_nb_resolutions the number of resolutions.
\r
1580 * @param numcomps the number of components
\r
1581 * @param numlayers the number of layers.
\r
1582 * @param p_manager the user event manager.
\r
1584 * @return true if the pocs are valid.
\r
1586 bool j2k_check_poc_val(const opj_poc_t *p_pocs, OPJ_UINT32 p_nb_pocs, OPJ_UINT32 p_nb_resolutions, OPJ_UINT32 p_num_comps, OPJ_UINT32 p_num_layers, opj_event_mgr_t * p_manager)
\r
1588 OPJ_UINT32* packet_array;
\r
1589 OPJ_UINT32 index , resno, compno, layno;
\r
1591 OPJ_UINT32 step_c = 1;
\r
1592 OPJ_UINT32 step_r = p_num_comps * step_c;
\r
1593 OPJ_UINT32 step_l = p_nb_resolutions * step_r;
\r
1594 bool loss = false;
\r
1595 OPJ_UINT32 layno0 = 0;
\r
1597 packet_array = (OPJ_UINT32*) opj_calloc(step_l * p_num_layers, sizeof(OPJ_UINT32));
\r
1599 (packet_array == 00)
\r
1601 opj_event_msg(p_manager , EVT_ERROR, "Not enough memory for checking the poc values.\n");
\r
1604 memset(packet_array,0,step_l * p_num_layers* sizeof(OPJ_UINT32));
\r
1611 index = step_r * p_pocs->resno0;
\r
1612 // take each resolution for each poc
\r
1614 (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno)
\r
1616 OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c;
\r
1617 // take each comp of each resolution for each poc
\r
1619 (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno)
\r
1621 OPJ_UINT32 comp_index = res_index + layno0 * step_l;
\r
1622 // and finally take each layer of each res of ...
\r
1624 (layno = layno0; layno < p_pocs->layno1 ; ++layno)
\r
1626 //index = step_r * resno + step_c * compno + step_l * layno;
\r
1627 packet_array[comp_index] = 1;
\r
1628 comp_index += step_l;
\r
1630 res_index += step_c;
\r
1635 // iterate through all the pocs
\r
1637 (i = 1; i < p_nb_pocs ; ++i)
\r
1639 OPJ_UINT32 l_last_layno1 = (p_pocs-1)->layno1 ;
\r
1640 layno0 = (p_pocs->layno1 > l_last_layno1)? l_last_layno1 : 0;
\r
1641 index = step_r * p_pocs->resno0;
\r
1642 // take each resolution for each poc
\r
1644 (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno)
\r
1646 OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c;
\r
1647 // take each comp of each resolution for each poc
\r
1649 (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno)
\r
1651 OPJ_UINT32 comp_index = res_index + layno0 * step_l;
\r
1652 // and finally take each layer of each res of ...
\r
1654 (layno = layno0; layno < p_pocs->layno1 ; ++layno)
\r
1656 //index = step_r * resno + step_c * compno + step_l * layno;
\r
1657 packet_array[comp_index] = 1;
\r
1658 comp_index += step_l;
\r
1660 res_index += step_c;
\r
1669 (layno = 0; layno < p_num_layers ; ++layno)
\r
1672 (resno = 0; resno < p_nb_resolutions; ++resno)
\r
1675 (compno = 0; compno < p_num_comps; ++compno)
\r
1677 loss |= (packet_array[index]!=1);
\r
1678 //index = step_r * resno + step_c * compno + step_l * layno;
\r
1686 opj_event_msg(p_manager , EVT_ERROR, "Missing packets possible loss of data\n");
\r
1688 opj_free(packet_array);
\r
1693 /* ----------------------------------------------------------------------- */
\r
1696 * Gets the number of tile parts used for the given change of progression (if any) and the given tile.
\r
1698 * @param cp the coding parameters.
\r
1699 * @param pino the offset of the given poc (i.e. its position in the coding parameter).
\r
1700 * @param tileno the given tile.
\r
1702 * @return the number of tile parts.
\r
1704 OPJ_UINT32 j2k_get_num_tp(opj_cp_t *cp,OPJ_UINT32 pino,OPJ_UINT32 tileno)
\r
1706 const OPJ_CHAR *prog = 00;
\r
1708 OPJ_UINT32 tpnum = 1;
\r
1709 opj_tcp_t *tcp = 00;
\r
1710 opj_poc_t * l_current_poc = 00;
\r
1712 // preconditions only in debug
\r
1713 assert(tileno < (cp->tw * cp->th));
\r
1714 assert(pino < (cp->tcps[tileno].numpocs + 1));
\r
1716 // get the given tile coding parameter
\r
1717 tcp = &cp->tcps[tileno];
\r
1718 assert(tcp != 00);
\r
1719 l_current_poc = &(tcp->pocs[pino]);
\r
1720 assert(l_current_poc != 0);
\r
1722 // get the progression order as a character string
\r
1723 prog = j2k_convert_progression_order(tcp->prg);
\r
1724 assert(strlen(prog) > 0);
\r
1727 (cp->m_specific_param.m_enc.m_tp_on == 1)
\r
1737 tpnum *= l_current_poc->compE;
\r
1739 // resolution wise
\r
1741 tpnum *= l_current_poc->resE;
\r
1745 tpnum *= l_current_poc->prcE;
\r
1749 tpnum *= l_current_poc->layE;
\r
1752 // whould we split here ?
\r
1754 ( cp->m_specific_param.m_enc.m_tp_flag == prog[i] )
\r
1756 cp->m_specific_param.m_enc.m_tp_pos=i;
\r
1769 * Calculates the total number of tile parts needed by the encoder to
\r
1770 * encode such an image. If not enough memory is available, then the function return false.
\r
1772 * @param p_nb_tiles pointer that will hold the number of tile parts.
\r
1773 * @param cp the coding parameters for the image.
\r
1774 * @param image the image to encode.
\r
1775 * @param p_j2k the p_j2k encoder.
\r
1776 * @param p_manager the user event manager.
\r
1778 * @return true if the function was successful, false else.
\r
1780 bool j2k_calculate_tp(
\r
1781 opj_j2k_t *p_j2k,
\r
1783 OPJ_UINT32 * p_nb_tiles,
\r
1784 opj_image_t *image,
\r
1785 opj_event_mgr_t * p_manager)
\r
1787 OPJ_UINT32 pino,tileno;
\r
1788 OPJ_UINT32 l_nb_tiles;
\r
1792 assert(p_nb_tiles != 00);
\r
1794 assert(image != 00);
\r
1795 assert(p_j2k != 00);
\r
1796 assert(p_manager != 00);
\r
1798 l_nb_tiles = cp->tw * cp->th;
\r
1804 (p_j2k->cstr_info)
\r
1806 opj_tile_info_t * l_info_tile_ptr = p_j2k->cstr_info->tile;
\r
1808 (tileno = 0; tileno < l_nb_tiles; ++tileno)
\r
1810 OPJ_UINT32 cur_totnum_tp = 0;
\r
1811 pi_update_encoding_parameters(image,cp,tileno);
\r
1813 (pino = 0; pino <= tcp->numpocs; ++pino)
\r
1815 OPJ_UINT32 tp_num = j2k_get_num_tp(cp,pino,tileno);
\r
1816 *p_nb_tiles = *p_nb_tiles + tp_num;
\r
1817 cur_totnum_tp += tp_num;
\r
1819 tcp->m_nb_tile_parts = cur_totnum_tp;
\r
1820 l_info_tile_ptr->tp = (opj_tp_info_t *) opj_malloc(cur_totnum_tp * sizeof(opj_tp_info_t));
\r
1822 (l_info_tile_ptr->tp == 00)
\r
1826 memset(l_info_tile_ptr->tp,0,cur_totnum_tp * sizeof(opj_tp_info_t));
\r
1827 l_info_tile_ptr->num_tps = cur_totnum_tp;
\r
1828 ++l_info_tile_ptr;
\r
1835 (tileno = 0; tileno < l_nb_tiles; ++tileno)
\r
1837 OPJ_UINT32 cur_totnum_tp = 0;
\r
1838 pi_update_encoding_parameters(image,cp,tileno);
\r
1840 (pino = 0; pino <= tcp->numpocs; ++pino)
\r
1842 OPJ_UINT32 tp_num=0;
\r
1843 tp_num = j2k_get_num_tp(cp,pino,tileno);
\r
1844 *p_nb_tiles = *p_nb_tiles + tp_num;
\r
1845 cur_totnum_tp += tp_num;
\r
1847 tcp->m_nb_tile_parts = cur_totnum_tp;
\r
1855 * Writes the SOC marker (Start Of Codestream)
\r
1857 * @param p_stream the stream to write data to.
\r
1858 * @param p_j2k J2K codec.
\r
1859 * @param p_manager the user event manager.
\r
1862 bool j2k_write_soc(
\r
1864 struct opj_stream_private *p_stream,
\r
1865 struct opj_event_mgr * p_manager
\r
1868 /* 2 bytes will be written */
\r
1869 OPJ_BYTE * l_start_stream = 00;
\r
1872 assert(p_stream != 00);
\r
1873 assert(p_j2k != 00);
\r
1874 assert(p_manager != 00);
\r
1876 l_start_stream = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
1878 /* write SOC identifier */
\r
1879 opj_write_bytes(l_start_stream,J2K_MS_SOC,2);
\r
1881 (opj_stream_write_data(p_stream,l_start_stream,2,p_manager) != 2)
\r
1887 /* update markers struct */
\r
1888 j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOC, p_stream_tell(p_stream) - 2, 2);
\r
1889 #endif /* USE_JPWL */
\r
1895 * Reads a SOC marker (Start of Codestream)
\r
1896 * @param p_header_data the data contained in the SOC box.
\r
1897 * @param jp2 the jpeg2000 file codec.
\r
1898 * @param p_header_size the size of the data contained in the SOC marker.
\r
1899 * @param p_manager the user event manager.
\r
1901 bool j2k_read_soc(
\r
1902 opj_j2k_t *p_j2k,
\r
1903 struct opj_stream_private *p_stream,
\r
1904 struct opj_event_mgr * p_manager
\r
1908 OPJ_BYTE l_data [2];
\r
1909 OPJ_UINT32 l_marker;
\r
1912 assert(p_j2k != 00);
\r
1913 assert(p_manager != 00);
\r
1914 assert(p_stream != 00);
\r
1916 (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2)
\r
1920 opj_read_bytes(l_data,&l_marker,2);
\r
1922 (l_marker != J2K_MS_SOC)
\r
1926 /* assure length of data is correct (0) */
\r
1927 p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_MHSIZ;
\r
1930 (p_j2k->cstr_info)
\r
1932 //TODO p_j2k->cstr_info->main_head_start = opj_stream_tell(p_stream) - 2; // why - 2 ?
\r
1933 p_j2k->cstr_info->codestream_size = 0;/*p_stream_numbytesleft(p_j2k->p_stream) + 2 - p_j2k->cstr_info->main_head_start*/;
\r
1939 * Writes the SIZ marker (image and tile size)
\r
1941 * @param p_stream the stream to write data to.
\r
1942 * @param p_j2k J2K codec.
\r
1943 * @param p_manager the user event manager.
\r
1945 bool j2k_write_siz(
\r
1947 struct opj_stream_private *p_stream,
\r
1948 struct opj_event_mgr * p_manager
\r
1952 OPJ_UINT32 l_size_len;
\r
1953 OPJ_BYTE * l_current_ptr;
\r
1954 opj_image_t * l_image = 00;
\r
1955 opj_cp_t *cp = 00;
\r
1956 opj_image_comp_t * l_img_comp = 00;
\r
1959 assert(p_stream != 00);
\r
1960 assert(p_j2k != 00);
\r
1961 assert(p_manager != 00);
\r
1963 l_image = p_j2k->m_image;
\r
1964 cp = &(p_j2k->m_cp);
\r
1965 l_size_len = 40 + 3 * l_image->numcomps;
\r
1966 l_img_comp = l_image->comps;
\r
1969 (l_size_len > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
1971 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
1973 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
1976 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
1980 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_size_len;
\r
1983 l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
1985 /* write SOC identifier */
\r
1986 opj_write_bytes(l_current_ptr,J2K_MS_SIZ,2); /* SIZ */
\r
1988 opj_write_bytes(l_current_ptr,l_size_len-2,2); /* L_SIZ */
\r
1990 opj_write_bytes(l_current_ptr, cp->rsiz, 2); /* Rsiz (capabilities) */
\r
1992 opj_write_bytes(l_current_ptr, l_image->x1, 4); /* Xsiz */
\r
1994 opj_write_bytes(l_current_ptr, l_image->y1, 4); /* Ysiz */
\r
1996 opj_write_bytes(l_current_ptr, l_image->x0, 4); /* X0siz */
\r
1998 opj_write_bytes(l_current_ptr, l_image->y0, 4); /* Y0siz */
\r
2000 opj_write_bytes(l_current_ptr, cp->tdx, 4); /* XTsiz */
\r
2002 opj_write_bytes(l_current_ptr, cp->tdy, 4); /* YTsiz */
\r
2004 opj_write_bytes(l_current_ptr, cp->tx0, 4); /* XT0siz */
\r
2006 opj_write_bytes(l_current_ptr, cp->ty0, 4); /* YT0siz */
\r
2008 opj_write_bytes(l_current_ptr, l_image->numcomps, 2); /* Csiz */
\r
2011 (i = 0; i < l_image->numcomps; ++i)
\r
2013 // TODO here with MCT ?
\r
2014 opj_write_bytes(l_current_ptr, l_img_comp->prec - 1 + (l_img_comp->sgnd << 7), 1); /* Ssiz_i */
\r
2016 opj_write_bytes(l_current_ptr, l_img_comp->dx, 1); /* XRsiz_i */
\r
2018 opj_write_bytes(l_current_ptr, l_img_comp->dy, 1); /* YRsiz_i */
\r
2023 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_size_len,p_manager) != l_size_len)
\r
2031 * Reads a SIZ marker (image and tile size)
\r
2032 * @param p_header_data the data contained in the SIZ box.
\r
2033 * @param jp2 the jpeg2000 file codec.
\r
2034 * @param p_header_size the size of the data contained in the SIZ marker.
\r
2035 * @param p_manager the user event manager.
\r
2037 bool j2k_read_siz (
\r
2038 opj_j2k_t *p_j2k,
\r
2039 OPJ_BYTE * p_header_data,
\r
2040 OPJ_UINT32 p_header_size,
\r
2041 struct opj_event_mgr * p_manager
\r
2044 OPJ_UINT32 l_size, i;
\r
2045 OPJ_UINT32 l_nb_comp;
\r
2046 OPJ_UINT32 l_nb_comp_remain;
\r
2047 OPJ_UINT32 l_remaining_size;
\r
2048 OPJ_UINT32 l_nb_tiles;
\r
2050 opj_image_t *l_image = 00;
\r
2051 opj_cp_t *l_cp = 00;
\r
2052 opj_image_comp_t * l_img_comp = 00;
\r
2053 opj_tcp_t * l_current_tile_param = 00;
\r
2056 assert(p_j2k != 00);
\r
2057 assert(p_manager != 00);
\r
2058 assert(p_header_data != 00);
\r
2060 l_image = p_j2k->m_image;
\r
2061 l_cp = &(p_j2k->m_cp);
\r
2063 (p_header_size < 36)
\r
2065 opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
\r
2068 l_remaining_size = p_header_size - 36;
\r
2070 l_nb_comp = l_remaining_size / 3;
\r
2071 l_nb_comp_remain = l_remaining_size % 3;
\r
2073 (l_nb_comp_remain != 0)
\r
2075 opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
\r
2078 l_size = p_header_size + 2; /* Lsiz */
\r
2080 opj_read_bytes(p_header_data,&l_tmp ,2); /* Rsiz (capabilities) */
\r
2082 l_cp->rsiz = (OPJ_RSIZ_CAPABILITIES) l_tmp;
\r
2083 opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&l_image->x1) ,4); /* Xsiz */
\r
2085 opj_read_bytes(p_header_data,(OPJ_UINT32*) (&l_image->y1),4); /* Ysiz */
\r
2087 opj_read_bytes(p_header_data,(OPJ_UINT32*) &l_image->x0,4); /* X0siz */
\r
2089 opj_read_bytes(p_header_data,(OPJ_UINT32*) &l_image->y0,4); /* Y0siz */
\r
2091 opj_read_bytes(p_header_data, (&l_cp->tdx),4); /* XTsiz */
\r
2093 opj_read_bytes(p_header_data,&l_cp->tdy,4); /* YTsiz */
\r
2095 opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&l_cp->tx0),4); /* XT0siz */
\r
2097 opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&l_cp->ty0),4); /* YT0siz */
\r
2099 opj_read_bytes(p_header_data,(&l_image->numcomps),2); /* Csiz */
\r
2102 (l_image->numcomps != l_nb_comp)
\r
2104 opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
\r
2109 if (p_j2k->m_cp->correct) {
\r
2110 /* if JPWL is on, we check whether TX errors have damaged
\r
2111 too much the SIZ parameters */
\r
2112 if (!(image->x1 * image->y1)) {
\r
2113 opj_event_msg(p_j2k->cinfo, EVT_ERROR,
\r
2114 "JPWL: bad image size (%d x %d)\n",
\r
2115 image->x1, image->y1);
\r
2116 if (!JPWL_ASSUME || JPWL_ASSUME) {
\r
2117 opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
\r
2121 if (image->numcomps != ((len - 38) / 3)) {
\r
2122 opj_event_msg(p_j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
\r
2123 "JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n",
\r
2124 image->numcomps, ((len - 38) / 3));
\r
2125 if (!JPWL_ASSUME) {
\r
2126 opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
\r
2129 /* we try to correct */
\r
2130 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
\r
2131 if (image->numcomps < ((len - 38) / 3)) {
\r
2132 len = 38 + 3 * image->numcomps;
\r
2133 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n",
\r
2136 image->numcomps = ((len - 38) / 3);
\r
2137 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n",
\r
2138 image->numcomps);
\r
2142 /* update components number in the jpwl_exp_comps filed */
\r
2143 cp->exp_comps = image->numcomps;
\r
2145 #endif /* USE_JPWL */
\r
2147 l_image->comps = (opj_image_comp_t*) opj_calloc(l_image->numcomps, sizeof(opj_image_comp_t));
\r
2149 (l_image->comps == 00)
\r
2151 l_image->numcomps = 0;
\r
2152 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
\r
2155 memset(l_image->comps,0,l_image->numcomps * sizeof(opj_image_comp_t));
\r
2156 l_img_comp = l_image->comps;
\r
2158 (i = 0; i < l_image->numcomps; ++i)
\r
2161 opj_read_bytes(p_header_data,&tmp,1); /* Ssiz_i */
\r
2163 l_img_comp->prec = (tmp & 0x7f) + 1;
\r
2164 l_img_comp->sgnd = tmp >> 7;
\r
2165 opj_read_bytes(p_header_data,&l_img_comp->dx,1); /* XRsiz_i */
\r
2167 opj_read_bytes(p_header_data,&l_img_comp->dy,1); /* YRsiz_i */
\r
2170 if (p_j2k->m_cp->correct) {
\r
2171 /* if JPWL is on, we check whether TX errors have damaged
\r
2172 too much the SIZ parameters, again */
\r
2173 if (!(image->comps[i].dx * image->comps[i].dy)) {
\r
2174 opj_event_msg(p_j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
\r
2175 "JPWL: bad XRsiz_%d/YRsiz_%d (%d x %d)\n",
\r
2176 i, i, image->comps[i].dx, image->comps[i].dy);
\r
2177 if (!JPWL_ASSUME) {
\r
2178 opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
\r
2181 /* we try to correct */
\r
2182 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
\r
2183 if (!image->comps[i].dx) {
\r
2184 image->comps[i].dx = 1;
\r
2185 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting XRsiz_%d to %d => HYPOTHESIS!!!\n",
\r
2186 i, image->comps[i].dx);
\r
2188 if (!image->comps[i].dy) {
\r
2189 image->comps[i].dy = 1;
\r
2190 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n",
\r
2191 i, image->comps[i].dy);
\r
2196 #endif /* USE_JPWL */
\r
2197 l_img_comp->resno_decoded = 0; /* number of resolution decoded */
\r
2198 l_img_comp->factor = l_cp->m_specific_param.m_dec.m_reduce; /* reducing factor per component */
\r
2202 l_cp->tw = int_ceildiv(l_image->x1 - l_cp->tx0, l_cp->tdx);
\r
2203 l_cp->th = int_ceildiv(l_image->y1 - l_cp->ty0, l_cp->tdy);
\r
2204 l_nb_tiles = l_cp->tw * l_cp->th;
\r
2206 (p_j2k->m_specific_param.m_decoder.m_discard_tiles)
\r
2208 p_j2k->m_specific_param.m_decoder.m_start_tile_x = (p_j2k->m_specific_param.m_decoder.m_start_tile_x - l_cp->tx0) / l_cp->tdx;
\r
2209 p_j2k->m_specific_param.m_decoder.m_start_tile_y = (p_j2k->m_specific_param.m_decoder.m_start_tile_y - l_cp->ty0) / l_cp->tdy;
\r
2210 p_j2k->m_specific_param.m_decoder.m_end_tile_x = int_ceildiv((p_j2k->m_specific_param.m_decoder.m_end_tile_x - l_cp->tx0), l_cp->tdx);
\r
2211 p_j2k->m_specific_param.m_decoder.m_end_tile_y = int_ceildiv((p_j2k->m_specific_param.m_decoder.m_end_tile_y - l_cp->ty0), l_cp->tdy);
\r
2215 p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
\r
2216 p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
\r
2217 p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
\r
2218 p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
\r
2222 if (p_j2k->m_cp->correct) {
\r
2223 /* if JPWL is on, we check whether TX errors have damaged
\r
2224 too much the SIZ parameters */
\r
2225 if ((cp->tw < 1) || (cp->th < 1) || (cp->tw > cp->max_tiles) || (cp->th > cp->max_tiles)) {
\r
2226 opj_event_msg(p_j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
\r
2227 "JPWL: bad number of tiles (%d x %d)\n",
\r
2229 if (!JPWL_ASSUME) {
\r
2230 opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
\r
2233 /* we try to correct */
\r
2234 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
\r
2237 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting %d tiles in x => HYPOTHESIS!!!\n",
\r
2240 if (cp->tw > cp->max_tiles) {
\r
2242 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- too large x, increase expectance of %d\n"
\r
2243 "- setting %d tiles in x => HYPOTHESIS!!!\n",
\r
2244 cp->max_tiles, cp->tw);
\r
2248 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting %d tiles in y => HYPOTHESIS!!!\n",
\r
2251 if (cp->th > cp->max_tiles) {
\r
2253 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- too large y, increase expectance of %d to continue\n",
\r
2254 "- setting %d tiles in y => HYPOTHESIS!!!\n",
\r
2255 cp->max_tiles, cp->th);
\r
2259 #endif /* USE_JPWL */
\r
2260 /* memory allocations */
\r
2261 l_cp->tcps = (opj_tcp_t*) opj_calloc(l_nb_tiles, sizeof(opj_tcp_t));
\r
2263 (l_cp->tcps == 00)
\r
2265 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
\r
2268 memset(l_cp->tcps,0,l_nb_tiles*sizeof(opj_tcp_t));
\r
2271 if (p_j2k->m_cp->correct) {
\r
2273 opj_event_msg(p_j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
\r
2274 "JPWL: could not alloc tcps field of cp\n");
\r
2275 if (!JPWL_ASSUME || JPWL_ASSUME) {
\r
2276 opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
\r
2281 #endif /* USE_JPWL */
\r
2283 p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps = (opj_tccp_t*) opj_calloc(l_image->numcomps, sizeof(opj_tccp_t));
\r
2285 (p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps == 00)
\r
2287 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
\r
2290 memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps ,0,l_image->numcomps*sizeof(opj_tccp_t));
\r
2292 p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records = opj_malloc(J2K_MCT_DEFAULT_NB_RECORDS * sizeof(opj_mct_data_t));
\r
2294 (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records)
\r
2296 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
\r
2299 memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records,0,J2K_MCT_DEFAULT_NB_RECORDS * sizeof(opj_mct_data_t));
\r
2300 p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mct_records = J2K_MCT_DEFAULT_NB_RECORDS;
\r
2302 p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records = opj_malloc(J2K_MCC_DEFAULT_NB_RECORDS * sizeof(opj_simple_mcc_decorrelation_data_t));
\r
2304 (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records)
\r
2306 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
\r
2309 memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records,0,J2K_MCC_DEFAULT_NB_RECORDS * sizeof(opj_simple_mcc_decorrelation_data_t));
\r
2310 p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mcc_records = J2K_MCC_DEFAULT_NB_RECORDS;
\r
2312 /* set up default dc level shift */
\r
2314 (i=0;i<l_image->numcomps;++i)
\r
2317 (! l_image->comps[i].sgnd)
\r
2319 p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[i].m_dc_level_shift = 1 << (l_image->comps[i].prec - 1);
\r
2323 l_current_tile_param = l_cp->tcps;
\r
2325 (i = 0; i < l_nb_tiles; ++i)
\r
2327 l_current_tile_param->tccps = (opj_tccp_t*) opj_malloc(l_image->numcomps * sizeof(opj_tccp_t));
\r
2329 (l_current_tile_param->tccps == 00)
\r
2331 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
\r
2334 memset(l_current_tile_param->tccps,0,l_image->numcomps * sizeof(opj_tccp_t));
\r
2336 ++l_current_tile_param;
\r
2339 p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_MH;
\r
2340 opj_image_comp_update(l_image,l_cp);
\r
2344 (p_j2k->cstr_info)
\r
2346 opj_codestream_info_t *cstr_info = p_j2k->cstr_info;
\r
2347 cstr_info->image_w = l_image->x1 - l_image->x0;
\r
2348 cstr_info->image_h = l_image->y1 - l_image->y0;
\r
2349 cstr_info->numcomps = l_image->numcomps;
\r
2350 cstr_info->tw = l_cp->tw;
\r
2351 cstr_info->th = l_cp->th;
\r
2352 cstr_info->tile_x = l_cp->tdx;
\r
2353 cstr_info->tile_y = l_cp->tdy;
\r
2354 cstr_info->tile_Ox = l_cp->tx0;
\r
2355 cstr_info->tile_Oy = l_cp->ty0;
\r
2356 cstr_info->tile = (opj_tile_info_t*) opj_calloc(l_nb_tiles, sizeof(opj_tile_info_t));
\r
2358 (cstr_info->tile == 00)
\r
2360 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
\r
2363 memset(cstr_info->tile,0,l_nb_tiles * sizeof(opj_tile_info_t));
\r
2369 * Writes the COM marker (comment)
\r
2371 * @param p_stream the stream to write data to.
\r
2372 * @param p_j2k J2K codec.
\r
2373 * @param p_manager the user event manager.
\r
2375 bool j2k_write_com(
\r
2377 struct opj_stream_private *p_stream,
\r
2378 struct opj_event_mgr * p_manager
\r
2381 OPJ_UINT32 l_comment_size;
\r
2382 OPJ_UINT32 l_total_com_size;
\r
2383 const OPJ_CHAR *l_comment;
\r
2384 OPJ_BYTE * l_current_ptr = 00;
\r
2387 assert(p_j2k != 00);
\r
2388 assert(p_stream != 00);
\r
2389 assert(p_manager != 00);
\r
2391 l_comment = p_j2k->m_cp.comment;
\r
2392 l_comment_size = strlen(l_comment);
\r
2393 l_total_com_size = l_comment_size + 6;
\r
2396 (l_total_com_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
2398 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
2400 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
2401 l_total_com_size);
\r
2403 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
2407 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_total_com_size;
\r
2409 l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
2410 opj_write_bytes(l_current_ptr,J2K_MS_COM , 2); /* COM */
\r
2412 opj_write_bytes(l_current_ptr,l_total_com_size - 2 , 2); /* L_COM */
\r
2414 opj_write_bytes(l_current_ptr,1 , 2); /* General use (IS 8859-15:1999 (Latin) values) */
\r
2416 memcpy( l_current_ptr,l_comment,l_comment_size);
\r
2418 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_total_com_size,p_manager) != l_total_com_size)
\r
2426 * Reads a COM marker (comments)
\r
2427 * @param p_header_data the data contained in the COM box.
\r
2428 * @param jp2 the jpeg2000 file codec.
\r
2429 * @param p_header_size the size of the data contained in the COM marker.
\r
2430 * @param p_manager the user event manager.
\r
2432 bool j2k_read_com (
\r
2433 opj_j2k_t *p_j2k,
\r
2434 OPJ_BYTE * p_header_data,
\r
2435 OPJ_UINT32 p_header_size,
\r
2436 struct opj_event_mgr * p_manager
\r
2440 assert(p_j2k != 00);
\r
2441 assert(p_manager != 00);
\r
2442 assert(p_header_data != 00);
\r
2447 * Gets the size taken by writting a SPCod or SPCoc for the given tile and component.
\r
2449 * @param p_tile_no the tile indix.
\r
2450 * @param p_comp_no the component being outputted.
\r
2451 * @param p_j2k the J2K codec.
\r
2453 * @return the number of bytes taken by the SPCod element.
\r
2455 OPJ_UINT32 j2k_get_SPCod_SPCoc_size (
\r
2457 OPJ_UINT32 p_tile_no,
\r
2458 OPJ_UINT32 p_comp_no
\r
2461 opj_cp_t *l_cp = 00;
\r
2462 opj_tcp_t *l_tcp = 00;
\r
2463 opj_tccp_t *l_tccp = 00;
\r
2466 assert(p_j2k != 00);
\r
2468 l_cp = &(p_j2k->m_cp);
\r
2469 l_tcp = &l_cp->tcps[p_tile_no];
\r
2470 l_tccp = &l_tcp->tccps[p_comp_no];
\r
2472 // preconditions again
\r
2473 assert(p_tile_no < (l_cp->tw * l_cp->th));
\r
2474 assert(p_comp_no < p_j2k->m_image->numcomps);
\r
2477 (l_tccp->csty & J2K_CCP_CSTY_PRT)
\r
2479 return 5 + l_tccp->numresolutions;
\r
2489 * Writes a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
\r
2491 * @param p_comp_no the component number to output.
\r
2492 * @param p_stream the stream to write data to.
\r
2493 * @param p_j2k J2K codec.
\r
2494 * @param p_manager the user event manager.
\r
2497 bool j2k_write_SPCod_SPCoc(
\r
2499 OPJ_UINT32 p_tile_no,
\r
2500 OPJ_UINT32 p_comp_no,
\r
2501 OPJ_BYTE * p_data,
\r
2502 OPJ_UINT32 * p_header_size,
\r
2503 struct opj_event_mgr * p_manager
\r
2507 opj_cp_t *l_cp = 00;
\r
2508 opj_tcp_t *l_tcp = 00;
\r
2509 opj_tccp_t *l_tccp = 00;
\r
2512 assert(p_j2k != 00);
\r
2513 assert(p_header_size != 00);
\r
2514 assert(p_manager != 00);
\r
2515 assert(p_data != 00);
\r
2517 l_cp = &(p_j2k->m_cp);
\r
2518 l_tcp = &l_cp->tcps[p_tile_no];
\r
2519 l_tccp = &l_tcp->tccps[p_comp_no];
\r
2521 // preconditions again
\r
2522 assert(p_tile_no < (l_cp->tw * l_cp->th));
\r
2523 assert(p_comp_no <(p_j2k->m_image->numcomps));
\r
2526 (*p_header_size < 5)
\r
2528 opj_event_msg(p_manager, EVT_ERROR, "Error writting SPCod SPCoc element\n");
\r
2532 opj_write_bytes(p_data,l_tccp->numresolutions - 1, 1); /* SPcoc (D) */
\r
2534 opj_write_bytes(p_data,l_tccp->cblkw - 2, 1); /* SPcoc (E) */
\r
2536 opj_write_bytes(p_data,l_tccp->cblkh - 2, 1); /* SPcoc (F) */
\r
2538 opj_write_bytes(p_data,l_tccp->cblksty, 1); /* SPcoc (G) */
\r
2540 opj_write_bytes(p_data,l_tccp->qmfbid, 1); /* SPcoc (H) */
\r
2543 *p_header_size = *p_header_size - 5;
\r
2545 (l_tccp->csty & J2K_CCP_CSTY_PRT)
\r
2548 (*p_header_size < l_tccp->numresolutions)
\r
2550 opj_event_msg(p_manager, EVT_ERROR, "Error writting SPCod SPCoc element\n");
\r
2554 (i = 0; i < l_tccp->numresolutions; ++i)
\r
2556 opj_write_bytes(p_data,l_tccp->prcw[i] + (l_tccp->prch[i] << 4), 1); /* SPcoc (I_i) */
\r
2559 *p_header_size = *p_header_size - l_tccp->numresolutions;
\r
2567 * Reads a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
\r
2568 * @param p_header_data the data contained in the COM box.
\r
2569 * @param p_j2k the jpeg2000 codec.
\r
2570 * @param p_header_size the size of the data contained in the COM marker.
\r
2571 * @param p_manager the user event manager.
\r
2573 bool j2k_read_SPCod_SPCoc(
\r
2574 opj_j2k_t *p_j2k,
\r
2575 OPJ_UINT32 compno,
\r
2576 OPJ_BYTE * p_header_data,
\r
2577 OPJ_UINT32 * p_header_size,
\r
2578 struct opj_event_mgr * p_manager
\r
2584 opj_cp_t *l_cp = 00;
\r
2585 opj_tcp_t *l_tcp = 00;
\r
2586 opj_tccp_t *l_tccp = 00;
\r
2587 OPJ_BYTE * l_current_ptr = 00;
\r
2591 assert(p_j2k != 00);
\r
2592 assert(p_manager != 00);
\r
2593 assert(p_header_data != 00);
\r
2596 l_cp = &(p_j2k->m_cp);
\r
2597 l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
2599 // precondition again
\r
2600 assert(compno < p_j2k->m_image->numcomps);
\r
2601 l_tccp = &l_tcp->tccps[compno];
\r
2602 l_current_ptr = p_header_data;
\r
2605 // make sure room is sufficient
\r
2607 (* p_header_size < 5)
\r
2609 opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n");
\r
2612 opj_read_bytes(l_current_ptr, &l_tccp->numresolutions ,1); /* SPcox (D) */
\r
2613 ++l_tccp->numresolutions; /* tccp->numresolutions = read() + 1 */
\r
2616 // If user wants to remove more resolutions than the codestream contains, return error
\r
2618 (l_cp->m_specific_param.m_dec.m_reduce >= l_tccp->numresolutions)
\r
2620 opj_event_msg(p_manager, EVT_ERROR, "Error decoding component %d.\nThe number of resolutions to remove is higher than the number "
\r
2621 "of resolutions of this component\nModify the cp_reduce parameter.\n\n", compno);
\r
2622 p_j2k->m_specific_param.m_decoder.m_state |= J2K_DEC_STATE_ERR;
\r
2626 opj_read_bytes(l_current_ptr,&l_tccp->cblkw ,1); /* SPcoc (E) */
\r
2628 l_tccp->cblkw += 2;
\r
2630 opj_read_bytes(l_current_ptr,&l_tccp->cblkh ,1); /* SPcoc (F) */
\r
2632 l_tccp->cblkh += 2;
\r
2634 opj_read_bytes(l_current_ptr,&l_tccp->cblksty ,1); /* SPcoc (G) */
\r
2637 opj_read_bytes(l_current_ptr,&l_tccp->qmfbid ,1); /* SPcoc (H) */
\r
2640 * p_header_size = * p_header_size - 5;
\r
2642 // use custom precinct size ?
\r
2644 (l_tccp->csty & J2K_CCP_CSTY_PRT)
\r
2647 (* p_header_size < l_tccp->numresolutions)
\r
2649 opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n");
\r
2653 (i = 0; i < l_tccp->numresolutions; ++i)
\r
2655 opj_read_bytes(l_current_ptr,&l_tmp ,1); /* SPcoc (I_i) */
\r
2657 l_tccp->prcw[i] = l_tmp & 0xf;
\r
2658 l_tccp->prch[i] = l_tmp >> 4;
\r
2660 * p_header_size = * p_header_size - l_tccp->numresolutions;
\r
2664 /* set default size for the precinct width and height */
\r
2666 (i = 0; i < l_tccp->numresolutions; ++i)
\r
2668 l_tccp->prcw[i] = 15;
\r
2669 l_tccp->prch[i] = 15;
\r
2675 (p_j2k->cstr_info && compno == 0)
\r
2677 OPJ_UINT32 l_data_size = l_tccp->numresolutions * sizeof(OPJ_UINT32);
\r
2678 memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdx,l_tccp->prcw, l_data_size);
\r
2679 memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdy,l_tccp->prch, l_data_size);
\r
2686 * Copies the tile component parameters of all the component from the first tile component.
\r
2688 * @param p_j2k the J2k codec.
\r
2690 void j2k_copy_tile_component_parameters(
\r
2697 opj_cp_t *l_cp = 00;
\r
2698 opj_tcp_t *l_tcp = 00;
\r
2699 opj_tccp_t *l_ref_tccp = 00;
\r
2700 opj_tccp_t *l_copied_tccp = 00;
\r
2701 OPJ_UINT32 l_prc_size;
\r
2703 assert(p_j2k != 00);
\r
2705 l_cp = &(p_j2k->m_cp);
\r
2706 l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
2708 l_ref_tccp = &l_tcp->tccps[0];
\r
2709 l_copied_tccp = l_ref_tccp + 1;
\r
2710 l_prc_size = l_ref_tccp->numresolutions * sizeof(OPJ_UINT32);
\r
2713 (i=1;i<p_j2k->m_image->numcomps;++i)
\r
2715 l_copied_tccp->numresolutions = l_ref_tccp->numresolutions;
\r
2716 l_copied_tccp->cblkw = l_ref_tccp->cblkw;
\r
2717 l_copied_tccp->cblkh = l_ref_tccp->cblkh;
\r
2718 l_copied_tccp->cblksty = l_ref_tccp->cblksty;
\r
2719 l_copied_tccp->qmfbid = l_ref_tccp->qmfbid;
\r
2720 memcpy(l_copied_tccp->prcw,l_ref_tccp->prcw,l_prc_size);
\r
2721 memcpy(l_copied_tccp->prch,l_ref_tccp->prch,l_prc_size);
\r
2729 * Writes the COD marker (Coding style default)
\r
2731 * @param p_stream the stream to write data to.
\r
2732 * @param p_j2k J2K codec.
\r
2733 * @param p_manager the user event manager.
\r
2735 bool j2k_write_cod(
\r
2737 struct opj_stream_private *p_stream,
\r
2738 struct opj_event_mgr * p_manager
\r
2741 opj_cp_t *l_cp = 00;
\r
2742 opj_tcp_t *l_tcp = 00;
\r
2743 OPJ_UINT32 l_code_size,l_remaining_size;
\r
2744 OPJ_BYTE * l_current_data = 00;
\r
2747 assert(p_j2k != 00);
\r
2748 assert(p_manager != 00);
\r
2749 assert(p_stream != 00);
\r
2751 l_cp = &(p_j2k->m_cp);
\r
2752 l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
\r
2753 l_code_size = 9 + j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,0);
\r
2754 l_remaining_size = l_code_size;
\r
2757 (l_code_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
2759 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
2761 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
2764 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
2768 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_code_size;
\r
2771 l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
2773 opj_write_bytes(l_current_data,J2K_MS_COD,2); /* COD */
\r
2774 l_current_data += 2;
\r
2776 opj_write_bytes(l_current_data,l_code_size-2,2); /* L_COD */
\r
2777 l_current_data += 2;
\r
2779 opj_write_bytes(l_current_data,l_tcp->csty,1); /* Scod */
\r
2782 opj_write_bytes(l_current_data,l_tcp->prg,1); /* SGcod (A) */
\r
2785 opj_write_bytes(l_current_data,l_tcp->numlayers,2); /* SGcod (B) */
\r
2786 l_current_data+=2;
\r
2788 opj_write_bytes(l_current_data,l_tcp->mct,1); /* SGcod (C) */
\r
2791 l_remaining_size -= 9;
\r
2794 (! j2k_write_SPCod_SPCoc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager))
\r
2796 opj_event_msg(p_manager, EVT_ERROR, "Error writting COD marker\n");
\r
2800 (l_remaining_size != 0)
\r
2802 opj_event_msg(p_manager, EVT_ERROR, "Error writting COD marker\n");
\r
2807 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_code_size,p_manager) != l_code_size)
\r
2815 * Reads a COD marker (Coding Styke defaults)
\r
2816 * @param p_header_data the data contained in the COD box.
\r
2817 * @param p_j2k the jpeg2000 codec.
\r
2818 * @param p_header_size the size of the data contained in the COD marker.
\r
2819 * @param p_manager the user event manager.
\r
2821 bool j2k_read_cod (
\r
2822 opj_j2k_t *p_j2k,
\r
2823 OPJ_BYTE * p_header_data,
\r
2824 OPJ_UINT32 p_header_size,
\r
2825 struct opj_event_mgr * p_manager
\r
2831 opj_cp_t *l_cp = 00;
\r
2832 opj_tcp_t *l_tcp = 00;
\r
2833 opj_image_t *l_image = 00;
\r
2836 assert(p_header_data != 00);
\r
2837 assert(p_j2k != 00);
\r
2838 assert(p_manager != 00);
\r
2840 l_cp = &(p_j2k->m_cp);
\r
2841 l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH) ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
2842 l_image = p_j2k->m_image;
\r
2844 // make sure room is sufficient
\r
2846 (p_header_size < 5)
\r
2848 opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
\r
2852 opj_read_bytes(p_header_data,&l_tcp->csty,1); /* Scod */
\r
2854 opj_read_bytes(p_header_data,&l_tmp,1); /* SGcod (A) */
\r
2856 l_tcp->prg = (OPJ_PROG_ORDER) l_tmp;
\r
2857 opj_read_bytes(p_header_data,&l_tcp->numlayers,2); /* SGcod (B) */
\r
2860 (l_cp->m_specific_param.m_dec.m_layer)
\r
2862 l_tcp->num_layers_to_decode = l_cp->m_specific_param.m_dec.m_layer;
\r
2866 l_tcp->num_layers_to_decode = l_tcp->numlayers;
\r
2869 opj_read_bytes(p_header_data,&l_tcp->mct,1); /* SGcod (C) */
\r
2872 p_header_size -= 5;
\r
2874 (i = 0; i < l_image->numcomps; ++i)
\r
2876 l_tcp->tccps[i].csty = l_tcp->csty & J2K_CCP_CSTY_PRT;
\r
2880 (! j2k_read_SPCod_SPCoc(p_j2k,0,p_header_data,&p_header_size,p_manager))
\r
2882 opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
\r
2886 (p_header_size != 0)
\r
2888 opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
\r
2891 j2k_copy_tile_component_parameters(p_j2k);
\r
2896 (p_j2k->cstr_info)
\r
2898 opj_codestream_info_t *l_cstr_info = p_j2k->cstr_info;
\r
2899 l_cstr_info->prog = l_tcp->prg;
\r
2900 l_cstr_info->numlayers = l_tcp->numlayers;
\r
2901 l_cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(l_image->numcomps * sizeof(OPJ_UINT32));
\r
2903 (i = 0; i < l_image->numcomps; ++i)
\r
2905 l_cstr_info->numdecompos[i] = l_tcp->tccps[i].numresolutions - 1;
\r
2912 * Writes the COC marker (Coding style component)
\r
2914 * @param p_comp_no the index of the component to output.
\r
2915 * @param p_stream the stream to write data to.
\r
2916 * @param p_j2k J2K codec.
\r
2917 * @param p_manager the user event manager.
\r
2919 bool j2k_write_coc(
\r
2921 OPJ_UINT32 p_comp_no,
\r
2922 struct opj_stream_private *p_stream,
\r
2923 struct opj_event_mgr * p_manager
\r
2926 OPJ_UINT32 l_coc_size,l_remaining_size;
\r
2927 OPJ_UINT32 l_comp_room;
\r
2930 assert(p_j2k != 00);
\r
2931 assert(p_manager != 00);
\r
2932 assert(p_stream != 00);
\r
2934 l_comp_room = (p_j2k->m_image->numcomps <= 256) ? 1 : 2;
\r
2936 l_coc_size = 5 + l_comp_room + j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
\r
2938 (l_coc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
2940 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
2942 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
2945 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
2949 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_coc_size;
\r
2952 j2k_write_coc_in_memory(p_j2k,p_comp_no,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_remaining_size,p_manager);
\r
2955 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_coc_size,p_manager) != l_coc_size)
\r
2963 * Gets the maximum size taken by a coc.
\r
2965 * @param p_j2k the jpeg2000 codec to use.
\r
2967 OPJ_UINT32 j2k_get_max_coc_size(opj_j2k_t *p_j2k)
\r
2970 OPJ_UINT32 l_nb_comp;
\r
2971 OPJ_UINT32 l_nb_tiles;
\r
2972 OPJ_UINT32 l_max = 0;
\r
2976 l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ;
\r
2977 l_nb_comp = p_j2k->m_image->numcomps;
\r
2980 (i=0;i<l_nb_tiles;++i)
\r
2983 (j=0;j<l_nb_comp;++j)
\r
2985 l_max = uint_max(l_max,j2k_get_SPCod_SPCoc_size(p_j2k,i,j));
\r
2992 * Gets the maximum size taken by the toc headers of all the tile parts of any given tile.
\r
2994 OPJ_UINT32 j2k_get_max_toc_size (opj_j2k_t *p_j2k)
\r
2997 OPJ_UINT32 l_nb_tiles;
\r
2998 OPJ_UINT32 l_max = 0;
\r
2999 opj_tcp_t * l_tcp = 00;
\r
3002 l_tcp = p_j2k->m_cp.tcps;
\r
3003 l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ;
\r
3006 (i=0;i<l_nb_tiles;++i)
\r
3008 l_max = uint_max(l_max,l_tcp->m_nb_tile_parts);
\r
3011 return 12 * l_max;
\r
3016 * Gets the maximum size taken by the headers of the SOT.
\r
3018 * @param p_j2k the jpeg2000 codec to use.
\r
3020 OPJ_UINT32 j2k_get_specific_header_sizes(opj_j2k_t *p_j2k)
\r
3022 OPJ_UINT32 l_nb_bytes = 0;
\r
3023 OPJ_UINT32 l_nb_comps;
\r
3024 OPJ_UINT32 l_coc_bytes,l_qcc_bytes;
\r
3027 l_nb_comps = p_j2k->m_image->numcomps - 1;
\r
3028 l_nb_bytes += j2k_get_max_toc_size(p_j2k);
\r
3030 (p_j2k->m_cp.m_specific_param.m_enc.m_cinema == 0)
\r
3032 l_coc_bytes = j2k_get_max_coc_size(p_j2k);
\r
3033 l_nb_bytes += l_nb_comps * l_coc_bytes;
\r
3034 l_qcc_bytes = j2k_get_max_qcc_size(p_j2k);
\r
3035 l_nb_bytes += l_nb_comps * l_qcc_bytes;
\r
3037 l_nb_bytes += j2k_get_max_poc_size(p_j2k);
\r
3038 /*** DEVELOPER CORNER, Add room for your headers ***/
\r
3041 return l_nb_bytes;
\r
3046 * Writes the COC marker (Coding style component)
\r
3048 * @param p_comp_no the index of the component to output.
\r
3049 * @param p_stream the stream to write data to.
\r
3050 * @param p_j2k J2K codec.
\r
3051 * @param p_manager the user event manager.
\r
3053 void j2k_write_coc_in_memory(
\r
3055 OPJ_UINT32 p_comp_no,
\r
3056 OPJ_BYTE * p_data,
\r
3057 OPJ_UINT32 * p_data_written,
\r
3058 struct opj_event_mgr * p_manager
\r
3061 opj_cp_t *l_cp = 00;
\r
3062 opj_tcp_t *l_tcp = 00;
\r
3063 OPJ_UINT32 l_coc_size,l_remaining_size;
\r
3064 OPJ_BYTE * l_current_data = 00;
\r
3065 opj_image_t *l_image = 00;
\r
3066 OPJ_UINT32 l_comp_room;
\r
3069 assert(p_j2k != 00);
\r
3070 assert(p_manager != 00);
\r
3072 l_cp = &(p_j2k->m_cp);
\r
3073 l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
\r
3074 l_image = p_j2k->m_image;
\r
3075 l_comp_room = (l_image->numcomps <= 256) ? 1 : 2;
\r
3077 l_coc_size = 5 + l_comp_room + j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
\r
3078 l_remaining_size = l_coc_size;
\r
3080 l_current_data = p_data;
\r
3082 opj_write_bytes(l_current_data,J2K_MS_COC,2); /* COC */
\r
3083 l_current_data += 2;
\r
3084 opj_write_bytes(l_current_data,l_coc_size-2,2); /* L_COC */
\r
3085 l_current_data += 2;
\r
3086 opj_write_bytes(l_current_data,p_comp_no, l_comp_room); /* Ccoc */
\r
3087 l_current_data+=l_comp_room;
\r
3088 opj_write_bytes(l_current_data, l_tcp->tccps[p_comp_no].csty, 1); /* Scoc */
\r
3090 l_remaining_size -= (5 + l_comp_room);
\r
3091 j2k_write_SPCod_SPCoc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager);
\r
3092 * p_data_written = l_coc_size;
\r
3097 * Reads a COC marker (Coding Style Component)
\r
3098 * @param p_header_data the data contained in the COC box.
\r
3099 * @param p_j2k the jpeg2000 codec.
\r
3100 * @param p_header_size the size of the data contained in the COC marker.
\r
3101 * @param p_manager the user event manager.
\r
3103 bool j2k_read_coc (
\r
3104 opj_j2k_t *p_j2k,
\r
3105 OPJ_BYTE * p_header_data,
\r
3106 OPJ_UINT32 p_header_size,
\r
3107 struct opj_event_mgr * p_manager
\r
3110 opj_cp_t *l_cp = 00;
\r
3111 opj_tcp_t *l_tcp = 00;
\r
3112 opj_image_t *l_image = 00;
\r
3113 OPJ_UINT32 l_comp_room;
\r
3114 OPJ_UINT32 l_comp_no;
\r
3117 assert(p_header_data != 00);
\r
3118 assert(p_j2k != 00);
\r
3119 assert(p_manager != 00);
\r
3121 l_cp = &(p_j2k->m_cp);
\r
3122 l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH) ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
3123 l_image = p_j2k->m_image;
\r
3125 l_comp_room = l_image->numcomps <= 256 ? 1 : 2;
\r
3126 // make sure room is sufficient
\r
3128 (p_header_size < l_comp_room + 1)
\r
3130 opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
\r
3133 p_header_size -= l_comp_room + 1;
\r
3135 opj_read_bytes(p_header_data,&l_comp_no,l_comp_room); /* Ccoc */
\r
3136 p_header_data += l_comp_room;
\r
3138 (l_comp_no >= l_image->numcomps)
\r
3140 opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker (bad number of components)\n");
\r
3143 opj_read_bytes(p_header_data,&l_tcp->tccps[l_comp_no].csty,1); /* Scoc */
\r
3147 (! j2k_read_SPCod_SPCoc(p_j2k,l_comp_no,p_header_data,&p_header_size,p_manager))
\r
3149 opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
\r
3153 (p_header_size != 0)
\r
3155 opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
\r
3162 * Gets the size taken by writting SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
\r
3164 * @param p_tile_no the tile indix.
\r
3165 * @param p_comp_no the component being outputted.
\r
3166 * @param p_j2k the J2K codec.
\r
3168 * @return the number of bytes taken by the SPCod element.
\r
3170 OPJ_UINT32 j2k_get_SQcd_SQcc_size (
\r
3172 OPJ_UINT32 p_tile_no,
\r
3173 OPJ_UINT32 p_comp_no
\r
3176 OPJ_UINT32 l_num_bands;
\r
3178 opj_cp_t *l_cp = 00;
\r
3179 opj_tcp_t *l_tcp = 00;
\r
3180 opj_tccp_t *l_tccp = 00;
\r
3183 assert(p_j2k != 00);
\r
3185 l_cp = &(p_j2k->m_cp);
\r
3186 l_tcp = &l_cp->tcps[p_tile_no];
\r
3187 l_tccp = &l_tcp->tccps[p_comp_no];
\r
3189 // preconditions again
\r
3190 assert(p_tile_no < l_cp->tw * l_cp->th);
\r
3191 assert(p_comp_no < p_j2k->m_image->numcomps);
\r
3193 l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : (l_tccp->numresolutions * 3 - 2);
\r
3196 (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)
\r
3198 return 1 + l_num_bands;
\r
3202 return 1 + 2*l_num_bands;
\r
3207 * Writes a SQcd or SQcc element, i.e. the quantization values of a band.
\r
3209 * @param p_tile_no the tile to output.
\r
3210 * @param p_comp_no the component number to output.
\r
3211 * @param p_data the data buffer.
\r
3212 * @param p_header_size pointer to the size of the data buffer, it is changed by the function.
\r
3213 * @param p_j2k J2K codec.
\r
3214 * @param p_manager the user event manager.
\r
3217 bool j2k_write_SQcd_SQcc(
\r
3219 OPJ_UINT32 p_tile_no,
\r
3220 OPJ_UINT32 p_comp_no,
\r
3221 OPJ_BYTE * p_data,
\r
3222 OPJ_UINT32 * p_header_size,
\r
3223 struct opj_event_mgr * p_manager
\r
3226 OPJ_UINT32 l_header_size;
\r
3227 OPJ_UINT32 l_band_no, l_num_bands;
\r
3228 OPJ_UINT32 l_expn,l_mant;
\r
3230 opj_cp_t *l_cp = 00;
\r
3231 opj_tcp_t *l_tcp = 00;
\r
3232 opj_tccp_t *l_tccp = 00;
\r
3235 assert(p_j2k != 00);
\r
3236 assert(p_header_size != 00);
\r
3237 assert(p_manager != 00);
\r
3238 assert(p_data != 00);
\r
3240 l_cp = &(p_j2k->m_cp);
\r
3241 l_tcp = &l_cp->tcps[p_tile_no];
\r
3242 l_tccp = &l_tcp->tccps[p_comp_no];
\r
3244 // preconditions again
\r
3245 assert(p_tile_no < l_cp->tw * l_cp->th);
\r
3246 assert(p_comp_no <p_j2k->m_image->numcomps);
\r
3248 l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : (l_tccp->numresolutions * 3 - 2);
\r
3251 (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)
\r
3253 l_header_size = 1 + l_num_bands;
\r
3255 (*p_header_size < l_header_size)
\r
3257 opj_event_msg(p_manager, EVT_ERROR, "Error writting SQcd SQcc element\n");
\r
3260 opj_write_bytes(p_data,l_tccp->qntsty + (l_tccp->numgbits << 5), 1); /* Sqcx */
\r
3263 (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no)
\r
3265 l_expn = l_tccp->stepsizes[l_band_no].expn;
\r
3266 opj_write_bytes(p_data, l_expn << 3, 1); /* SPqcx_i */
\r
3272 l_header_size = 1 + 2*l_num_bands;
\r
3274 (*p_header_size < l_header_size)
\r
3276 opj_event_msg(p_manager, EVT_ERROR, "Error writting SQcd SQcc element\n");
\r
3279 opj_write_bytes(p_data,l_tccp->qntsty + (l_tccp->numgbits << 5), 1); /* Sqcx */
\r
3282 (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no)
\r
3284 l_expn = l_tccp->stepsizes[l_band_no].expn;
\r
3285 l_mant = l_tccp->stepsizes[l_band_no].mant;
\r
3286 opj_write_bytes(p_data, (l_expn << 11) + l_mant, 2); /* SPqcx_i */
\r
3290 *p_header_size = *p_header_size - l_header_size;
\r
3295 * Reads a SQcd or SQcc element, i.e. the quantization values of a band.
\r
3297 * @param p_comp_no the component being targeted.
\r
3298 * @param p_header_data the data contained in the COM box.
\r
3299 * @param p_j2k the jpeg2000 codec.
\r
3300 * @param p_header_size the size of the data contained in the COM marker.
\r
3301 * @param p_manager the user event manager.
\r
3303 bool j2k_read_SQcd_SQcc(
\r
3304 opj_j2k_t *p_j2k,
\r
3305 OPJ_UINT32 p_comp_no,
\r
3306 OPJ_BYTE* p_header_data,
\r
3307 OPJ_UINT32 * p_header_size,
\r
3308 struct opj_event_mgr * p_manager
\r
3312 OPJ_UINT32 l_band_no;
\r
3313 opj_cp_t *l_cp = 00;
\r
3314 opj_tcp_t *l_tcp = 00;
\r
3315 opj_tccp_t *l_tccp = 00;
\r
3316 OPJ_BYTE * l_current_ptr = 00;
\r
3318 OPJ_UINT32 l_num_band;
\r
3321 assert(p_j2k != 00);
\r
3322 assert(p_manager != 00);
\r
3323 assert(p_header_data != 00);
\r
3325 l_cp = &(p_j2k->m_cp);
\r
3326 l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
3327 // precondition again
\r
3328 assert(p_comp_no < p_j2k->m_image->numcomps);
\r
3329 l_tccp = &l_tcp->tccps[p_comp_no];
\r
3330 l_current_ptr = p_header_data;
\r
3333 (* p_header_size < 1)
\r
3335 opj_event_msg(p_manager, EVT_ERROR, "Error reading SQcd or SQcc element\n");
\r
3338 * p_header_size -= 1;
\r
3340 opj_read_bytes(l_current_ptr, &l_tmp ,1); /* Sqcx */
\r
3343 l_tccp->qntsty = l_tmp & 0x1f;
\r
3344 l_tccp->numgbits = l_tmp >> 5;
\r
3346 (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT)
\r
3352 l_num_band = (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) ? (*p_header_size) : (*p_header_size) / 2;
\r
3356 if (p_j2k->m_cp->correct) {
\r
3358 /* if JPWL is on, we check whether there are too many subbands */
\r
3359 if ((numbands < 0) || (numbands >= J2K_MAXBANDS)) {
\r
3360 opj_event_msg(p_j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
\r
3361 "JPWL: bad number of subbands in Sqcx (%d)\n",
\r
3363 if (!JPWL_ASSUME) {
\r
3364 opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
\r
3367 /* we try to correct */
\r
3369 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust them\n"
\r
3370 "- setting number of bands to %d => HYPOTHESIS!!!\n",
\r
3375 #endif /* USE_JPWL */
\r
3377 (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)
\r
3380 (l_band_no = 0; l_band_no < l_num_band; l_band_no++)
\r
3382 opj_read_bytes(l_current_ptr, &l_tmp ,1); /* SPqcx_i */
\r
3384 l_tccp->stepsizes[l_band_no].expn = l_tmp>>3;
\r
3385 l_tccp->stepsizes[l_band_no].mant = 0;
\r
3387 * p_header_size = * p_header_size - l_num_band;
\r
3392 (l_band_no = 0; l_band_no < l_num_band; l_band_no++)
\r
3394 opj_read_bytes(l_current_ptr, &l_tmp ,2); /* SPqcx_i */
\r
3396 l_tccp->stepsizes[l_band_no].expn = l_tmp >> 11;
\r
3397 l_tccp->stepsizes[l_band_no].mant = l_tmp & 0x7ff;
\r
3399 * p_header_size = * p_header_size - 2*l_num_band;
\r
3402 /* Add Antonin : if scalar_derived -> compute other stepsizes */
\r
3404 (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT)
\r
3407 (l_band_no = 1; l_band_no < J2K_MAXBANDS; l_band_no++)
\r
3409 l_tccp->stepsizes[l_band_no].expn =
\r
3410 ((l_tccp->stepsizes[0].expn) - ((l_band_no - 1) / 3) > 0) ?
\r
3411 (l_tccp->stepsizes[0].expn) - ((l_band_no - 1) / 3) : 0;
\r
3412 l_tccp->stepsizes[l_band_no].mant = l_tccp->stepsizes[0].mant;
\r
3422 * Copies the tile component parameters of all the component from the first tile component.
\r
3424 * @param p_j2k the J2k codec.
\r
3426 void j2k_copy_tile_quantization_parameters(
\r
3433 opj_cp_t *l_cp = 00;
\r
3434 opj_tcp_t *l_tcp = 00;
\r
3435 opj_tccp_t *l_ref_tccp = 00;
\r
3436 opj_tccp_t *l_copied_tccp = 00;
\r
3437 OPJ_UINT32 l_size;
\r
3439 assert(p_j2k != 00);
\r
3441 l_cp = &(p_j2k->m_cp);
\r
3442 l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
3443 // precondition again
\r
3444 l_ref_tccp = &l_tcp->tccps[0];
\r
3445 l_copied_tccp = l_ref_tccp + 1;
\r
3446 l_size = J2K_MAXBANDS * sizeof(opj_stepsize_t);
\r
3449 (i=1;i<p_j2k->m_image->numcomps;++i)
\r
3451 l_copied_tccp->qntsty = l_ref_tccp->qntsty;
\r
3452 l_copied_tccp->numgbits = l_ref_tccp->numgbits;
\r
3453 memcpy(l_copied_tccp->stepsizes,l_ref_tccp->stepsizes,l_size);
\r
3461 * Writes the QCD marker (quantization default)
\r
3463 * @param p_comp_number the index of the component to output.
\r
3464 * @param p_stream the stream to write data to.
\r
3465 * @param p_j2k J2K codec.
\r
3466 * @param p_manager the user event manager.
\r
3468 bool j2k_write_qcd(
\r
3470 struct opj_stream_private *p_stream,
\r
3471 struct opj_event_mgr * p_manager
\r
3474 opj_cp_t *l_cp = 00;
\r
3475 opj_tcp_t *l_tcp = 00;
\r
3476 OPJ_UINT32 l_qcd_size,l_remaining_size;
\r
3477 OPJ_BYTE * l_current_data = 00;
\r
3480 assert(p_j2k != 00);
\r
3481 assert(p_manager != 00);
\r
3482 assert(p_stream != 00);
\r
3484 l_cp = &(p_j2k->m_cp);
\r
3485 l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
\r
3486 l_qcd_size = 4 + j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,0);
\r
3487 l_remaining_size = l_qcd_size;
\r
3490 (l_qcd_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
3492 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
3494 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
3497 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
3501 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_qcd_size;
\r
3503 l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
3505 opj_write_bytes(l_current_data,J2K_MS_QCD,2); /* QCD */
\r
3506 l_current_data += 2;
\r
3508 opj_write_bytes(l_current_data,l_qcd_size-2,2); /* L_QCD */
\r
3509 l_current_data += 2;
\r
3511 l_remaining_size -= 4;
\r
3514 (! j2k_write_SQcd_SQcc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager))
\r
3516 opj_event_msg(p_manager, EVT_ERROR, "Error writting QCD marker\n");
\r
3520 (l_remaining_size != 0)
\r
3522 opj_event_msg(p_manager, EVT_ERROR, "Error writting QCD marker\n");
\r
3527 (opj_stream_write_data(p_stream, p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_qcd_size,p_manager) != l_qcd_size)
\r
3535 * Reads a QCD marker (Quantization defaults)
\r
3536 * @param p_header_data the data contained in the QCD box.
\r
3537 * @param p_j2k the jpeg2000 codec.
\r
3538 * @param p_header_size the size of the data contained in the QCD marker.
\r
3539 * @param p_manager the user event manager.
\r
3541 bool j2k_read_qcd (
\r
3542 opj_j2k_t *p_j2k,
\r
3543 OPJ_BYTE * p_header_data,
\r
3544 OPJ_UINT32 p_header_size,
\r
3545 struct opj_event_mgr * p_manager
\r
3549 assert(p_header_data != 00);
\r
3550 assert(p_j2k != 00);
\r
3551 assert(p_manager != 00);
\r
3554 (! j2k_read_SQcd_SQcc(p_j2k,0,p_header_data,&p_header_size,p_manager))
\r
3556 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n");
\r
3560 (p_header_size != 0)
\r
3562 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n");
\r
3565 j2k_copy_tile_quantization_parameters(p_j2k);
\r
3571 * Writes the QCC marker (quantization component)
\r
3573 * @param p_comp_no the index of the component to output.
\r
3574 * @param p_stream the stream to write data to.
\r
3575 * @param p_j2k J2K codec.
\r
3576 * @param p_manager the user event manager.
\r
3578 bool j2k_write_qcc(
\r
3580 OPJ_UINT32 p_comp_no,
\r
3581 struct opj_stream_private *p_stream,
\r
3582 struct opj_event_mgr * p_manager
\r
3585 OPJ_UINT32 l_qcc_size,l_remaining_size;
\r
3588 assert(p_j2k != 00);
\r
3589 assert(p_manager != 00);
\r
3590 assert(p_stream != 00);
\r
3592 l_qcc_size = 6 + j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
\r
3593 l_remaining_size = l_qcc_size;
\r
3595 (l_qcc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
3597 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
3599 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
3602 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
3606 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_qcc_size;
\r
3608 j2k_write_qcc_in_memory(p_j2k,p_comp_no,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_remaining_size,p_manager);
\r
3611 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_qcc_size,p_manager) != l_qcc_size)
\r
3620 * Writes the QCC marker (quantization component)
\r
3622 * @param p_comp_no the index of the component to output.
\r
3623 * @param p_stream the stream to write data to.
\r
3624 * @param p_j2k J2K codec.
\r
3625 * @param p_manager the user event manager.
\r
3627 void j2k_write_qcc_in_memory(
\r
3629 OPJ_UINT32 p_comp_no,
\r
3630 OPJ_BYTE * p_data,
\r
3631 OPJ_UINT32 * p_data_written,
\r
3632 struct opj_event_mgr * p_manager
\r
3635 OPJ_UINT32 l_qcc_size,l_remaining_size;
\r
3636 OPJ_BYTE * l_current_data = 00;
\r
3639 assert(p_j2k != 00);
\r
3640 assert(p_manager != 00);
\r
3642 l_qcc_size = 6 + j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
\r
3643 l_remaining_size = l_qcc_size;
\r
3645 l_current_data = p_data;
\r
3647 opj_write_bytes(l_current_data,J2K_MS_QCC,2); /* QCC */
\r
3648 l_current_data += 2;
\r
3651 (p_j2k->m_image->numcomps <= 256)
\r
3654 opj_write_bytes(l_current_data,l_qcc_size-2,2); /* L_QCC */
\r
3655 l_current_data += 2;
\r
3656 opj_write_bytes(l_current_data, p_comp_no, 1); /* Cqcc */
\r
3658 // in the case only one byte is sufficient the last byte allocated is useless -> still do -6 for available
\r
3659 l_remaining_size -= 6;
\r
3663 opj_write_bytes(l_current_data,l_qcc_size-2,2); /* L_QCC */
\r
3664 l_current_data += 2;
\r
3665 opj_write_bytes(l_current_data, p_comp_no, 2); /* Cqcc */
\r
3666 l_current_data+=2;
\r
3667 l_remaining_size -= 6;
\r
3669 j2k_write_SQcd_SQcc(p_j2k,p_j2k->m_current_tile_number,p_comp_no,l_current_data,&l_remaining_size,p_manager);
\r
3670 * p_data_written = l_qcc_size;
\r
3674 * Gets the maximum size taken by a qcc.
\r
3676 OPJ_UINT32 j2k_get_max_qcc_size (opj_j2k_t *p_j2k)
\r
3678 return j2k_get_max_coc_size(p_j2k);
\r
3682 * Reads a QCC marker (Quantization component)
\r
3683 * @param p_header_data the data contained in the QCC box.
\r
3684 * @param p_j2k the jpeg2000 codec.
\r
3685 * @param p_header_size the size of the data contained in the QCC marker.
\r
3686 * @param p_manager the user event manager.
\r
3688 bool j2k_read_qcc(
\r
3689 opj_j2k_t *p_j2k,
\r
3690 OPJ_BYTE * p_header_data,
\r
3691 OPJ_UINT32 p_header_size,
\r
3692 struct opj_event_mgr * p_manager)
\r
3694 OPJ_UINT32 l_num_comp,l_comp_no;
\r
3696 assert(p_header_data != 00);
\r
3697 assert(p_j2k != 00);
\r
3698 assert(p_manager != 00);
\r
3700 l_num_comp = p_j2k->m_image->numcomps;
\r
3703 if (p_j2k->m_cp->correct) {
\r
3705 static OPJ_UINT32 backup_compno = 0;
\r
3707 /* compno is negative or larger than the number of components!!! */
\r
3708 if ((compno < 0) || (compno >= numcomp)) {
\r
3709 opj_event_msg(p_j2k->cinfo, EVT_ERROR,
\r
3710 "JPWL: bad component number in QCC (%d out of a maximum of %d)\n",
\r
3712 if (!JPWL_ASSUME) {
\r
3713 opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
\r
3716 /* we try to correct */
\r
3717 compno = backup_compno % numcomp;
\r
3718 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
\r
3719 "- setting component number to %d\n",
\r
3723 /* keep your private count of tiles */
\r
3726 #endif /* USE_JPWL */
\r
3728 (l_num_comp <= 256)
\r
3731 (p_header_size < 1)
\r
3733 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
\r
3736 opj_read_bytes(p_header_data,&l_comp_no,1);
\r
3743 (p_header_size < 2)
\r
3745 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
\r
3748 opj_read_bytes(p_header_data,&l_comp_no,2);
\r
3753 (! j2k_read_SQcd_SQcc(p_j2k,l_comp_no,p_header_data,&p_header_size,p_manager))
\r
3755 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
\r
3759 (p_header_size != 0)
\r
3761 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
\r
3770 * Writes the CBD marker (Component bit depth definition)
\r
3772 * @param p_stream the stream to write data to.
\r
3773 * @param p_j2k J2K codec.
\r
3774 * @param p_manager the user event manager.
\r
3776 bool j2k_write_cbd(
\r
3778 struct opj_stream_private *p_stream,
\r
3779 struct opj_event_mgr * p_manager
\r
3783 OPJ_UINT32 l_cbd_size;
\r
3784 OPJ_BYTE * l_current_data = 00;
\r
3785 opj_image_t *l_image = 00;
\r
3786 opj_image_comp_t * l_comp = 00;
\r
3789 assert(p_j2k != 00);
\r
3790 assert(p_manager != 00);
\r
3791 assert(p_stream != 00);
\r
3793 l_image = p_j2k->m_image;
\r
3794 l_cbd_size = 6 + p_j2k->m_image->numcomps;
\r
3797 (l_cbd_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
3799 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
3801 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
3804 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
3808 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_cbd_size;
\r
3811 l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
3812 opj_write_bytes(l_current_data,J2K_MS_CBD,2); /* CBD */
\r
3813 l_current_data += 2;
\r
3814 opj_write_bytes(l_current_data,l_cbd_size-2,2); /* L_CBD */
\r
3815 l_current_data += 2;
\r
3816 opj_write_bytes(l_current_data,l_image->numcomps, 2); /* Ncbd */
\r
3817 l_current_data+=2;
\r
3818 l_comp = l_image->comps;
\r
3820 (i=0;i<l_image->numcomps;++i)
\r
3822 opj_write_bytes(l_current_data, (l_comp->sgnd << 7) | (l_comp->prec - 1), 1); /* Component bit depth */
\r
3827 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_cbd_size,p_manager) != l_cbd_size)
\r
3835 * Reads a CBD marker (Component bit depth definition)
\r
3836 * @param p_header_data the data contained in the CBD box.
\r
3837 * @param p_j2k the jpeg2000 codec.
\r
3838 * @param p_header_size the size of the data contained in the CBD marker.
\r
3839 * @param p_manager the user event manager.
\r
3841 bool j2k_read_cbd (
\r
3842 opj_j2k_t *p_j2k,
\r
3843 OPJ_BYTE * p_header_data,
\r
3844 OPJ_UINT32 p_header_size,
\r
3845 struct opj_event_mgr * p_manager)
\r
3847 OPJ_UINT32 l_nb_comp,l_num_comp;
\r
3848 OPJ_UINT32 l_comp_def;
\r
3850 opj_image_comp_t * l_comp = 00;
\r
3853 assert(p_header_data != 00);
\r
3854 assert(p_j2k != 00);
\r
3855 assert(p_manager != 00);
\r
3857 l_num_comp = p_j2k->m_image->numcomps;
\r
3860 (p_header_size != (p_j2k->m_image->numcomps + 2))
\r
3862 opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
\r
3865 opj_read_bytes(p_header_data,&l_nb_comp,2); /* Ncbd */
\r
3868 (l_nb_comp != l_num_comp)
\r
3870 opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
\r
3874 l_comp = p_j2k->m_image->comps;
\r
3876 (i=0;i<l_num_comp;++i)
\r
3878 opj_read_bytes(p_header_data,&l_comp_def,1); /* Component bit depth */
\r
3880 l_comp->sgnd = (l_comp_def>>7) & 1;
\r
3881 l_comp->prec = (l_comp_def&0x7f) + 1;
\r
3888 * Writes the MCC marker (Multiple Component Collection)
\r
3890 * @param p_stream the stream to write data to.
\r
3891 * @param p_j2k J2K codec.
\r
3892 * @param p_manager the user event manager.
\r
3894 bool j2k_write_mcc_record(
\r
3896 struct opj_simple_mcc_decorrelation_data * p_mcc_record,
\r
3897 struct opj_stream_private *p_stream,
\r
3898 struct opj_event_mgr * p_manager
\r
3902 OPJ_UINT32 l_mcc_size;
\r
3903 OPJ_BYTE * l_current_data = 00;
\r
3904 OPJ_UINT32 l_nb_bytes_for_comp;
\r
3905 OPJ_UINT32 l_mask;
\r
3906 OPJ_UINT32 l_tmcc;
\r
3909 assert(p_j2k != 00);
\r
3910 assert(p_manager != 00);
\r
3911 assert(p_stream != 00);
\r
3914 (p_mcc_record->m_nb_comps > 255 )
\r
3916 l_nb_bytes_for_comp = 2;
\r
3921 l_nb_bytes_for_comp = 1;
\r
3925 l_mcc_size = p_mcc_record->m_nb_comps * 2 * l_nb_bytes_for_comp + 19;
\r
3927 (l_mcc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
3929 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
3931 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
3934 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
3938 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mcc_size;
\r
3940 l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
3941 opj_write_bytes(l_current_data,J2K_MS_MCC,2); /* MCC */
\r
3942 l_current_data += 2;
\r
3943 opj_write_bytes(l_current_data,l_mcc_size-2,2); /* Lmcc */
\r
3944 l_current_data += 2;
\r
3946 /* first marker */
\r
3947 opj_write_bytes(l_current_data,0,2); /* Zmcc */
\r
3948 l_current_data += 2;
\r
3949 opj_write_bytes(l_current_data,p_mcc_record->m_index,1); /* Imcc -> no need for other values, take the first */
\r
3951 /* only one marker atm */
\r
3952 opj_write_bytes(l_current_data,0,2); /* Ymcc */
\r
3953 l_current_data+=2;
\r
3954 opj_write_bytes(l_current_data,1,2); /* Qmcc -> number of collections -> 1 */
\r
3955 l_current_data+=2;
\r
3956 opj_write_bytes(l_current_data,0x1,1); /* Xmcci type of component transformation -> array based decorrelation */
\r
3959 opj_write_bytes(l_current_data,p_mcc_record->m_nb_comps | l_mask,2); /* Nmcci number of input components involved and size for each component offset = 8 bits */
\r
3960 l_current_data+=2;
\r
3963 (i=0;i<p_mcc_record->m_nb_comps;++i)
\r
3965 opj_write_bytes(l_current_data,i,l_nb_bytes_for_comp); /* Cmccij Component offset*/
\r
3966 l_current_data+=l_nb_bytes_for_comp;
\r
3969 opj_write_bytes(l_current_data,p_mcc_record->m_nb_comps|l_mask,2); /* Mmcci number of output components involved and size for each component offset = 8 bits */
\r
3970 l_current_data+=2;
\r
3972 (i=0;i<p_mcc_record->m_nb_comps;++i)
\r
3974 opj_write_bytes(l_current_data,i,l_nb_bytes_for_comp); /* Wmccij Component offset*/
\r
3975 l_current_data+=l_nb_bytes_for_comp;
\r
3977 l_tmcc = ((!p_mcc_record->m_is_irreversible)&1)<<16;
\r
3979 (p_mcc_record->m_decorrelation_array)
\r
3981 l_tmcc |= p_mcc_record->m_decorrelation_array->m_index;
\r
3984 (p_mcc_record->m_offset_array)
\r
3986 l_tmcc |= ((p_mcc_record->m_offset_array->m_index)<<8);
\r
3988 opj_write_bytes(l_current_data,l_tmcc,3); /* Tmcci : use MCT defined as number 1 and irreversible array based. */
\r
3989 l_current_data+=3;
\r
3991 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_mcc_size,p_manager) != l_mcc_size)
\r
4000 * Reads a MCC marker (Multiple Component Collection)
\r
4002 * @param p_header_data the data contained in the MCC box.
\r
4003 * @param p_j2k the jpeg2000 codec.
\r
4004 * @param p_header_size the size of the data contained in the MCC marker.
\r
4005 * @param p_manager the user event manager.
\r
4007 bool j2k_read_mcc (
\r
4008 opj_j2k_t *p_j2k,
\r
4009 OPJ_BYTE * p_header_data,
\r
4010 OPJ_UINT32 p_header_size,
\r
4011 struct opj_event_mgr * p_manager
\r
4016 OPJ_UINT32 l_indix;
\r
4017 opj_tcp_t * l_tcp;
\r
4018 opj_simple_mcc_decorrelation_data_t * l_mcc_record;
\r
4019 opj_mct_data_t * l_mct_data;
\r
4020 OPJ_UINT32 l_nb_collections;
\r
4021 OPJ_UINT32 l_nb_comps;
\r
4022 OPJ_UINT32 l_nb_bytes_by_comp;
\r
4026 assert(p_header_data != 00);
\r
4027 assert(p_j2k != 00);
\r
4028 assert(p_manager != 00);
\r
4030 l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
4033 (p_header_size < 2)
\r
4035 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
\r
4039 /* first marker */
\r
4040 opj_read_bytes(p_header_data,&l_tmp,2); /* Zmcc */
\r
4041 p_header_data += 2;
\r
4045 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n");
\r
4049 (p_header_size < 7)
\r
4051 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
\r
4054 opj_read_bytes(p_header_data,&l_indix,1); /* Imcc -> no need for other values, take the first */
\r
4057 l_mcc_record = l_tcp->m_mcc_records;
\r
4059 (i=0;i<l_tcp->m_nb_mcc_records;++i)
\r
4062 (l_mcc_record->m_index == l_indix)
\r
4070 (i == l_tcp->m_nb_mcc_records)
\r
4073 (l_tcp->m_nb_mcc_records == l_tcp->m_nb_max_mcc_records)
\r
4075 l_tcp->m_nb_max_mcc_records += J2K_MCC_DEFAULT_NB_RECORDS;
\r
4076 l_tcp->m_mcc_records = opj_realloc(l_tcp->m_mcc_records,l_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
\r
4078 (! l_tcp->m_mcc_records)
\r
4080 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
\r
4083 l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
\r
4084 memset(l_mcc_record,0,(l_tcp->m_nb_max_mcc_records-l_tcp->m_nb_mcc_records) * sizeof(opj_simple_mcc_decorrelation_data_t));
\r
4086 l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
\r
4088 l_mcc_record->m_index = l_indix;
\r
4090 /* only one marker atm */
\r
4091 opj_read_bytes(p_header_data,&l_tmp,2); /* Ymcc */
\r
4096 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n");
\r
4099 opj_read_bytes(p_header_data,&l_nb_collections,2); /* Qmcc -> number of collections -> 1 */
\r
4102 (l_nb_collections > 1)
\r
4104 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple collections\n");
\r
4107 p_header_size -= 7;
\r
4109 (i=0;i<l_nb_collections;++i)
\r
4112 (p_header_size < 3)
\r
4114 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
\r
4117 opj_read_bytes(p_header_data,&l_tmp,1); /* Xmcci type of component transformation -> array based decorrelation */
\r
4122 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections other than array decorrelation\n");
\r
4125 opj_read_bytes(p_header_data,&l_nb_comps,2);
\r
4128 l_nb_bytes_by_comp = 1 + (l_nb_comps>>15);
\r
4129 l_mcc_record->m_nb_comps = l_nb_comps & 0x7fff;
\r
4131 (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2))
\r
4133 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
\r
4136 p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2);
\r
4138 (j=0;j<l_mcc_record->m_nb_comps;++j)
\r
4140 opj_read_bytes(p_header_data,&l_tmp,l_nb_bytes_by_comp); /* Cmccij Component offset*/
\r
4141 p_header_data+=l_nb_bytes_by_comp;
\r
4145 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n");
\r
4149 opj_read_bytes(p_header_data,&l_nb_comps,2);
\r
4151 l_nb_bytes_by_comp = 1 + (l_nb_comps>>15);
\r
4152 l_nb_comps &= 0x7fff;
\r
4154 (l_nb_comps != l_mcc_record->m_nb_comps)
\r
4156 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections without same number of indixes\n");
\r
4160 (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3))
\r
4162 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
\r
4165 p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3);
\r
4167 (j=0;j<l_mcc_record->m_nb_comps;++j)
\r
4169 opj_read_bytes(p_header_data,&l_tmp,l_nb_bytes_by_comp); /* Wmccij Component offset*/
\r
4170 p_header_data+=l_nb_bytes_by_comp;
\r
4174 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n");
\r
4178 opj_read_bytes(p_header_data,&l_tmp,3); /* Wmccij Component offset*/
\r
4179 p_header_data += 3;
\r
4180 l_mcc_record->m_is_irreversible = ! ((l_tmp>>16) & 1);
\r
4181 l_mcc_record->m_decorrelation_array = 00;
\r
4182 l_mcc_record->m_offset_array = 00;
\r
4183 l_indix = l_tmp & 0xff;
\r
4187 l_mct_data = l_tcp->m_mct_records;
\r
4189 (j=0;j<l_tcp->m_nb_mct_records;++j)
\r
4192 (l_mct_data->m_index == l_indix)
\r
4194 l_mcc_record->m_decorrelation_array = l_mct_data;
\r
4200 (l_mcc_record->m_decorrelation_array == 00)
\r
4202 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
\r
4206 l_indix = (l_tmp >> 8) & 0xff;
\r
4210 l_mct_data = l_tcp->m_mct_records;
\r
4212 (j=0;j<l_tcp->m_nb_mct_records;++j)
\r
4215 (l_mct_data->m_index == l_indix)
\r
4217 l_mcc_record->m_offset_array = l_mct_data;
\r
4223 (l_mcc_record->m_offset_array == 00)
\r
4225 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
\r
4231 (p_header_size != 0)
\r
4233 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
\r
4236 ++l_tcp->m_nb_mcc_records;
\r
4241 * Writes the MCT marker (Multiple Component Transform)
\r
4243 * @param p_stream the stream to write data to.
\r
4244 * @param p_j2k J2K codec.
\r
4245 * @param p_manager the user event manager.
\r
4247 bool j2k_write_mct_record(
\r
4249 opj_mct_data_t * p_mct_record,
\r
4250 struct opj_stream_private *p_stream,
\r
4251 struct opj_event_mgr * p_manager
\r
4254 OPJ_UINT32 l_mct_size;
\r
4255 OPJ_BYTE * l_current_data = 00;
\r
4259 assert(p_j2k != 00);
\r
4260 assert(p_manager != 00);
\r
4261 assert(p_stream != 00);
\r
4263 l_mct_size = 10 + p_mct_record->m_data_size;
\r
4265 (l_mct_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
4267 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
4269 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
4272 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
4276 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mct_size;
\r
4279 l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
4281 opj_write_bytes(l_current_data,J2K_MS_MCT,2); /* MCT */
\r
4282 l_current_data += 2;
\r
4283 opj_write_bytes(l_current_data,l_mct_size-2,2); /* Lmct */
\r
4284 l_current_data += 2;
\r
4285 opj_write_bytes(l_current_data,0,2); /* Zmct */
\r
4286 l_current_data += 2;
\r
4287 /* only one marker atm */
\r
4288 l_tmp = (p_mct_record->m_index & 0xff) | (p_mct_record->m_array_type << 8) | (p_mct_record->m_element_type << 10);
\r
4289 opj_write_bytes(l_current_data,l_tmp,2);
\r
4290 l_current_data += 2;
\r
4291 opj_write_bytes(l_current_data,0,2); /* Ymct */
\r
4292 l_current_data+=2;
\r
4294 memcpy(l_current_data,p_mct_record->m_data,p_mct_record->m_data_size);
\r
4296 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_mct_size,p_manager) != l_mct_size)
\r
4304 * Reads a MCT marker (Multiple Component Transform)
\r
4306 * @param p_header_data the data contained in the MCT box.
\r
4307 * @param p_j2k the jpeg2000 codec.
\r
4308 * @param p_header_size the size of the data contained in the MCT marker.
\r
4309 * @param p_manager the user event manager.
\r
4311 bool j2k_read_mct (
\r
4312 opj_j2k_t *p_j2k,
\r
4313 OPJ_BYTE * p_header_data,
\r
4314 OPJ_UINT32 p_header_size,
\r
4315 struct opj_event_mgr * p_manager
\r
4319 opj_tcp_t *l_tcp = 00;
\r
4321 OPJ_UINT32 l_indix;
\r
4322 opj_mct_data_t * l_mct_data;
\r
4325 assert(p_header_data != 00);
\r
4326 assert(p_j2k != 00);
\r
4328 l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
4331 (p_header_size < 2)
\r
4333 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
\r
4336 /* first marker */
\r
4337 opj_read_bytes(p_header_data,&l_tmp,2); /* Zmct */
\r
4338 p_header_data += 2;
\r
4342 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge mct data within multiple MCT records\n");
\r
4346 (p_header_size <= 6)
\r
4348 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
\r
4351 opj_read_bytes(p_header_data,&l_tmp,2); /* Imct -> no need for other values, take the first, type is double with decorrelation x0000 1101 0000 0000*/
\r
4352 p_header_data += 2;
\r
4354 l_indix = l_tmp & 0xff;
\r
4355 l_mct_data = l_tcp->m_mct_records;
\r
4357 (i=0;i<l_tcp->m_nb_mct_records;++i)
\r
4360 (l_mct_data->m_index == l_indix)
\r
4368 (i == l_tcp->m_nb_mct_records)
\r
4371 (l_tcp->m_nb_mct_records == l_tcp->m_nb_max_mct_records)
\r
4373 l_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
\r
4374 l_tcp->m_mct_records = opj_realloc(l_tcp->m_mct_records,l_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
\r
4376 (! l_tcp->m_mct_records)
\r
4378 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
\r
4381 l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
\r
4382 memset(l_mct_data ,0,(l_tcp->m_nb_max_mct_records - l_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
\r
4384 l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
\r
4387 (l_mct_data->m_data)
\r
4389 opj_free(l_mct_data->m_data);
\r
4390 l_mct_data->m_data = 00;
\r
4392 l_mct_data->m_index = l_indix;
\r
4393 l_mct_data->m_array_type = (l_tmp >> 8) & 3;
\r
4394 l_mct_data->m_element_type = (l_tmp >> 10) & 3;
\r
4396 opj_read_bytes(p_header_data,&l_tmp,2); /* Ymct */
\r
4401 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple MCT markers\n");
\r
4404 p_header_size -= 6;
\r
4405 l_mct_data->m_data = opj_malloc(p_header_size);
\r
4407 (! l_mct_data->m_data)
\r
4409 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
\r
4412 memcpy(l_mct_data->m_data,p_header_data,p_header_size);
\r
4413 l_mct_data->m_data_size = p_header_size;
\r
4414 ++l_tcp->m_nb_mct_records;
\r
4418 bool j2k_setup_mct_encoding (opj_tcp_t * p_tcp,opj_image_t * p_image)
\r
4421 OPJ_UINT32 l_indix = 1;
\r
4422 opj_mct_data_t * l_mct_deco_data = 00,* l_mct_offset_data = 00;
\r
4423 opj_simple_mcc_decorrelation_data_t * l_mcc_data;
\r
4424 OPJ_UINT32 l_mct_size,l_nb_elem;
\r
4425 OPJ_FLOAT32 * l_data, * l_current_data;
\r
4426 opj_tccp_t * l_tccp;
\r
4429 assert(p_tcp != 00);
\r
4438 (p_tcp->m_mct_decoding_matrix)
\r
4441 (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records)
\r
4443 p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
\r
4444 p_tcp->m_mct_records = opj_realloc(p_tcp->m_mct_records,p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
\r
4446 (! p_tcp->m_mct_records)
\r
4450 l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
\r
4451 memset(l_mct_deco_data ,0,(p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
\r
4453 l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
\r
4456 (l_mct_deco_data->m_data)
\r
4458 opj_free(l_mct_deco_data->m_data);
\r
4459 l_mct_deco_data->m_data = 00;
\r
4461 l_mct_deco_data->m_index = l_indix++;
\r
4462 l_mct_deco_data->m_array_type = MCT_TYPE_DECORRELATION;
\r
4463 l_mct_deco_data->m_element_type = MCT_TYPE_FLOAT;
\r
4464 l_nb_elem = p_image->numcomps * p_image->numcomps;
\r
4465 l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_deco_data->m_element_type];
\r
4466 l_mct_deco_data->m_data = opj_malloc(l_mct_size );
\r
4468 (! l_mct_deco_data->m_data)
\r
4472 j2k_mct_write_functions_from_float[l_mct_deco_data->m_element_type](p_tcp->m_mct_decoding_matrix,l_mct_deco_data->m_data,l_nb_elem);
\r
4473 l_mct_deco_data->m_data_size = l_mct_size;
\r
4474 ++p_tcp->m_nb_mct_records;
\r
4478 (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records)
\r
4480 p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
\r
4481 p_tcp->m_mct_records = opj_realloc(p_tcp->m_mct_records,p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
\r
4483 (! p_tcp->m_mct_records)
\r
4487 l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
\r
4488 memset(l_mct_offset_data ,0,(p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
\r
4492 l_mct_deco_data = l_mct_offset_data - 1;
\r
4495 l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
\r
4497 (l_mct_offset_data->m_data)
\r
4499 opj_free(l_mct_offset_data->m_data);
\r
4500 l_mct_offset_data->m_data = 00;
\r
4503 l_mct_offset_data->m_index = l_indix++;
\r
4504 l_mct_offset_data->m_array_type = MCT_TYPE_OFFSET;
\r
4505 l_mct_offset_data->m_element_type = MCT_TYPE_FLOAT;
\r
4506 l_nb_elem = p_image->numcomps;
\r
4507 l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_offset_data->m_element_type];
\r
4508 l_mct_offset_data->m_data = opj_malloc(l_mct_size );
\r
4510 (! l_mct_offset_data->m_data)
\r
4514 l_data = opj_malloc(l_nb_elem * sizeof(OPJ_FLOAT32));
\r
4518 opj_free(l_mct_offset_data->m_data);
\r
4519 l_mct_offset_data->m_data = 00;
\r
4522 l_tccp = p_tcp->tccps;
\r
4523 l_current_data = l_data;
\r
4525 (i=0;i<l_nb_elem;++i)
\r
4527 *(l_current_data++) = (OPJ_FLOAT32) (l_tccp->m_dc_level_shift);
\r
4530 j2k_mct_write_functions_from_float[l_mct_offset_data->m_element_type](l_data,l_mct_offset_data->m_data,l_nb_elem);
\r
4532 l_mct_offset_data->m_data_size = l_mct_size;
\r
4533 ++p_tcp->m_nb_mct_records;
\r
4536 (p_tcp->m_nb_mcc_records == p_tcp->m_nb_max_mcc_records)
\r
4538 p_tcp->m_nb_max_mcc_records += J2K_MCT_DEFAULT_NB_RECORDS;
\r
4539 p_tcp->m_mcc_records = opj_realloc(p_tcp->m_mcc_records,p_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
\r
4541 (! p_tcp->m_mcc_records)
\r
4545 l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
\r
4546 memset(l_mcc_data ,0,(p_tcp->m_nb_max_mcc_records - p_tcp->m_nb_mcc_records) * sizeof(opj_simple_mcc_decorrelation_data_t));
\r
4549 l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
\r
4550 l_mcc_data->m_decorrelation_array = l_mct_deco_data;
\r
4551 l_mcc_data->m_is_irreversible = 1;
\r
4552 l_mcc_data->m_nb_comps = p_image->numcomps;
\r
4553 l_mcc_data->m_index = l_indix++;
\r
4554 l_mcc_data->m_offset_array = l_mct_offset_data;
\r
4555 ++p_tcp->m_nb_mcc_records;
\r
4560 * Writes the MCO marker (Multiple component transformation ordering)
\r
4562 * @param p_stream the stream to write data to.
\r
4563 * @param p_j2k J2K codec.
\r
4564 * @param p_manager the user event manager.
\r
4566 bool j2k_write_mco(
\r
4568 struct opj_stream_private *p_stream,
\r
4569 struct opj_event_mgr * p_manager
\r
4572 OPJ_BYTE * l_current_data = 00;
\r
4573 OPJ_UINT32 l_mco_size;
\r
4574 opj_tcp_t * l_tcp = 00;
\r
4575 opj_simple_mcc_decorrelation_data_t * l_mcc_record;
\r
4579 assert(p_j2k != 00);
\r
4580 assert(p_manager != 00);
\r
4581 assert(p_stream != 00);
\r
4583 l_tcp =&(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
\r
4584 l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
4585 l_mco_size = 5 + l_tcp->m_nb_mcc_records;
\r
4587 (l_mco_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
4589 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
4591 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
4594 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
4598 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mco_size;
\r
4601 opj_write_bytes(l_current_data,J2K_MS_MCO,2); /* MCO */
\r
4602 l_current_data += 2;
\r
4603 opj_write_bytes(l_current_data,l_mco_size-2,2); /* Lmco */
\r
4604 l_current_data += 2;
\r
4605 opj_write_bytes(l_current_data,l_tcp->m_nb_mcc_records,1); /* Nmco : only one tranform stage*/
\r
4608 l_mcc_record = l_tcp->m_mcc_records;
\r
4610 (i=0;i<l_tcp->m_nb_mcc_records;++i)
\r
4612 opj_write_bytes(l_current_data,l_mcc_record->m_index,1); /* Imco -> use the mcc indicated by 1*/
\r
4618 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_mco_size,p_manager) != l_mco_size)
\r
4625 * Reads a MCO marker (Multiple Component Transform Ordering)
\r
4627 * @param p_header_data the data contained in the MCO box.
\r
4628 * @param p_j2k the jpeg2000 codec.
\r
4629 * @param p_header_size the size of the data contained in the MCO marker.
\r
4630 * @param p_manager the user event manager.
\r
4632 bool j2k_read_mco (
\r
4633 opj_j2k_t *p_j2k,
\r
4634 OPJ_BYTE * p_header_data,
\r
4635 OPJ_UINT32 p_header_size,
\r
4636 struct opj_event_mgr * p_manager
\r
4639 OPJ_UINT32 l_tmp, i;
\r
4640 OPJ_UINT32 l_nb_stages;
\r
4641 opj_tcp_t * l_tcp;
\r
4642 opj_tccp_t * l_tccp;
\r
4643 opj_image_t * l_image;
\r
4644 opj_image_comp_t * l_img_comp;
\r
4647 assert(p_header_data != 00);
\r
4648 assert(p_j2k != 00);
\r
4649 assert(p_manager != 00);
\r
4651 l_image = p_j2k->m_image;
\r
4652 l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
4654 (p_header_size < 1)
\r
4656 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCO marker\n");
\r
4660 opj_read_bytes(p_header_data,&l_nb_stages,1); /* Nmco : only one tranform stage*/
\r
4665 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple transformation stages.\n");
\r
4669 (p_header_size != l_nb_stages + 1)
\r
4671 opj_event_msg(p_manager, EVT_WARNING, "Error reading MCO marker\n");
\r
4675 l_tccp = l_tcp->tccps;
\r
4676 l_img_comp = l_image->comps;
\r
4678 (i=0;i<l_image->numcomps;++i)
\r
4680 l_tccp->m_dc_level_shift = 0;
\r
4684 (l_tcp->m_mct_decoding_matrix)
\r
4686 opj_free(l_tcp->m_mct_decoding_matrix);
\r
4687 l_tcp->m_mct_decoding_matrix = 00;
\r
4691 (i=0;i<l_nb_stages;++i)
\r
4693 opj_read_bytes(p_header_data,&l_tmp,1);
\r
4696 (! j2k_add_mct(l_tcp,p_j2k->m_image,l_tmp))
\r
4704 bool j2k_add_mct(opj_tcp_t * p_tcp,opj_image_t * p_image, OPJ_UINT32 p_index)
\r
4707 opj_simple_mcc_decorrelation_data_t * l_mcc_record;
\r
4708 opj_mct_data_t * l_deco_array, * l_offset_array;
\r
4709 OPJ_UINT32 l_data_size,l_mct_size, l_offset_size;
\r
4710 OPJ_UINT32 l_nb_elem;
\r
4711 OPJ_UINT32 * l_offset_data, * l_current_offset_data;
\r
4712 opj_tccp_t * l_tccp;
\r
4716 assert(p_tcp != 00);
\r
4718 l_mcc_record = p_tcp->m_mcc_records;
\r
4720 (i=0;i<p_tcp->m_nb_mcc_records;++i)
\r
4723 (l_mcc_record->m_index == p_index)
\r
4729 (i==p_tcp->m_nb_mcc_records)
\r
4731 /** element discarded **/
\r
4735 (l_mcc_record->m_nb_comps != p_image->numcomps)
\r
4737 /** do not support number of comps != image */
\r
4740 l_deco_array = l_mcc_record->m_decorrelation_array;
\r
4744 l_data_size = MCT_ELEMENT_SIZE[l_deco_array->m_element_type] * p_image->numcomps * p_image->numcomps;
\r
4746 (l_deco_array->m_data_size != l_data_size)
\r
4750 l_nb_elem = p_image->numcomps * p_image->numcomps;
\r
4751 l_mct_size = l_nb_elem * sizeof(OPJ_FLOAT32);
\r
4752 p_tcp->m_mct_decoding_matrix = opj_malloc(l_mct_size);
\r
4754 (! p_tcp->m_mct_decoding_matrix )
\r
4758 j2k_mct_read_functions_to_float[l_deco_array->m_element_type](l_deco_array->m_data,p_tcp->m_mct_decoding_matrix,l_nb_elem);
\r
4760 l_offset_array = l_mcc_record->m_offset_array;
\r
4764 l_data_size = MCT_ELEMENT_SIZE[l_offset_array->m_element_type] * p_image->numcomps;
\r
4766 (l_offset_array->m_data_size != l_data_size)
\r
4770 l_nb_elem = p_image->numcomps;
\r
4771 l_offset_size = l_nb_elem * sizeof(OPJ_UINT32);
\r
4772 l_offset_data = opj_malloc(l_offset_size);
\r
4774 (! l_offset_data )
\r
4778 j2k_mct_read_functions_to_int32[l_offset_array->m_element_type](l_offset_array->m_data,l_offset_data,l_nb_elem);
\r
4779 l_tccp = p_tcp->tccps;
\r
4780 l_current_offset_data = l_offset_data;
\r
4782 (i=0;i<p_image->numcomps;++i)
\r
4784 l_tccp->m_dc_level_shift = *(l_current_offset_data++);
\r
4787 opj_free(l_offset_data);
\r
4793 * Writes the MCT marker (Multiple Component Transform)
\r
4795 * @param p_stream the stream to write data to.
\r
4796 * @param p_j2k J2K codec.
\r
4797 * @param p_manager the user event manager.
\r
4799 bool j2k_write_mct_data_group(
\r
4801 struct opj_stream_private *p_stream,
\r
4802 struct opj_event_mgr * p_manager
\r
4806 opj_simple_mcc_decorrelation_data_t * l_mcc_record;
\r
4807 opj_mct_data_t * l_mct_record;
\r
4808 opj_tcp_t * l_tcp;
\r
4811 assert(p_j2k != 00);
\r
4812 assert(p_stream != 00);
\r
4813 assert(p_manager != 00);
\r
4816 (! j2k_write_cbd(p_j2k,p_stream,p_manager))
\r
4820 l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
\r
4821 l_mct_record = l_tcp->m_mct_records;
\r
4823 (i=0;i<l_tcp->m_nb_mct_records;++i)
\r
4826 (! j2k_write_mct_record(p_j2k,l_mct_record,p_stream,p_manager))
\r
4832 l_mcc_record = l_tcp->m_mcc_records;
\r
4834 (i=0;i<l_tcp->m_nb_mcc_records;++i)
\r
4837 (! j2k_write_mcc_record(p_j2k,l_mcc_record,p_stream,p_manager))
\r
4844 (! j2k_write_mco(p_j2k,p_stream,p_manager))
\r
4853 * Writes the POC marker (Progression Order Change)
\r
4855 * @param p_stream the stream to write data to.
\r
4856 * @param p_j2k J2K codec.
\r
4857 * @param p_manager the user event manager.
\r
4859 bool j2k_write_poc(
\r
4861 struct opj_stream_private *p_stream,
\r
4862 struct opj_event_mgr * p_manager
\r
4865 OPJ_UINT32 l_nb_comp;
\r
4866 OPJ_UINT32 l_nb_poc;
\r
4867 OPJ_UINT32 l_poc_size;
\r
4868 OPJ_UINT32 l_written_size = 0;
\r
4869 opj_tcp_t *l_tcp = 00;
\r
4870 opj_tccp_t *l_tccp = 00;
\r
4871 OPJ_UINT32 l_poc_room;
\r
4874 assert(p_j2k != 00);
\r
4875 assert(p_manager != 00);
\r
4876 assert(p_stream != 00);
\r
4878 l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number];
\r
4879 l_tccp = &l_tcp->tccps[0];
\r
4880 l_nb_comp = p_j2k->m_image->numcomps;
\r
4881 l_nb_poc = 1 + l_tcp->numpocs;
\r
4883 (l_nb_comp <= 256)
\r
4891 l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc;
\r
4893 (l_poc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
4895 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
4897 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
4900 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
4904 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_poc_size;
\r
4907 j2k_write_poc_in_memory(p_j2k,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_written_size,p_manager);
\r
4910 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_poc_size,p_manager) != l_poc_size)
\r
4921 * @param p_stream the stream to write data to.
\r
4922 * @param p_j2k J2K codec.
\r
4923 * @param p_manager the user event manager.
\r
4925 bool j2k_write_epc(
\r
4927 struct opj_stream_private *p_stream,
\r
4928 struct opj_event_mgr * p_manager
\r
4931 opj_codestream_info_t * l_info = 00;
\r
4934 assert(p_j2k != 00);
\r
4935 assert(p_manager != 00);
\r
4936 assert(p_stream != 00);
\r
4938 l_info = p_j2k->cstr_info;
\r
4942 l_info->codestream_size = opj_stream_tell(p_stream);
\r
4944 /* The following adjustment is done to adjust the codestream size */
\r
4945 /* if SOD is not at 0 in the buffer. Useful in case of JP2, where */
\r
4946 /* the first bunch of bytes is not in the codestream */
\r
4947 l_info->codestream_size -= l_info->main_head_start;
\r
4953 preparation of JPWL marker segments
\r
4957 /* encode according to JPWL */
\r
4958 jpwl_encode(p_j2k, p_stream, image);
\r
4961 #endif /* USE_JPWL */
\r
4967 * Gets the maximum size taken by the writting of a POC.
\r
4969 OPJ_UINT32 j2k_get_max_poc_size(opj_j2k_t *p_j2k)
\r
4971 opj_tcp_t * l_tcp = 00;
\r
4972 OPJ_UINT32 l_nb_tiles = 0;
\r
4973 OPJ_UINT32 l_max_poc = 0;
\r
4976 l_tcp = p_j2k->m_cp.tcps;
\r
4977 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
\r
4980 (i=0;i<l_nb_tiles;++i)
\r
4982 l_max_poc = uint_max(l_max_poc,l_tcp->numpocs);
\r
4986 return 4 + 9 * l_max_poc;
\r
4991 * Writes the POC marker (Progression Order Change)
\r
4993 * @param p_stream the stream to write data to.
\r
4994 * @param p_j2k J2K codec.
\r
4995 * @param p_manager the user event manager.
\r
4997 void j2k_write_poc_in_memory(
\r
4999 OPJ_BYTE * p_data,
\r
5000 OPJ_UINT32 * p_data_written,
\r
5001 struct opj_event_mgr * p_manager
\r
5005 OPJ_BYTE * l_current_data = 00;
\r
5006 OPJ_UINT32 l_nb_comp;
\r
5007 OPJ_UINT32 l_nb_poc;
\r
5008 OPJ_UINT32 l_poc_size;
\r
5009 opj_image_t *l_image = 00;
\r
5010 opj_tcp_t *l_tcp = 00;
\r
5011 opj_tccp_t *l_tccp = 00;
\r
5012 opj_poc_t *l_current_poc = 00;
\r
5013 OPJ_UINT32 l_poc_room;
\r
5016 assert(p_j2k != 00);
\r
5017 assert(p_manager != 00);
\r
5019 l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number];
\r
5020 l_tccp = &l_tcp->tccps[0];
\r
5021 l_image = p_j2k->m_image;
\r
5022 l_nb_comp = l_image->numcomps;
\r
5023 l_nb_poc = 1 + l_tcp->numpocs;
\r
5025 (l_nb_comp <= 256)
\r
5033 l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc;
\r
5035 l_current_data = p_data;
\r
5037 opj_write_bytes(l_current_data,J2K_MS_POC,2); /* POC */
\r
5038 l_current_data += 2;
\r
5039 opj_write_bytes(l_current_data,l_poc_size-2,2); /* Lpoc */
\r
5040 l_current_data += 2;
\r
5042 l_current_poc = l_tcp->pocs;
\r
5044 (i = 0; i < l_nb_poc; ++i)
\r
5046 opj_write_bytes(l_current_data,l_current_poc->resno0,1); /* RSpoc_i */
\r
5048 opj_write_bytes(l_current_data,l_current_poc->compno0,l_poc_room); /* CSpoc_i */
\r
5049 l_current_data+=l_poc_room;
\r
5050 opj_write_bytes(l_current_data,l_current_poc->layno1,2); /* LYEpoc_i */
\r
5051 l_current_data+=2;
\r
5052 opj_write_bytes(l_current_data,l_current_poc->resno1,1); /* REpoc_i */
\r
5054 opj_write_bytes(l_current_data,l_current_poc->compno1,l_poc_room); /* CEpoc_i */
\r
5055 l_current_data+=l_poc_room;
\r
5056 opj_write_bytes(l_current_data,l_current_poc->prg,1); /* Ppoc_i */
\r
5059 /* change the value of the max layer according to the actual number of layers in the file, components and resolutions*/
\r
5060 l_current_poc->layno1 = int_min(l_current_poc->layno1, l_tcp->numlayers);
\r
5061 l_current_poc->resno1 = int_min(l_current_poc->resno1, l_tccp->numresolutions);
\r
5062 l_current_poc->compno1 = int_min(l_current_poc->compno1, l_nb_comp);
\r
5065 * p_data_written = l_poc_size;
\r
5070 * Reads a POC marker (Progression Order Change)
\r
5072 * @param p_header_data the data contained in the POC box.
\r
5073 * @param p_j2k the jpeg2000 codec.
\r
5074 * @param p_header_size the size of the data contained in the POC marker.
\r
5075 * @param p_manager the user event manager.
\r
5077 bool j2k_read_poc (
\r
5078 opj_j2k_t *p_j2k,
\r
5079 OPJ_BYTE * p_header_data,
\r
5080 OPJ_UINT32 p_header_size,
\r
5081 struct opj_event_mgr * p_manager
\r
5085 OPJ_UINT32 l_nb_comp;
\r
5086 opj_image_t * l_image = 00;
\r
5087 OPJ_UINT32 l_old_poc_nb,l_current_poc_nb,l_current_poc_remaining;
\r
5088 OPJ_UINT32 l_chunk_size;
\r
5091 opj_cp_t *l_cp = 00;
\r
5092 opj_tcp_t *l_tcp = 00;
\r
5093 opj_poc_t *l_current_poc = 00;
\r
5094 OPJ_UINT32 l_comp_room;
\r
5097 assert(p_header_data != 00);
\r
5098 assert(p_j2k != 00);
\r
5099 assert(p_manager != 00);
\r
5101 l_image = p_j2k->m_image;
\r
5102 l_nb_comp = l_image->numcomps;
\r
5104 (l_nb_comp <= 256)
\r
5112 l_chunk_size = 5 + 2 * l_comp_room;
\r
5113 l_current_poc_nb = p_header_size / l_chunk_size;
\r
5114 l_current_poc_remaining = p_header_size % l_chunk_size;
\r
5117 ((l_current_poc_nb <= 0) || (l_current_poc_remaining != 0))
\r
5119 opj_event_msg(p_manager, EVT_ERROR, "Error reading POC marker\n");
\r
5123 l_cp = &(p_j2k->m_cp);
\r
5124 l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH) ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
5125 l_old_poc_nb = l_tcp->POC ? l_tcp->numpocs + 1 : 0;
\r
5126 l_current_poc_nb += l_old_poc_nb;
\r
5127 assert(l_current_poc_nb < 32);
\r
5129 /* now poc is in use.*/
\r
5132 l_current_poc = &l_tcp->pocs[l_old_poc_nb];
\r
5134 (i = l_old_poc_nb; i < l_current_poc_nb; ++i)
\r
5136 opj_read_bytes(p_header_data,&(l_current_poc->resno0),1); /* RSpoc_i */
\r
5138 opj_read_bytes(p_header_data,&(l_current_poc->compno0),l_comp_room); /* CSpoc_i */
\r
5139 p_header_data+=l_comp_room;
\r
5140 opj_read_bytes(p_header_data,&(l_current_poc->layno1),2); /* LYEpoc_i */
\r
5142 opj_read_bytes(p_header_data,&(l_current_poc->resno1),1); /* REpoc_i */
\r
5144 opj_read_bytes(p_header_data,&(l_current_poc->compno1),l_comp_room); /* CEpoc_i */
\r
5145 p_header_data+=l_comp_room;
\r
5146 opj_read_bytes(p_header_data,&l_tmp,1); /* Ppoc_i */
\r
5148 l_current_poc->prg = (OPJ_PROG_ORDER) l_tmp;
\r
5149 /* make sure comp is in acceptable bounds */
\r
5150 l_current_poc->compno1 = uint_min(l_current_poc->compno1, l_nb_comp);
\r
5153 l_tcp->numpocs = l_current_poc_nb - 1;
\r
5158 * Writes the RGN marker (Region Of Interest)
\r
5160 * @param p_tile_no the tile to output
\r
5161 * @param p_comp_no the component to output
\r
5162 * @param p_stream the stream to write data to.
\r
5163 * @param p_j2k J2K codec.
\r
5164 * @param p_manager the user event manager.
\r
5166 bool j2k_write_rgn(
\r
5167 opj_j2k_t *p_j2k,
\r
5168 OPJ_UINT32 p_tile_no,
\r
5169 OPJ_UINT32 p_comp_no,
\r
5170 struct opj_stream_private *p_stream,
\r
5171 struct opj_event_mgr * p_manager
\r
5174 OPJ_BYTE * l_current_data = 00;
\r
5175 OPJ_UINT32 l_nb_comp;
\r
5176 OPJ_UINT32 l_rgn_size;
\r
5177 opj_image_t *l_image = 00;
\r
5178 opj_cp_t *l_cp = 00;
\r
5179 opj_tcp_t *l_tcp = 00;
\r
5180 opj_tccp_t *l_tccp = 00;
\r
5181 OPJ_UINT32 l_comp_room;
\r
5184 assert(p_j2k != 00);
\r
5185 assert(p_manager != 00);
\r
5186 assert(p_stream != 00);
\r
5188 l_cp = &(p_j2k->m_cp);
\r
5189 l_tcp = &l_cp->tcps[p_tile_no];
\r
5190 l_tccp = &l_tcp->tccps[p_comp_no];
\r
5192 l_nb_comp = l_image->numcomps;
\r
5195 (l_nb_comp <= 256)
\r
5203 l_rgn_size = 6 + l_comp_room;
\r
5205 l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
5207 opj_write_bytes(l_current_data,J2K_MS_RGN,2); /* RGN */
\r
5208 l_current_data += 2;
\r
5209 opj_write_bytes(l_current_data,l_rgn_size-2,2); /* Lrgn */
\r
5210 l_current_data += 2;
\r
5211 opj_write_bytes(l_current_data,p_comp_no,l_comp_room); /* Crgn */
\r
5212 l_current_data+=l_comp_room;
\r
5213 opj_write_bytes(l_current_data, 0,1); /* Srgn */
\r
5215 opj_write_bytes(l_current_data, l_tccp->roishift,1); /* SPrgn */
\r
5219 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_rgn_size,p_manager) != l_rgn_size)
\r
5227 * Reads a RGN marker (Region Of Interest)
\r
5229 * @param p_header_data the data contained in the POC box.
\r
5230 * @param p_j2k the jpeg2000 codec.
\r
5231 * @param p_header_size the size of the data contained in the POC marker.
\r
5232 * @param p_manager the user event manager.
\r
5234 bool j2k_read_rgn (
\r
5235 opj_j2k_t *p_j2k,
\r
5236 OPJ_BYTE * p_header_data,
\r
5237 OPJ_UINT32 p_header_size,
\r
5238 struct opj_event_mgr * p_manager
\r
5241 OPJ_UINT32 l_nb_comp;
\r
5242 opj_image_t * l_image = 00;
\r
5244 opj_cp_t *l_cp = 00;
\r
5245 opj_tcp_t *l_tcp = 00;
\r
5246 OPJ_UINT32 l_comp_room;
\r
5247 OPJ_UINT32 l_comp_no;
\r
5248 OPJ_UINT32 l_roi_sty;
\r
5251 assert(p_header_data != 00);
\r
5252 assert(p_j2k != 00);
\r
5253 assert(p_manager != 00);
\r
5255 l_image = p_j2k->m_image;
\r
5256 l_nb_comp = l_image->numcomps;
\r
5258 (l_nb_comp <= 256)
\r
5267 (p_header_size != 2 + l_comp_room)
\r
5269 opj_event_msg(p_manager, EVT_ERROR, "Error reading RGN marker\n");
\r
5273 l_cp = &(p_j2k->m_cp);
\r
5274 l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH) ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
5276 opj_read_bytes(p_header_data,&l_comp_no,l_comp_room); /* Crgn */
\r
5277 p_header_data+=l_comp_room;
\r
5278 opj_read_bytes(p_header_data,&l_roi_sty,1); /* Srgn */
\r
5282 if (p_j2k->m_cp->correct) {
\r
5283 /* totlen is negative or larger than the bytes left!!! */
\r
5284 if (compno >= numcomps) {
\r
5285 opj_event_msg(p_j2k->cinfo, EVT_ERROR,
\r
5286 "JPWL: bad component number in RGN (%d when there are only %d)\n",
\r
5287 compno, numcomps);
\r
5288 if (!JPWL_ASSUME || JPWL_ASSUME) {
\r
5289 opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
\r
5294 #endif /* USE_JPWL */
\r
5296 opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&(l_tcp->tccps[l_comp_no].roishift)),1); /* SPrgn */
\r
5303 * Writes the TLM marker (Tile Length Marker)
\r
5305 * @param p_stream the stream to write data to.
\r
5306 * @param p_j2k J2K codec.
\r
5307 * @param p_manager the user event manager.
\r
5309 bool j2k_write_tlm(
\r
5311 struct opj_stream_private *p_stream,
\r
5312 struct opj_event_mgr * p_manager
\r
5315 OPJ_BYTE * l_current_data = 00;
\r
5316 OPJ_UINT32 l_tlm_size;
\r
5319 assert(p_j2k != 00);
\r
5320 assert(p_manager != 00);
\r
5321 assert(p_stream != 00);
\r
5323 l_tlm_size = 6 + (5*p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
\r
5325 (l_tlm_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
\r
5327 p_j2k->m_specific_param.m_encoder.m_header_tile_data
\r
5329 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
\r
5332 (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
5336 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_tlm_size;
\r
5338 l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
\r
5340 /* change the way data is written to avoid seeking if possible */
\r
5342 p_j2k->m_specific_param.m_encoder.m_tlm_start = opj_stream_tell(p_stream);
\r
5344 opj_write_bytes(l_current_data,J2K_MS_TLM,2); /* TLM */
\r
5345 l_current_data += 2;
\r
5346 opj_write_bytes(l_current_data,l_tlm_size-2,2); /* Lpoc */
\r
5347 l_current_data += 2;
\r
5348 opj_write_bytes(l_current_data,0,1); /* Ztlm=0*/
\r
5350 opj_write_bytes(l_current_data,0x50,1); /* Stlm ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
\r
5352 /* do nothing on the 5 * l_j2k->m_specific_param.m_encoder.m_total_tile_parts remaining data */
\r
5355 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_tlm_size,p_manager) != l_tlm_size)
\r
5363 * Reads a TLM marker (Tile Length Marker)
\r
5365 * @param p_header_data the data contained in the TLM box.
\r
5366 * @param p_j2k the jpeg2000 codec.
\r
5367 * @param p_header_size the size of the data contained in the TLM marker.
\r
5368 * @param p_manager the user event manager.
\r
5370 bool j2k_read_tlm (
\r
5371 opj_j2k_t *p_j2k,
\r
5372 OPJ_BYTE * p_header_data,
\r
5373 OPJ_UINT32 p_header_size,
\r
5374 struct opj_event_mgr * p_manager
\r
5377 OPJ_UINT32 l_Ztlm, l_Stlm, l_ST, l_SP, l_tot_num_tp, l_tot_num_tp_remaining, l_quotient, l_Ptlm_size;
\r
5379 assert(p_header_data != 00);
\r
5380 assert(p_j2k != 00);
\r
5381 assert(p_manager != 00);
\r
5384 (p_header_size < 2)
\r
5386 opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n");
\r
5389 p_header_size -= 2;
\r
5392 opj_read_bytes(p_header_data,&l_Ztlm,1); /* Ztlm */
\r
5394 opj_read_bytes(p_header_data,&l_Stlm,1); /* Stlm */
\r
5397 l_ST = ((l_Stlm >> 4) & 0x3);
\r
5398 l_SP = (l_Stlm >> 6) & 0x1;
\r
5400 l_Ptlm_size = (l_SP + 1) * 2;
\r
5401 l_quotient = l_Ptlm_size + l_ST;
\r
5403 l_tot_num_tp = p_header_size / l_quotient;
\r
5404 l_tot_num_tp_remaining = p_header_size % l_quotient;
\r
5406 (l_tot_num_tp_remaining != 0)
\r
5408 opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n");
\r
5411 /* Do not care of this at the moment since only local variables are set here */
\r
5414 (i = 0; i < l_tot_num_tp; ++i)
\r
5416 opj_read_bytes(p_header_data,&l_Ttlm_i,l_ST); // Ttlm_i
\r
5417 p_header_data += l_ST;
\r
5418 opj_read_bytes(p_header_data,&l_Ptlm_i,l_Ptlm_size); // Ptlm_i
\r
5419 p_header_data += l_Ptlm_size;
\r
5425 * Reads a CRG marker (Component registration)
\r
5427 * @param p_header_data the data contained in the TLM box.
\r
5428 * @param p_j2k the jpeg2000 codec.
\r
5429 * @param p_header_size the size of the data contained in the TLM marker.
\r
5430 * @param p_manager the user event manager.
\r
5432 bool j2k_read_crg (
\r
5433 opj_j2k_t *p_j2k,
\r
5434 OPJ_BYTE * p_header_data,
\r
5435 OPJ_UINT32 p_header_size,
\r
5436 struct opj_event_mgr * p_manager
\r
5439 OPJ_UINT32 l_nb_comp;
\r
5441 assert(p_header_data != 00);
\r
5442 assert(p_j2k != 00);
\r
5443 assert(p_manager != 00);
\r
5445 l_nb_comp = p_j2k->m_image->numcomps;
\r
5448 (p_header_size != l_nb_comp *4)
\r
5450 opj_event_msg(p_manager, EVT_ERROR, "Error reading CRG marker\n");
\r
5453 /* Do not care of this at the moment since only local variables are set here */
\r
5456 (i = 0; i < l_nb_comp; ++i)
\r
5458 opj_read_bytes(p_header_data,&l_Xcrg_i,2); // Xcrg_i
\r
5460 opj_read_bytes(p_header_data,&l_Ycrg_i,2); // Xcrg_i
\r
5468 * Reads a PLM marker (Packet length, main header marker)
\r
5470 * @param p_header_data the data contained in the TLM box.
\r
5471 * @param p_j2k the jpeg2000 codec.
\r
5472 * @param p_header_size the size of the data contained in the TLM marker.
\r
5473 * @param p_manager the user event manager.
\r
5475 bool j2k_read_plm (
\r
5476 opj_j2k_t *p_j2k,
\r
5477 OPJ_BYTE * p_header_data,
\r
5478 OPJ_UINT32 p_header_size,
\r
5479 struct opj_event_mgr * p_manager
\r
5483 assert(p_header_data != 00);
\r
5484 assert(p_j2k != 00);
\r
5485 assert(p_manager != 00);
\r
5488 (p_header_size < 1)
\r
5490 opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
\r
5493 /* Do not care of this at the moment since only local variables are set here */
\r
5495 opj_read_bytes(p_header_data,&l_Zplm,1); // Zplm
\r
5500 (p_header_size > 0)
\r
5502 opj_read_bytes(p_header_data,&l_Nplm,1); // Nplm
\r
5504 p_header_size -= (1+l_Nplm);
\r
5506 (p_header_size < 0)
\r
5508 opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
\r
5512 (i = 0; i < l_Nplm; ++i)
\r
5514 opj_read_bytes(p_header_data,&l_tmp,1); // Iplm_ij
\r
5516 // take only the last seven bytes
\r
5517 l_packet_len |= (l_tmp & 0x7f);
\r
5521 l_packet_len <<= 7;
\r
5525 // store packet length and proceed to next packet
\r
5530 (l_packet_len != 0)
\r
5532 opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
\r
5541 * Reads a PLT marker (Packet length, tile-part header)
\r
5543 * @param p_header_data the data contained in the PLT box.
\r
5544 * @param p_j2k the jpeg2000 codec.
\r
5545 * @param p_header_size the size of the data contained in the PLT marker.
\r
5546 * @param p_manager the user event manager.
\r
5548 bool j2k_read_plt (
\r
5549 opj_j2k_t *p_j2k,
\r
5550 OPJ_BYTE * p_header_data,
\r
5551 OPJ_UINT32 p_header_size,
\r
5552 struct opj_event_mgr * p_manager
\r
5555 OPJ_UINT32 l_Zplt, l_tmp, l_packet_len = 0, i;
\r
5558 assert(p_header_data != 00);
\r
5559 assert(p_j2k != 00);
\r
5560 assert(p_manager != 00);
\r
5563 (p_header_size < 1)
\r
5565 opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
\r
5569 opj_read_bytes(p_header_data,&l_Zplt,1); // Zplt
\r
5573 (i = 0; i < p_header_size; ++i)
\r
5575 opj_read_bytes(p_header_data,&l_tmp,1); // Iplm_ij
\r
5577 // take only the last seven bytes
\r
5578 l_packet_len |= (l_tmp & 0x7f);
\r
5582 l_packet_len <<= 7;
\r
5586 // store packet length and proceed to next packet
\r
5591 (l_packet_len != 0)
\r
5593 opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
\r
5600 * Reads a PPM marker (Packed packet headers, main header)
\r
5602 * @param p_header_data the data contained in the POC box.
\r
5603 * @param p_j2k the jpeg2000 codec.
\r
5604 * @param p_header_size the size of the data contained in the POC marker.
\r
5605 * @param p_manager the user event manager.
\r
5607 bool j2k_read_ppm (
\r
5608 opj_j2k_t *p_j2k,
\r
5609 OPJ_BYTE * p_header_data,
\r
5610 OPJ_UINT32 p_header_size,
\r
5611 struct opj_event_mgr * p_manager
\r
5615 opj_cp_t *l_cp = 00;
\r
5616 OPJ_UINT32 l_remaining_data, l_Z_ppm, l_N_ppm;
\r
5619 assert(p_header_data != 00);
\r
5620 assert(p_j2k != 00);
\r
5621 assert(p_manager != 00);
\r
5624 (p_header_size < 1)
\r
5626 opj_event_msg(p_manager, EVT_ERROR, "Error reading RGN marker\n");
\r
5629 l_cp = &(p_j2k->m_cp);
\r
5632 opj_read_bytes(p_header_data,&l_Z_ppm,1); /* Z_ppm */
\r
5636 // first PPM marker
\r
5641 (p_header_size < 4)
\r
5643 opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
\r
5647 opj_read_bytes(p_header_data,&l_N_ppm,4); /* N_ppm */
\r
5650 /* First PPM marker */
\r
5651 l_cp->ppm_len = l_N_ppm;
\r
5652 l_cp->ppm_data_size = 0;
\r
5653 l_cp->ppm_buffer = (OPJ_BYTE *) opj_malloc(l_cp->ppm_len);
\r
5654 l_cp->ppm_data = l_cp->ppm_buffer;
\r
5656 (l_cp->ppm_buffer == 00)
\r
5658 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n");
\r
5661 memset(l_cp->ppm_buffer,0,l_cp->ppm_len);
\r
5668 (l_cp->ppm_data_size == l_cp->ppm_len)
\r
5671 (p_header_size >= 4)
\r
5674 opj_read_bytes(p_header_data,&l_N_ppm,4); /* N_ppm */
\r
5677 l_cp->ppm_len += l_N_ppm ;
\r
5678 l_cp->ppm_buffer = (OPJ_BYTE *) opj_realloc(l_cp->ppm_buffer, l_cp->ppm_len);
\r
5679 l_cp->ppm_data = l_cp->ppm_buffer;
\r
5681 (l_cp->ppm_buffer == 00)
\r
5683 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n");
\r
5686 memset(l_cp->ppm_buffer+l_cp->ppm_data_size,0,l_N_ppm);
\r
5693 l_remaining_data = l_cp->ppm_len - l_cp->ppm_data_size;
\r
5695 (l_remaining_data <= p_header_size)
\r
5697 /* we must store less information than available in the packet */
\r
5698 memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , l_remaining_data);
\r
5699 l_cp->ppm_data_size = l_cp->ppm_len;
\r
5700 p_header_size -= l_remaining_data;
\r
5701 p_header_data += l_remaining_data;
\r
5705 memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , p_header_size);
\r
5706 l_cp->ppm_data_size += p_header_size;
\r
5707 p_header_data += p_header_size;
\r
5708 p_header_size = 0;
\r
5716 * Reads a PPT marker (Packed packet headers, tile-part header)
\r
5718 * @param p_header_data the data contained in the PPT box.
\r
5719 * @param p_j2k the jpeg2000 codec.
\r
5720 * @param p_header_size the size of the data contained in the PPT marker.
\r
5721 * @param p_manager the user event manager.
\r
5723 bool j2k_read_ppt (
\r
5724 opj_j2k_t *p_j2k,
\r
5725 OPJ_BYTE * p_header_data,
\r
5726 OPJ_UINT32 p_header_size,
\r
5727 struct opj_event_mgr * p_manager
\r
5731 opj_cp_t *l_cp = 00;
\r
5732 opj_tcp_t *l_tcp = 00;
\r
5733 OPJ_UINT32 l_Z_ppt;
\r
5736 assert(p_header_data != 00);
\r
5737 assert(p_j2k != 00);
\r
5738 assert(p_manager != 00);
\r
5741 (p_header_size < 1)
\r
5743 opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker\n");
\r
5747 l_cp = &(p_j2k->m_cp);
\r
5748 l_tcp = &(l_cp->tcps[p_j2k->m_current_tile_number]);
\r
5751 opj_read_bytes(p_header_data,&l_Z_ppt,1); /* Z_ppt */
\r
5755 // first PPM marker
\r
5759 /* First PPM marker */
\r
5760 l_tcp->ppt_len = p_header_size;
\r
5761 l_tcp->ppt_data_size = 0;
\r
5762 l_tcp->ppt_buffer = (OPJ_BYTE *) opj_malloc(l_tcp->ppt_len);
\r
5763 l_tcp->ppt_data = l_tcp->ppt_buffer;
\r
5765 (l_tcp->ppt_buffer == 00)
\r
5767 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading PPT marker\n");
\r
5770 memset(l_tcp->ppt_buffer,0,l_tcp->ppt_len);
\r
5774 l_tcp->ppt_len += p_header_size;
\r
5775 l_tcp->ppt_buffer = (OPJ_BYTE *) opj_realloc(l_tcp->ppt_buffer,l_tcp->ppt_len);
\r
5777 (l_tcp->ppt_buffer == 00)
\r
5779 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading PPT marker\n");
\r
5782 l_tcp->ppt_data = l_tcp->ppt_buffer;
\r
5783 memset(l_tcp->ppt_buffer+l_tcp->ppt_data_size,0,p_header_size);
\r
5785 memcpy(l_tcp->ppt_buffer+l_tcp->ppt_data_size,p_header_data,p_header_size);
\r
5786 l_tcp->ppt_data_size += p_header_size;
\r
5791 * Writes the SOT marker (Start of tile-part)
\r
5793 * @param p_stream the stream to write data to.
\r
5794 * @param p_j2k J2K codec.
\r
5795 * @param p_manager the user event manager.
\r
5797 bool j2k_write_sot(
\r
5799 OPJ_BYTE * p_data,
\r
5800 OPJ_UINT32 * p_data_written,
\r
5801 const struct opj_stream_private *p_stream,
\r
5802 struct opj_event_mgr * p_manager
\r
5806 assert(p_j2k != 00);
\r
5807 assert(p_manager != 00);
\r
5808 assert(p_stream != 00);
\r
5810 opj_write_bytes(p_data,J2K_MS_SOT,2); /* SOT */
\r
5813 opj_write_bytes(p_data,10,2); /* Lsot */
\r
5816 opj_write_bytes(p_data, p_j2k->m_current_tile_number,2); /* Isot */
\r
5822 opj_write_bytes(p_data, p_j2k->m_specific_param.m_encoder.m_current_tile_part_number,1); /* TPsot */
\r
5825 opj_write_bytes(p_data, p_j2k->m_cp.tcps[p_j2k->m_current_tile_number].m_nb_tile_parts,1); /* TNsot */
\r
5829 /* update markers struct */
\r
5830 j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOT, p_j2k->sot_start, len + 2);
\r
5831 #endif /* USE_JPWL */
\r
5833 * p_data_written = 12;
\r
5838 * Reads a PPT marker (Packed packet headers, tile-part header)
\r
5840 * @param p_header_data the data contained in the PPT box.
\r
5841 * @param p_j2k the jpeg2000 codec.
\r
5842 * @param p_header_size the size of the data contained in the PPT marker.
\r
5843 * @param p_manager the user event manager.
\r
5845 bool j2k_read_sot (
\r
5846 opj_j2k_t *p_j2k,
\r
5847 OPJ_BYTE * p_header_data,
\r
5848 OPJ_UINT32 p_header_size,
\r
5849 struct opj_event_mgr * p_manager
\r
5853 opj_cp_t *l_cp = 00;
\r
5854 opj_tcp_t *l_tcp = 00;
\r
5855 OPJ_UINT32 l_tot_len, l_num_parts = 0;
\r
5856 OPJ_UINT32 l_current_part;
\r
5857 OPJ_UINT32 l_tile_x,l_tile_y;
\r
5860 assert(p_header_data != 00);
\r
5861 assert(p_j2k != 00);
\r
5862 assert(p_manager != 00);
\r
5865 (p_header_size != 8)
\r
5867 opj_event_msg(p_manager, EVT_ERROR, "Error reading SOT marker\n");
\r
5870 l_cp = &(p_j2k->m_cp);
\r
5871 opj_read_bytes(p_header_data,&(p_j2k->m_current_tile_number),2); /* Isot */
\r
5875 l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
\r
5876 l_tile_x = p_j2k->m_current_tile_number % l_cp->tw;
\r
5877 l_tile_y = p_j2k->m_current_tile_number / l_cp->tw;
\r
5880 if (p_j2k->m_cp->correct) {
\r
5882 static int backup_tileno = 0;
\r
5884 /* tileno is negative or larger than the number of tiles!!! */
\r
5885 if ((tileno < 0) || (tileno > (cp->tw * cp->th))) {
\r
5886 opj_event_msg(p_j2k->cinfo, EVT_ERROR,
\r
5887 "JPWL: bad tile number (%d out of a maximum of %d)\n",
\r
5888 tileno, (cp->tw * cp->th));
\r
5889 if (!JPWL_ASSUME) {
\r
5890 opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
\r
5893 /* we try to correct */
\r
5894 tileno = backup_tileno;
\r
5895 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
\r
5896 "- setting tile number to %d\n",
\r
5900 /* keep your private count of tiles */
\r
5903 #endif /* USE_JPWL */
\r
5905 /* look for the tile in the list of already processed tile (in parts). */
\r
5906 /* Optimization possible here with a more complex data structure and with the removing of tiles */
\r
5907 /* since the time taken by this function can only grow at the time */
\r
5909 opj_read_bytes(p_header_data,&l_tot_len,4); /* Psot */
\r
5913 if (p_j2k->m_cp->correct) {
\r
5915 /* totlen is negative or larger than the bytes left!!! */
\r
5916 if ((totlen < 0) || (totlen > (p_stream_numbytesleft(p_stream) + 8))) {
\r
5917 opj_event_msg(p_j2k->cinfo, EVT_ERROR,
\r
5918 "JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
\r
5919 totlen, p_stream_numbytesleft(p_stream) + 8);
\r
5920 if (!JPWL_ASSUME) {
\r
5921 opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
\r
5924 /* we try to correct */
\r
5926 opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
\r
5927 "- setting Psot to %d => assuming it is the last tile\n",
\r
5932 #endif /* USE_JPWL */
\r
5937 opj_event_msg(p_manager, EVT_ERROR, "Cannot read data with no size known, giving up\n");
\r
5941 opj_read_bytes(p_header_data,&l_current_part ,1); /* Psot */
\r
5944 opj_read_bytes(p_header_data,&l_num_parts ,1); /* Psot */
\r
5948 (l_num_parts != 0)
\r
5950 l_tcp->m_nb_tile_parts = l_num_parts;
\r
5953 (l_tcp->m_nb_tile_parts)
\r
5956 (l_tcp->m_nb_tile_parts == (l_current_part + 1))
\r
5958 p_j2k->m_specific_param.m_decoder.m_can_decode = 1;
\r
5961 p_j2k->m_specific_param.m_decoder.m_sot_length = l_tot_len - 12;
\r
5962 p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_TPH;
\r
5963 p_j2k->m_specific_param.m_decoder.m_skip_data =
\r
5964 (l_tile_x < p_j2k->m_specific_param.m_decoder.m_start_tile_x)
\r
5965 || (l_tile_x >= p_j2k->m_specific_param.m_decoder.m_end_tile_x)
\r
5966 || (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
\r
5967 || (l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
\r
5970 /* move this onto a separate method to call before reading any SOT */
\r
5973 (p_j2k->cstr_info)
\r
5981 p_j2k->cstr_info->main_head_end = p_stream_tell(p_stream) - 13;
\r
5983 p_j2k->cstr_info->tile[tileno].tileno = tileno;
\r
5984 p_j2k->cstr_info->tile[tileno].start_pos = p_stream_tell(p_stream) - 12;
\r
5985 p_j2k->cstr_info->tile[tileno].end_pos = p_j2k->cstr_info->tile[tileno].start_pos + totlen - 1;
\r
5986 p_j2k->cstr_info->tile[tileno].num_tps = numparts;
\r
5990 p_j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(numparts * sizeof(opj_tp_info_t));
\r
5994 p_j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(10 * sizeof(opj_tp_info_t)); // Fixme (10)
\r
5999 p_j2k->cstr_info->tile[tileno].end_pos += totlen;
\r
6001 p_j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos = p_stream_tell(p_stream) - 12;
\r
6002 p_j2k->cstr_info->tile[tileno].tp[partno].tp_end_pos =
\r
6003 p_j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos + totlen - 1;
\r
6009 * Writes the SOD marker (Start of data)
\r
6011 * @param p_stream the stream to write data to.
\r
6012 * @param p_j2k J2K codec.
\r
6013 * @param p_manager the user event manager.
\r
6015 bool j2k_write_sod(
\r
6017 struct opj_tcd * p_tile_coder,
\r
6018 OPJ_BYTE * p_data,
\r
6019 OPJ_UINT32 * p_data_written,
\r
6020 OPJ_UINT32 p_total_data_size,
\r
6021 const struct opj_stream_private *p_stream,
\r
6022 struct opj_event_mgr * p_manager
\r
6025 opj_tcp_t *l_tcp = 00;
\r
6026 opj_codestream_info_t *l_cstr_info = 00;
\r
6027 opj_cp_t *l_cp = 00;
\r
6029 OPJ_UINT32 l_size_tile;
\r
6030 OPJ_UINT32 l_remaining_data;
\r
6033 assert(p_j2k != 00);
\r
6034 assert(p_manager != 00);
\r
6035 assert(p_stream != 00);
\r
6037 opj_write_bytes(p_data,J2K_MS_SOD,2); /* SOD */
\r
6040 /* make room for the EOF marker */
\r
6041 l_remaining_data = p_total_data_size - 4;
\r
6043 l_cp = &(p_j2k->m_cp);
\r
6044 l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
\r
6045 l_cstr_info = p_j2k->cstr_info;
\r
6047 /* update tile coder */
\r
6048 p_tile_coder->tp_num = p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number ;
\r
6049 p_tile_coder->cur_tp_num = p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
\r
6050 l_size_tile = l_cp->th * l_cp->tw;
\r
6057 (!p_j2k->m_specific_param.m_encoder.m_current_tile_part_number )
\r
6059 //TODO cstr_info->tile[p_j2k->m_current_tile_number].end_header = p_stream_tell(p_stream) + p_j2k->pos_correction - 1;
\r
6060 l_cstr_info->tile[p_j2k->m_current_tile_number].tileno = p_j2k->m_current_tile_number;
\r
6067 (cstr_info->tile[p_j2k->m_current_tile_number].packet[cstr_info->packno - 1].end_pos < p_stream_tell(p_stream))
\r
6069 cstr_info->tile[p_j2k->m_current_tile_number].packet[cstr_info->packno].start_pos = p_stream_tell(p_stream);
\r
6075 /* update markers struct */
\r
6076 j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOD, p_j2k->sod_start, 2);
\r
6077 #endif /* USE_JPWL */
\r
6083 (p_j2k->m_specific_param.m_encoder.m_current_tile_part_number == 0)
\r
6085 p_tile_coder->tcd_image->tiles->packno = 0;
\r
6089 l_cstr_info->packno = 0;
\r
6092 *p_data_written = 0;
\r
6094 (! tcd_encode_tile(p_tile_coder, p_j2k->m_current_tile_number, p_data, p_data_written, l_remaining_data , l_cstr_info))
\r
6096 opj_event_msg(p_manager, EVT_ERROR, "Cannot encode tile\n");
\r
6099 *p_data_written += 2;
\r
6104 * Updates the Tile Length Marker.
\r
6106 void j2k_update_tlm (
\r
6107 opj_j2k_t * p_j2k,
\r
6108 OPJ_UINT32 p_tile_part_size
\r
6111 opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,p_j2k->m_current_tile_number,1); /* PSOT */
\r
6112 ++p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current;
\r
6113 opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,p_tile_part_size,4); /* PSOT */
\r
6114 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current += 4;
\r
6119 * Reads a SOD marker (Start Of Data)
\r
6121 * @param p_header_data the data contained in the SOD box.
\r
6122 * @param p_j2k the jpeg2000 codec.
\r
6123 * @param p_header_size the size of the data contained in the SOD marker.
\r
6124 * @param p_manager the user event manager.
\r
6126 bool j2k_read_sod (
\r
6127 opj_j2k_t *p_j2k,
\r
6128 struct opj_stream_private *p_stream,
\r
6129 struct opj_event_mgr * p_manager
\r
6132 OPJ_UINT32 l_current_read_size;
\r
6133 opj_codestream_info_t * l_cstr_info = 00;
\r
6134 OPJ_BYTE ** l_current_data = 00;
\r
6135 opj_tcp_t * l_tcp = 00;
\r
6136 OPJ_UINT32 * l_tile_len = 00;
\r
6139 assert(p_j2k != 00);
\r
6140 assert(p_manager != 00);
\r
6141 assert(p_stream != 00);
\r
6143 l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
\r
6144 p_j2k->m_specific_param.m_decoder.m_sot_length -= 2;
\r
6145 l_cstr_info = p_j2k->cstr_info;
\r
6147 l_current_data = &(l_tcp->m_data);
\r
6148 l_tile_len = &l_tcp->m_data_size;
\r
6151 (! *l_current_data)
\r
6153 *l_current_data = (OPJ_BYTE*) my_opj_malloc(p_j2k->m_specific_param.m_decoder.m_sot_length);
\r
6157 *l_current_data = (OPJ_BYTE*) my_opj_realloc(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length);
\r
6160 (*l_current_data == 00)
\r
6162 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile\n");
\r
6170 OPJ_SIZE_T l_current_pos = opj_stream_tell(p_stream)-1;
\r
6171 l_cstr_info->tile[p_j2k->m_current_tile_number].tp[p_j2k->m_specific_param.m_encoder.m_current_tile_part_number].tp_end_header = l_current_pos;
\r
6173 (p_j2k->m_specific_param.m_encoder.m_current_tile_part_number == 0)
\r
6175 l_cstr_info->tile[p_j2k->m_current_tile_number].end_header = l_current_pos;
\r
6177 l_cstr_info->packno = 0;
\r
6179 l_current_read_size = opj_stream_read_data(p_stream, *l_current_data + *l_tile_len , p_j2k->m_specific_param.m_decoder.m_sot_length,p_manager);
\r
6181 (l_current_read_size != p_j2k->m_specific_param.m_decoder.m_sot_length)
\r
6183 p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_NEOC;
\r
6187 p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_TPHSOT;
\r
6189 *l_tile_len += l_current_read_size;
\r
6194 * Writes the EOC marker (End of Codestream)
\r
6196 * @param p_stream the stream to write data to.
\r
6197 * @param p_j2k J2K codec.
\r
6198 * @param p_manager the user event manager.
\r
6200 bool j2k_write_eoc(
\r
6202 struct opj_stream_private *p_stream,
\r
6203 struct opj_event_mgr * p_manager
\r
6207 assert(p_j2k != 00);
\r
6208 assert(p_manager != 00);
\r
6209 assert(p_stream != 00);
\r
6211 opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_header_tile_data,J2K_MS_EOC,2); /* EOC */
\r
6216 /* update markers struct */
\r
6217 j2k_add_marker(p_j2k->cstr_info, J2K_MS_EOC, p_stream_tell(p_stream) - 2, 2);
\r
6218 #endif /* USE_JPWL */
\r
6221 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,2,p_manager) != 2)
\r
6226 (! opj_stream_flush(p_stream,p_manager))
\r
6237 * @param p_stream the stream to write data to.
\r
6238 * @param p_j2k J2K codec.
\r
6239 * @param p_manager the user event manager.
\r
6241 bool j2k_init_info(
\r
6243 struct opj_stream_private *p_stream,
\r
6244 struct opj_event_mgr * p_manager
\r
6247 opj_codestream_info_t * l_cstr_info = 00;
\r
6250 assert(p_j2k != 00);
\r
6251 assert(p_manager != 00);
\r
6252 assert(p_stream != 00);
\r
6253 l_cstr_info = p_j2k->cstr_info;
\r
6258 OPJ_UINT32 compno;
\r
6259 l_cstr_info->tile = (opj_tile_info_t *) opj_malloc(p_j2k->m_cp.tw * p_j2k->m_cp.th * sizeof(opj_tile_info_t));
\r
6260 l_cstr_info->image_w = p_j2k->m_image->x1 - p_j2k->m_image->x0;
\r
6261 l_cstr_info->image_h = p_j2k->m_image->y1 - p_j2k->m_image->y0;
\r
6262 l_cstr_info->prog = (&p_j2k->m_cp.tcps[0])->prg;
\r
6263 l_cstr_info->tw = p_j2k->m_cp.tw;
\r
6264 l_cstr_info->th = p_j2k->m_cp.th;
\r
6265 l_cstr_info->tile_x = p_j2k->m_cp.tdx; /* new version parser */
\r
6266 l_cstr_info->tile_y = p_j2k->m_cp.tdy; /* new version parser */
\r
6267 l_cstr_info->tile_Ox = p_j2k->m_cp.tx0; /* new version parser */
\r
6268 l_cstr_info->tile_Oy = p_j2k->m_cp.ty0; /* new version parser */
\r
6269 l_cstr_info->numcomps = p_j2k->m_image->numcomps;
\r
6270 l_cstr_info->numlayers = (&p_j2k->m_cp.tcps[0])->numlayers;
\r
6271 l_cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(p_j2k->m_image->numcomps * sizeof(OPJ_INT32));
\r
6272 for (compno=0; compno < p_j2k->m_image->numcomps; compno++) {
\r
6273 l_cstr_info->numdecompos[compno] = (&p_j2k->m_cp.tcps[0])->tccps->numresolutions - 1;
\r
6275 l_cstr_info->D_max = 0.0; /* ADD Marcela */
\r
6276 l_cstr_info->main_head_start = opj_stream_tell(p_stream); /* position of SOC */
\r
6277 l_cstr_info->maxmarknum = 100;
\r
6278 l_cstr_info->marker = (opj_marker_info_t *) opj_malloc(l_cstr_info->maxmarknum * sizeof(opj_marker_info_t));
\r
6279 l_cstr_info->marknum = 0;
\r
6281 return j2k_calculate_tp(p_j2k,&(p_j2k->m_cp),&p_j2k->m_specific_param.m_encoder.m_total_tile_parts,p_j2k->m_image,p_manager);
\r
6285 * Creates a tile-coder decoder.
\r
6287 * @param p_stream the stream to write data to.
\r
6288 * @param p_j2k J2K codec.
\r
6289 * @param p_manager the user event manager.
\r
6291 bool j2k_create_tcd(
\r
6293 struct opj_stream_private *p_stream,
\r
6294 struct opj_event_mgr * p_manager
\r
6298 assert(p_j2k != 00);
\r
6299 assert(p_manager != 00);
\r
6300 assert(p_stream != 00);
\r
6302 p_j2k->m_tcd = tcd_create(false);
\r
6306 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to create Tile Coder\n");
\r
6310 (! tcd_init(p_j2k->m_tcd,p_j2k->m_image,&p_j2k->m_cp))
\r
6312 tcd_destroy(p_j2k->m_tcd);
\r
6313 p_j2k->m_tcd = 00;
\r
6319 OPJ_FLOAT32 get_tp_stride (opj_tcp_t * p_tcp)
\r
6321 return (OPJ_FLOAT32) ((p_tcp->m_nb_tile_parts - 1) * 14);
\r
6324 OPJ_FLOAT32 get_default_stride (opj_tcp_t * p_tcp)
\r
6330 * Updates the rates of the tcp.
\r
6332 * @param p_stream the stream to write data to.
\r
6333 * @param p_j2k J2K codec.
\r
6334 * @param p_manager the user event manager.
\r
6336 bool j2k_update_rates(
\r
6338 struct opj_stream_private *p_stream,
\r
6339 struct opj_event_mgr * p_manager
\r
6342 opj_cp_t * l_cp = 00;
\r
6343 opj_image_t * l_image = 00;
\r
6344 opj_tcp_t * l_tcp = 00;
\r
6345 opj_image_comp_t * l_img_comp = 00;
\r
6348 OPJ_INT32 l_x0,l_y0,l_x1,l_y1;
\r
6349 OPJ_FLOAT32 * l_rates = 0;
\r
6350 OPJ_FLOAT32 l_sot_remove;
\r
6351 OPJ_UINT32 l_bits_empty, l_size_pixel;
\r
6352 OPJ_UINT32 l_tile_size = 0;
\r
6353 OPJ_UINT32 l_last_res;
\r
6354 OPJ_FLOAT32 (* l_tp_stride_func)(opj_tcp_t *) = 00;
\r
6357 assert(p_j2k != 00);
\r
6358 assert(p_manager != 00);
\r
6359 assert(p_stream != 00);
\r
6362 l_cp = &(p_j2k->m_cp);
\r
6363 l_image = p_j2k->m_image;
\r
6364 l_tcp = l_cp->tcps;
\r
6366 l_bits_empty = 8 * l_image->comps->dx * l_image->comps->dy;
\r
6367 l_size_pixel = l_image->numcomps * l_image->comps->prec;
\r
6368 l_sot_remove = ((OPJ_FLOAT32) opj_stream_tell(p_stream)) / (l_cp->th * l_cp->tw);
\r
6371 (l_cp->m_specific_param.m_enc.m_tp_on)
\r
6373 l_tp_stride_func = get_tp_stride;
\r
6377 l_tp_stride_func = get_default_stride;
\r
6381 (i=0;i<l_cp->th;++i)
\r
6384 (j=0;j<l_cp->tw;++j)
\r
6386 OPJ_FLOAT32 l_offset = ((*l_tp_stride_func)(l_tcp)) / l_tcp->numlayers;
\r
6387 /* 4 borders of the tile rescale on the image if necessary */
\r
6388 l_x0 = int_max(l_cp->tx0 + j * l_cp->tdx, l_image->x0);
\r
6389 l_y0 = int_max(l_cp->ty0 + i * l_cp->tdy, l_image->y0);
\r
6390 l_x1 = int_min(l_cp->tx0 + (j + 1) * l_cp->tdx, l_image->x1);
\r
6391 l_y1 = int_min(l_cp->ty0 + (i + 1) * l_cp->tdy, l_image->y1);
\r
6392 l_rates = l_tcp->rates;
\r
6394 /* Modification of the RATE >> */
\r
6398 *l_rates = (( (float) (l_size_pixel * (l_x1 - l_x0) * (l_y1 - l_y0)))
\r
6400 ((*l_rates) * l_bits_empty)
\r
6407 (k = 1; k < l_tcp->numlayers; ++k)
\r
6412 *l_rates = (( (OPJ_FLOAT32) (l_size_pixel * (l_x1 - l_x0) * (l_y1 - l_y0)))
\r
6414 ((*l_rates) * l_bits_empty)
\r
6425 l_tcp = l_cp->tcps;
\r
6427 (i=0;i<l_cp->th;++i)
\r
6430 (j=0;j<l_cp->tw;++j)
\r
6432 l_rates = l_tcp->rates;
\r
6436 *l_rates -= l_sot_remove;
\r
6444 l_last_res = l_tcp->numlayers - 1;
\r
6446 (k = 1; k < l_last_res; ++k)
\r
6451 *l_rates -= l_sot_remove;
\r
6453 (*l_rates < *(l_rates - 1) + 10)
\r
6455 *l_rates = (*(l_rates - 1)) + 20;
\r
6463 *l_rates -= (l_sot_remove + 2.f);
\r
6465 (*l_rates < *(l_rates - 1) + 10)
\r
6467 *l_rates = (*(l_rates - 1)) + 20;
\r
6474 l_img_comp = l_image->comps;
\r
6477 (i=0;i<l_image->numcomps;++i)
\r
6479 l_tile_size += ( uint_ceildiv(l_cp->tdx,l_img_comp->dx)
\r
6481 uint_ceildiv(l_cp->tdy,l_img_comp->dy)
\r
6488 l_tile_size = (OPJ_UINT32) (l_tile_size * 0.1625); /* 1.3/8 = 0.1625 */
\r
6489 l_tile_size += j2k_get_specific_header_sizes(p_j2k);
\r
6491 p_j2k->m_specific_param.m_encoder.m_encoded_tile_size = l_tile_size;
\r
6492 p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = (OPJ_BYTE *) my_opj_malloc(p_j2k->m_specific_param.m_encoder.m_encoded_tile_size);
\r
6494 (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data == 00)
\r
6499 (l_cp->m_specific_param.m_enc.m_cinema)
\r
6501 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = (OPJ_BYTE *) opj_malloc(5*p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
\r
6503 (! p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer)
\r
6507 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer;
\r
6513 * Reads a EOC marker (End Of Codestream)
\r
6515 * @param p_header_data the data contained in the SOD box.
\r
6516 * @param p_j2k the jpeg2000 codec.
\r
6517 * @param p_header_size the size of the data contained in the SOD marker.
\r
6518 * @param p_manager the user event manager.
\r
6520 bool j2k_read_eoc (
\r
6521 opj_j2k_t *p_j2k,
\r
6522 struct opj_stream_private *p_stream,
\r
6523 struct opj_event_mgr * p_manager
\r
6527 opj_tcd_t * l_tcd = 00;
\r
6528 OPJ_UINT32 l_nb_tiles;
\r
6529 opj_tcp_t * l_tcp = 00;
\r
6533 assert(p_j2k != 00);
\r
6534 assert(p_manager != 00);
\r
6535 assert(p_stream != 00);
\r
6537 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
\r
6538 l_tcp = p_j2k->m_cp.tcps;
\r
6540 l_tcd = tcd_create(true);
\r
6544 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
\r
6551 (i = 0; i < l_nb_tiles; ++i)
\r
6557 (! tcd_init_decode_tile(l_tcd, i))
\r
6559 tcd_destroy(l_tcd);
\r
6560 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
\r
6563 l_success = tcd_decode_tile(l_tcd, l_tcp->m_data, l_tcp->m_data_size, i, p_j2k->cstr_info);
\r
6568 p_j2k->m_specific_param.m_decoder.m_state |= J2K_DEC_STATE_ERR;
\r
6572 j2k_tcp_destroy(l_tcp);
\r
6575 tcd_destroy(l_tcd);
\r
6580 * Writes the image components.
\r
6582 * @param p_stream the stream to write data to.
\r
6583 * @param p_j2k J2K codec.
\r
6584 * @param p_manager the user event manager.
\r
6586 bool j2k_write_image_components(
\r
6588 struct opj_stream_private *p_stream,
\r
6589 struct opj_event_mgr * p_manager
\r
6592 OPJ_UINT32 compno;
\r
6594 assert(p_j2k != 00);
\r
6595 assert(p_manager != 00);
\r
6596 assert(p_stream != 00);
\r
6599 (compno = 1; compno < p_j2k->m_image->numcomps; ++compno)
\r
6602 (! j2k_write_coc(p_j2k,compno,p_stream, p_manager))
\r
6607 (! j2k_write_qcc(p_j2k,compno,p_stream, p_manager))
\r
6616 * Writes regions of interests.
\r
6618 * @param p_stream the stream to write data to.
\r
6619 * @param p_j2k J2K codec.
\r
6620 * @param p_manager the user event manager.
\r
6622 bool j2k_write_regions(
\r
6624 struct opj_stream_private *p_stream,
\r
6625 struct opj_event_mgr * p_manager
\r
6628 OPJ_UINT32 compno;
\r
6629 const opj_tccp_t *l_tccp = 00;
\r
6631 assert(p_j2k != 00);
\r
6632 assert(p_manager != 00);
\r
6633 assert(p_stream != 00);
\r
6635 l_tccp = p_j2k->m_cp.tcps->tccps;
\r
6637 (compno = 0; compno < p_j2k->m_image->numcomps; ++compno)
\r
6640 (l_tccp->roishift)
\r
6643 (! j2k_write_rgn(p_j2k,0,compno,p_stream,p_manager))
\r
6653 * Writes the updated tlm.
\r
6655 * @param p_stream the stream to write data to.
\r
6656 * @param p_j2k J2K codec.
\r
6657 * @param p_manager the user event manager.
\r
6659 bool j2k_write_updated_tlm(
\r
6661 struct opj_stream_private *p_stream,
\r
6662 struct opj_event_mgr * p_manager
\r
6665 OPJ_UINT32 l_tlm_size;
\r
6666 OPJ_SIZE_T l_tlm_position, l_current_position;
\r
6669 assert(p_j2k != 00);
\r
6670 assert(p_manager != 00);
\r
6671 assert(p_stream != 00);
\r
6673 l_tlm_size = 5 * p_j2k->m_specific_param.m_encoder.m_total_tile_parts;
\r
6674 l_tlm_position = 6 + p_j2k->m_specific_param.m_encoder.m_tlm_start;
\r
6675 l_current_position = opj_stream_tell(p_stream);
\r
6678 (! opj_stream_seek(p_stream,l_tlm_position,p_manager))
\r
6683 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer,l_tlm_size,p_manager) != l_tlm_size)
\r
6688 (! opj_stream_seek(p_stream,l_current_position,p_manager))
\r
6696 * Ends the encoding, i.e. frees memory.
\r
6698 * @param p_stream the stream to write data to.
\r
6699 * @param p_j2k J2K codec.
\r
6700 * @param p_manager the user event manager.
\r
6702 bool j2k_end_encoding(
\r
6704 struct opj_stream_private *p_stream,
\r
6705 struct opj_event_mgr * p_manager
\r
6709 assert(p_j2k != 00);
\r
6710 assert(p_manager != 00);
\r
6711 assert(p_stream != 00);
\r
6713 tcd_destroy(p_j2k->m_tcd);
\r
6714 p_j2k->m_tcd = 00;
\r
6717 (p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer)
\r
6719 opj_free(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer);
\r
6720 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = 0;
\r
6721 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = 0;
\r
6724 (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data)
\r
6726 opj_free(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
\r
6727 p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = 0;
\r
6729 p_j2k->m_specific_param.m_encoder.m_encoded_tile_size = 0;
\r
6735 * Gets the offset of the header.
\r
6737 * @param p_stream the stream to write data to.
\r
6738 * @param p_j2k J2K codec.
\r
6739 * @param p_manager the user event manager.
\r
6741 bool j2k_get_end_header(
\r
6743 struct opj_stream_private *p_stream,
\r
6744 struct opj_event_mgr * p_manager
\r
6748 assert(p_j2k != 00);
\r
6749 assert(p_manager != 00);
\r
6750 assert(p_stream != 00);
\r
6752 p_j2k->cstr_info->main_head_end = opj_stream_tell(p_stream);
\r
6760 * Reads an unknown marker
\r
6762 * @param p_stream the stream object to read from.
\r
6763 * @param p_j2k the jpeg2000 codec.
\r
6764 * @param p_manager the user event manager.
\r
6766 * @return true if the marker could be deduced.
\r
6768 bool j2k_read_unk (
\r
6769 opj_j2k_t *p_j2k,
\r
6770 struct opj_stream_private *p_stream,
\r
6771 struct opj_event_mgr * p_manager
\r
6774 OPJ_BYTE l_data [2];
\r
6775 OPJ_UINT32 l_unknown_size;
\r
6777 assert(p_j2k != 00);
\r
6778 assert(p_manager != 00);
\r
6779 assert(p_stream != 00);
\r
6781 opj_event_msg(p_manager, EVT_WARNING, "Unknown marker\n");
\r
6784 if (p_j2k->m_cp->correct) {
\r
6785 OPJ_INT32 m = 0, id, i;
\r
6786 OPJ_INT32 min_id = 0, min_dist = 17, cur_dist = 0, tmp_id;
\r
6787 p_stream_seek(p_j2k->p_stream, p_stream_tell(p_j2k->p_stream) - 2);
\r
6788 id = p_stream_read(p_j2k->p_stream, 2);
\r
6789 opj_event_msg(p_j2k->cinfo, EVT_ERROR,
\r
6790 "JPWL: really don't know this marker %x\n",
\r
6792 if (!JPWL_ASSUME) {
\r
6793 opj_event_msg(p_j2k->cinfo, EVT_ERROR,
\r
6794 "- possible synch loss due to uncorrectable codestream errors => giving up\n");
\r
6797 /* OK, activate this at your own risk!!! */
\r
6798 /* we look for the marker at the minimum hamming distance from this */
\r
6799 while (j2k_dec_mstab[m].id) {
\r
6801 /* 1's where they differ */
\r
6802 tmp_id = j2k_dec_mstab[m].id ^ id;
\r
6804 /* compute the hamming distance between our id and the current */
\r
6806 for (i = 0; i < 16; i++) {
\r
6807 if ((tmp_id >> i) & 0x0001) {
\r
6812 /* if current distance is smaller, set the minimum */
\r
6813 if (cur_dist < min_dist) {
\r
6814 min_dist = cur_dist;
\r
6815 min_id = j2k_dec_mstab[m].id;
\r
6818 /* jump to the next marker */
\r
6822 /* do we substitute the marker? */
\r
6823 if (min_dist < JPWL_MAXIMUM_HAMMING) {
\r
6824 opj_event_msg(p_j2k->cinfo, EVT_ERROR,
\r
6825 "- marker %x is at distance %d from the read %x\n",
\r
6826 min_id, min_dist, id);
\r
6827 opj_event_msg(p_j2k->cinfo, EVT_ERROR,
\r
6828 "- trying to substitute in place and crossing fingers!\n");
\r
6829 p_stream_seek(p_j2k->p_stream, p_stream_tell(p_j2k->p_stream) - 2);
\r
6830 p_stream_write(p_j2k->p_stream, min_id, 2);
\r
6833 p_stream_seek(p_j2k->p_stream, p_stream_tell(p_j2k->p_stream) - 2);
\r
6838 #endif /* USE_JPWL */
\r
6840 (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2)
\r
6842 opj_event_msg(p_manager, EVT_WARNING, "Unknown marker\n");
\r
6845 opj_read_bytes(l_data,&l_unknown_size,2);
\r
6847 (l_unknown_size < 2)
\r
6851 l_unknown_size-=2;
\r
6854 (opj_stream_skip(p_stream,l_unknown_size,p_manager) != l_unknown_size)
\r
6862 * Reads the lookup table containing all the marker, status and action, and returns the handler associated
\r
6863 * with the marker value.
\r
6864 * @param p_id Marker value to look up
\r
6866 * @return the handler associated with the id.
\r
6868 const opj_dec_memory_marker_handler_t * j2k_get_marker_handler (OPJ_UINT32 p_id)
\r
6870 const opj_dec_memory_marker_handler_t *e;
\r
6872 (e = j2k_memory_marker_handler_tab; e->id != 0; ++e)
\r
6884 * Destroys a tile coding parameter structure.
\r
6886 * @param p_tcp the tile coding parameter to destroy.
\r
6888 void j2k_tcp_destroy (opj_tcp_t *p_tcp)
\r
6896 (p_tcp->ppt_buffer != 00)
\r
6898 opj_free(p_tcp->ppt_buffer);
\r
6899 p_tcp->ppt_buffer = 00;
\r
6902 (p_tcp->tccps != 00)
\r
6904 opj_free(p_tcp->tccps);
\r
6905 p_tcp->tccps = 00;
\r
6908 (p_tcp->m_mct_coding_matrix != 00)
\r
6910 opj_free(p_tcp->m_mct_coding_matrix);
\r
6911 p_tcp->m_mct_coding_matrix = 00;
\r
6914 (p_tcp->m_mct_decoding_matrix != 00)
\r
6916 opj_free(p_tcp->m_mct_decoding_matrix);
\r
6917 p_tcp->m_mct_decoding_matrix = 00;
\r
6920 (p_tcp->m_mcc_records)
\r
6922 opj_free(p_tcp->m_mcc_records);
\r
6923 p_tcp->m_mcc_records = 00;
\r
6924 p_tcp->m_nb_max_mcc_records = 0;
\r
6925 p_tcp->m_nb_mcc_records = 0;
\r
6928 (p_tcp->m_mct_records)
\r
6930 opj_mct_data_t * l_mct_data = p_tcp->m_mct_records;
\r
6933 (i=0;i<p_tcp->m_nb_mct_records;++i)
\r
6936 (l_mct_data->m_data)
\r
6938 opj_free(l_mct_data->m_data);
\r
6939 l_mct_data->m_data = 00;
\r
6943 opj_free(p_tcp->m_mct_records);
\r
6944 p_tcp->m_mct_records = 00;
\r
6948 (p_tcp->mct_norms != 00)
\r
6950 opj_free(p_tcp->mct_norms);
\r
6951 p_tcp->mct_norms = 00;
\r
6956 opj_free(p_tcp->m_data);
\r
6957 p_tcp->m_data = 00;
\r
6962 * Destroys a coding parameter structure.
\r
6964 * @param p_cp the coding parameter to destroy.
\r
6966 void j2k_cp_destroy (opj_cp_t *p_cp)
\r
6968 OPJ_UINT32 l_nb_tiles;
\r
6969 opj_tcp_t * l_current_tile = 00;
\r
6978 (p_cp->tcps != 00)
\r
6980 l_current_tile = p_cp->tcps;
\r
6981 l_nb_tiles = p_cp->th * p_cp->tw;
\r
6984 (i = 0; i < l_nb_tiles; ++i)
\r
6986 j2k_tcp_destroy(l_current_tile);
\r
6989 opj_free(p_cp->tcps);
\r
6993 (p_cp->ppm_buffer != 00)
\r
6995 opj_free(p_cp->ppm_buffer);
\r
6996 p_cp->ppm_buffer = 00;
\r
6999 (p_cp->comment != 00)
\r
7001 opj_free(p_cp->comment);
\r
7002 p_cp->comment = 00;
\r
7005 (! p_cp->m_is_decoder)
\r
7008 (p_cp->m_specific_param.m_enc.m_matrice)
\r
7010 opj_free(p_cp->m_specific_param.m_enc.m_matrice);
\r
7011 p_cp->m_specific_param.m_enc.m_matrice = 00;
\r
7016 /* ----------------------------------------------------------------------- */
\r
7017 /* J2K / JPT decoder interface */
\r
7018 /* ----------------------------------------------------------------------- */
\r
7020 * Creates a J2K decompression structure.
\r
7022 * @return a handle to a J2K decompressor if successful, NULL otherwise.
\r
7024 opj_j2k_t* j2k_create_decompress()
\r
7026 opj_j2k_t *l_j2k = (opj_j2k_t*) opj_malloc(sizeof(opj_j2k_t));
\r
7032 memset(l_j2k,0,sizeof(opj_j2k_t));
\r
7033 l_j2k->m_is_decoder = 1;
\r
7034 l_j2k->m_cp.m_is_decoder = 1;
\r
7035 l_j2k->m_specific_param.m_decoder.m_default_tcp = (opj_tcp_t*) opj_malloc(sizeof(opj_tcp_t));
\r
7037 (!l_j2k->m_specific_param.m_decoder.m_default_tcp)
\r
7042 memset(l_j2k->m_specific_param.m_decoder.m_default_tcp,0,sizeof(opj_tcp_t));
\r
7044 l_j2k->m_specific_param.m_decoder.m_header_data = (OPJ_BYTE *) opj_malloc(J2K_DEFAULT_HEADER_SIZE);
\r
7046 (! l_j2k->m_specific_param.m_decoder.m_header_data)
\r
7048 j2k_destroy(l_j2k);
\r
7051 l_j2k->m_specific_param.m_decoder.m_header_data_size = J2K_DEFAULT_HEADER_SIZE;
\r
7053 // validation list creation
\r
7054 l_j2k->m_validation_list = opj_procedure_list_create();
\r
7056 (! l_j2k->m_validation_list)
\r
7058 j2k_destroy(l_j2k);
\r
7062 // execution list creation
\r
7063 l_j2k->m_procedure_list = opj_procedure_list_create();
\r
7065 (! l_j2k->m_procedure_list)
\r
7067 j2k_destroy(l_j2k);
\r
7073 opj_j2k_t* j2k_create_compress()
\r
7075 opj_j2k_t *l_j2k = (opj_j2k_t*) opj_malloc(sizeof(opj_j2k_t));
\r
7081 memset(l_j2k,0,sizeof(opj_j2k_t));
\r
7082 l_j2k->m_is_decoder = 0;
\r
7083 l_j2k->m_cp.m_is_decoder = 0;
\r
7085 l_j2k->m_specific_param.m_encoder.m_header_tile_data = (OPJ_BYTE *) opj_malloc(J2K_DEFAULT_HEADER_SIZE);
\r
7087 (! l_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
7089 j2k_destroy(l_j2k);
\r
7092 l_j2k->m_specific_param.m_encoder.m_header_tile_data_size = J2K_DEFAULT_HEADER_SIZE;
\r
7094 // validation list creation
\r
7095 l_j2k->m_validation_list = opj_procedure_list_create();
\r
7097 (! l_j2k->m_validation_list)
\r
7099 j2k_destroy(l_j2k);
\r
7103 // execution list creation
\r
7104 l_j2k->m_procedure_list = opj_procedure_list_create();
\r
7106 (! l_j2k->m_procedure_list)
\r
7108 j2k_destroy(l_j2k);
\r
7116 * Destroys a jpeg2000 codec.
\r
7118 * @param p_j2k the jpeg20000 structure to destroy.
\r
7120 void j2k_destroy (opj_j2k_t *p_j2k)
\r
7129 (p_j2k->m_is_decoder)
\r
7132 (p_j2k->m_specific_param.m_decoder.m_default_tcp != 00)
\r
7134 j2k_tcp_destroy(p_j2k->m_specific_param.m_decoder.m_default_tcp);
\r
7135 opj_free(p_j2k->m_specific_param.m_decoder.m_default_tcp);
\r
7136 p_j2k->m_specific_param.m_decoder.m_default_tcp = 00;
\r
7139 (p_j2k->m_specific_param.m_decoder.m_header_data != 00)
\r
7141 opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
\r
7142 p_j2k->m_specific_param.m_decoder.m_header_data = 00;
\r
7143 p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
\r
7150 (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data)
\r
7152 opj_free(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
\r
7153 p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = 00;
\r
7156 (p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer)
\r
7158 opj_free(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer);
\r
7159 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = 00;
\r
7160 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = 00;
\r
7163 (p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
7165 opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
\r
7166 p_j2k->m_specific_param.m_encoder.m_header_tile_data = 00;
\r
7167 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
\r
7170 tcd_destroy(p_j2k->m_tcd);
\r
7172 j2k_cp_destroy(&(p_j2k->m_cp));
\r
7173 memset(&(p_j2k->m_cp),0,sizeof(opj_cp_t));
\r
7175 opj_procedure_list_destroy(p_j2k->m_procedure_list);
\r
7176 p_j2k->m_procedure_list = 00;
\r
7178 opj_procedure_list_destroy(p_j2k->m_validation_list);
\r
7179 p_j2k->m_procedure_list = 00;
\r
7185 * Starts a compression scheme, i.e. validates the codec parameters, writes the header.
\r
7187 * @param p_j2k the jpeg2000 codec.
\r
7188 * @param p_stream the stream object.
\r
7189 * @param p_manager the user event manager.
\r
7191 * @return true if the codec is valid.
\r
7193 bool j2k_start_compress(
\r
7194 opj_j2k_t *p_j2k,
\r
7195 opj_stream_private_t *p_stream,
\r
7196 opj_image_t * p_image,
\r
7197 opj_event_mgr_t * p_manager)
\r
7200 assert(p_j2k != 00);
\r
7201 assert(p_stream != 00);
\r
7202 assert(p_manager != 00);
\r
7203 p_j2k->m_image = p_image;
\r
7206 /* customization of the validation */
\r
7207 j2k_setup_encoding_validation (p_j2k);
\r
7209 /* validation of the parameters codec */
\r
7211 (! j2k_exec(p_j2k,p_j2k->m_validation_list,p_stream,p_manager))
\r
7216 /* customization of the encoding */
\r
7217 j2k_setup_header_writting(p_j2k);
\r
7219 /* write header */
\r
7221 (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager))
\r
7228 * Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures.
\r
7230 void j2k_setup_header_reading (opj_j2k_t *p_j2k)
\r
7233 assert(p_j2k != 00);
\r
7234 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_read_header_procedure);
\r
7236 /* DEVELOPER CORNER, add your custom procedures */
\r
7237 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_copy_default_tcp_and_create_tcd);
\r
7242 * Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures.
\r
7244 void j2k_setup_decoding (opj_j2k_t *p_j2k)
\r
7247 assert(p_j2k != 00);
\r
7249 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_decode_tiles);
\r
7250 /* DEVELOPER CORNER, add your custom procedures */
\r
7255 * Sets up the procedures to do on writting header. Developpers wanting to extend the library can add their own writting procedures.
\r
7257 void j2k_setup_header_writting (opj_j2k_t *p_j2k)
\r
7260 assert(p_j2k != 00);
\r
7261 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_init_info );
\r
7262 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_soc );
\r
7263 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_siz );
\r
7264 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_cod );
\r
7265 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_qcd );
\r
7269 (p_j2k->m_cp.m_specific_param.m_enc.m_cinema)
\r
7271 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_image_components );
\r
7272 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_tlm );
\r
7274 (p_j2k->m_cp.m_specific_param.m_enc.m_cinema == CINEMA4K_24)
\r
7276 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_poc );
\r
7279 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_regions);
\r
7282 (p_j2k->m_cp.comment != 00)
\r
7284 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_com);
\r
7287 /* DEVELOPER CORNER, insert your custom procedures */
\r
7289 (p_j2k->m_cp.rsiz & MCT)
\r
7291 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_mct_data_group );
\r
7293 /* End of Developer Corner */
\r
7296 (p_j2k->cstr_info)
\r
7298 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_get_end_header );
\r
7300 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_create_tcd);
\r
7301 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_update_rates);
\r
7305 * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
\r
7306 * are valid. Developpers wanting to extend the library can add their own validation procedures.
\r
7308 void j2k_setup_end_compress (opj_j2k_t *p_j2k)
\r
7311 assert(p_j2k != 00);
\r
7313 /* DEVELOPER CORNER, insert your custom procedures */
\r
7314 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_eoc );
\r
7316 (p_j2k->m_cp.m_specific_param.m_enc.m_cinema)
\r
7318 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_updated_tlm);
\r
7320 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_epc );
\r
7321 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_end_encoding );
\r
7322 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_destroy_header_memory);
\r
7328 * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
\r
7329 * are valid. Developpers wanting to extend the library can add their own validation procedures.
\r
7331 void j2k_setup_encoding_validation (opj_j2k_t *p_j2k)
\r
7334 assert(p_j2k != 00);
\r
7335 opj_procedure_list_add_procedure(p_j2k->m_validation_list, j2k_build_encoder);
\r
7336 opj_procedure_list_add_procedure(p_j2k->m_validation_list, j2k_encoding_validation);
\r
7339 /* DEVELOPER CORNER, add your custom validation procedure */
\r
7340 opj_procedure_list_add_procedure(p_j2k->m_validation_list, j2k_mct_validation);
\r
7344 * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
\r
7345 * are valid. Developpers wanting to extend the library can add their own validation procedures.
\r
7347 void j2k_setup_decoding_validation (opj_j2k_t *p_j2k)
\r
7350 assert(p_j2k != 00);
\r
7351 opj_procedure_list_add_procedure(p_j2k->m_validation_list, j2k_build_decoder);
\r
7352 opj_procedure_list_add_procedure(p_j2k->m_validation_list, j2k_decoding_validation);
\r
7353 /* DEVELOPER CORNER, add your custom validation procedure */
\r
7359 * Excutes the given procedures on the given codec.
\r
7361 * @param p_procedure_list the list of procedures to execute
\r
7362 * @param p_j2k the jpeg2000 codec to execute the procedures on.
\r
7363 * @param p_stream the stream to execute the procedures on.
\r
7364 * @param p_manager the user manager.
\r
7366 * @return true if all the procedures were successfully executed.
\r
7369 opj_j2k_t * p_j2k,
\r
7370 opj_procedure_list_t * p_procedure_list,
\r
7371 opj_stream_private_t *p_stream,
\r
7372 opj_event_mgr_t * p_manager
\r
7375 bool (** l_procedure) (opj_j2k_t * ,opj_stream_private_t *,opj_event_mgr_t *) = 00;
\r
7376 bool l_result = true;
\r
7377 OPJ_UINT32 l_nb_proc, i;
\r
7380 assert(p_procedure_list != 00);
\r
7381 assert(p_j2k != 00);
\r
7382 assert(p_stream != 00);
\r
7383 assert(p_manager != 00);
\r
7385 l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
\r
7386 l_procedure = (bool (**) (opj_j2k_t * ,opj_stream_private_t *,opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list);
\r
7388 (i=0;i<l_nb_proc;++i)
\r
7390 l_result = l_result && ((*l_procedure) (p_j2k,p_stream,p_manager));
\r
7393 // and clear the procedure list at the end.
\r
7394 opj_procedure_list_clear(p_procedure_list);
\r
7399 * The default encoding validation procedure without any extension.
\r
7401 * @param p_j2k the jpeg2000 codec to validate.
\r
7402 * @param p_stream the input stream to validate.
\r
7403 * @param p_manager the user event manager.
\r
7405 * @return true if the parameters are correct.
\r
7407 bool j2k_encoding_validation (
\r
7408 opj_j2k_t * p_j2k,
\r
7409 opj_stream_private_t *p_stream,
\r
7410 opj_event_mgr_t * p_manager
\r
7413 bool l_is_valid = true;
\r
7416 assert(p_j2k != 00);
\r
7417 assert(p_stream != 00);
\r
7418 assert(p_manager != 00);
\r
7420 /* STATE checking */
\r
7421 /* make sure the state is at 0 */
\r
7422 l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_NONE);
\r
7424 /* POINTER validation */
\r
7425 /* make sure a p_j2k codec is present */
\r
7426 l_is_valid &= (p_j2k->m_procedure_list != 00);
\r
7427 /* make sure a validation list is present */
\r
7428 l_is_valid &= (p_j2k->m_validation_list != 00);
\r
7431 ((p_j2k->m_cp.tdx) < (OPJ_UINT32) (1 << p_j2k->m_cp.tcps->tccps->numresolutions))
\r
7433 opj_event_msg(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n");
\r
7437 ((p_j2k->m_cp.tdy) < (OPJ_UINT32) (1 << p_j2k->m_cp.tcps->tccps->numresolutions))
\r
7439 opj_event_msg(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n");
\r
7443 /* PARAMETER VALIDATION */
\r
7444 return l_is_valid;
\r
7448 * The default decoding validation procedure without any extension.
\r
7450 * @param p_j2k the jpeg2000 codec to validate.
\r
7451 * @param p_stream the input stream to validate.
\r
7452 * @param p_manager the user event manager.
\r
7454 * @return true if the parameters are correct.
\r
7456 bool j2k_decoding_validation (
\r
7458 opj_stream_private_t *p_stream,
\r
7459 opj_event_mgr_t * p_manager
\r
7462 bool l_is_valid = true;
\r
7465 assert(p_j2k != 00);
\r
7466 assert(p_stream != 00);
\r
7467 assert(p_manager != 00);
\r
7469 /* STATE checking */
\r
7470 /* make sure the state is at 0 */
\r
7471 l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_NONE);
\r
7473 /* POINTER validation */
\r
7474 /* make sure a p_j2k codec is present */
\r
7475 /* make sure a procedure list is present */
\r
7476 l_is_valid &= (p_j2k->m_procedure_list != 00);
\r
7477 /* make sure a validation list is present */
\r
7478 l_is_valid &= (p_j2k->m_validation_list != 00);
\r
7480 /* PARAMETER VALIDATION */
\r
7481 return l_is_valid;
\r
7485 * The mct encoding validation procedure.
\r
7487 * @param p_j2k the jpeg2000 codec to validate.
\r
7488 * @param p_stream the input stream to validate.
\r
7489 * @param p_manager the user event manager.
\r
7491 * @return true if the parameters are correct.
\r
7493 bool j2k_mct_validation (
\r
7494 opj_j2k_t * p_j2k,
\r
7495 opj_stream_private_t *p_stream,
\r
7496 opj_event_mgr_t * p_manager
\r
7499 bool l_is_valid = true;
\r
7503 assert(p_j2k != 00);
\r
7504 assert(p_stream != 00);
\r
7505 assert(p_manager != 00);
\r
7508 ((p_j2k->m_cp.rsiz & 0x8200) == 0x8200)
\r
7510 OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
\r
7511 opj_tcp_t * l_tcp = p_j2k->m_cp.tcps;
\r
7513 (i=0;i<l_nb_tiles;++i)
\r
7518 opj_tccp_t * l_tccp = l_tcp->tccps;
\r
7519 l_is_valid &= (l_tcp->m_mct_coding_matrix != 00);
\r
7521 (j=0;j<p_j2k->m_image->numcomps;++j)
\r
7523 l_is_valid &= ! (l_tccp->qmfbid & 1);
\r
7530 return l_is_valid;
\r
7534 * Builds the cp decoder parameters to use to decode tile.
\r
7536 bool j2k_build_decoder (
\r
7537 opj_j2k_t * p_j2k,
\r
7538 opj_stream_private_t *p_stream,
\r
7539 opj_event_mgr_t * p_manager
\r
7542 // add here initialization of cp
\r
7543 // copy paste of setup_decoder
\r
7548 * Builds the cp encoder parameters to use to encode tile.
\r
7550 bool j2k_build_encoder (
\r
7551 opj_j2k_t * p_j2k,
\r
7552 opj_stream_private_t *p_stream,
\r
7553 opj_event_mgr_t * p_manager
\r
7556 // add here initialization of cp
\r
7557 // copy paste of setup_encoder
\r
7561 bool j2k_copy_default_tcp_and_create_tcd
\r
7563 opj_j2k_t * p_j2k,
\r
7564 opj_stream_private_t *p_stream,
\r
7565 opj_event_mgr_t * p_manager
\r
7568 opj_tcp_t * l_tcp = 00;
\r
7569 opj_tcp_t * l_default_tcp = 00;
\r
7570 OPJ_UINT32 l_nb_tiles;
\r
7572 opj_tccp_t *l_current_tccp = 00;
\r
7573 OPJ_UINT32 l_tccp_size;
\r
7574 OPJ_UINT32 l_mct_size;
\r
7575 opj_image_t * l_image;
\r
7576 OPJ_UINT32 l_mcc_records_size,l_mct_records_size;
\r
7577 opj_mct_data_t * l_src_mct_rec, *l_dest_mct_rec;
\r
7578 opj_simple_mcc_decorrelation_data_t * l_src_mcc_rec, *l_dest_mcc_rec;
\r
7579 OPJ_UINT32 l_offset;
\r
7581 // preconditions in debug
\r
7582 assert(p_j2k != 00);
\r
7583 assert(p_stream != 00);
\r
7584 assert(p_manager != 00);
\r
7586 l_image = p_j2k->m_image;
\r
7587 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
\r
7588 l_tcp = p_j2k->m_cp.tcps;
\r
7589 l_tccp_size = l_image->numcomps * sizeof(opj_tccp_t);
\r
7590 l_default_tcp = p_j2k->m_specific_param.m_decoder.m_default_tcp;
\r
7591 l_mct_size = l_image->numcomps * l_image->numcomps * sizeof(OPJ_FLOAT32);
\r
7593 (i=0;i<l_nb_tiles;++i)
\r
7595 l_current_tccp = l_tcp->tccps;
\r
7596 memcpy(l_tcp,l_default_tcp, sizeof(opj_tcp_t));
\r
7598 l_tcp->ppt_data = 00;
\r
7599 l_tcp->tccps = l_current_tccp;
\r
7601 (l_default_tcp->m_mct_decoding_matrix)
\r
7603 l_tcp->m_mct_decoding_matrix = opj_malloc(l_mct_size);
\r
7605 (! l_tcp->m_mct_decoding_matrix )
\r
7609 memcpy(l_tcp->m_mct_decoding_matrix,l_default_tcp->m_mct_decoding_matrix,l_mct_size);
\r
7611 l_mct_records_size = l_default_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t);
\r
7612 l_tcp->m_mct_records = opj_malloc(l_mct_records_size);
\r
7614 (! l_tcp->m_mct_records)
\r
7618 memcpy(l_tcp->m_mct_records, l_default_tcp->m_mct_records,l_mct_records_size);
\r
7619 l_src_mct_rec = l_default_tcp->m_mct_records;
\r
7620 l_dest_mct_rec = l_tcp->m_mct_records;
\r
7622 (j=0;j<l_default_tcp->m_nb_mct_records;++j)
\r
7625 (l_src_mct_rec->m_data)
\r
7627 l_dest_mct_rec->m_data = opj_malloc(l_src_mct_rec->m_data_size);
\r
7629 (! l_dest_mct_rec->m_data)
\r
7633 memcpy(l_dest_mct_rec->m_data,l_src_mct_rec->m_data,l_src_mct_rec->m_data_size);
\r
7638 l_mcc_records_size = l_default_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t);
\r
7639 l_tcp->m_mcc_records = opj_malloc(l_mcc_records_size);
\r
7641 (! l_tcp->m_mcc_records)
\r
7645 memcpy(l_tcp->m_mcc_records,l_default_tcp->m_mcc_records,l_mcc_records_size);
\r
7646 l_src_mcc_rec = l_default_tcp->m_mcc_records;
\r
7647 l_dest_mcc_rec = l_tcp->m_mcc_records;
\r
7649 (j=0;j<l_default_tcp->m_nb_max_mcc_records;++j)
\r
7652 (l_src_mcc_rec->m_decorrelation_array)
\r
7654 l_offset = l_src_mcc_rec->m_decorrelation_array - l_default_tcp->m_mct_records;
\r
7655 l_dest_mcc_rec->m_decorrelation_array = l_tcp->m_mct_records + l_offset;
\r
7658 (l_src_mcc_rec->m_offset_array)
\r
7660 l_offset = l_src_mcc_rec->m_offset_array - l_default_tcp->m_mct_records;
\r
7661 l_dest_mcc_rec->m_offset_array = l_tcp->m_mct_records + l_offset;
\r
7666 memcpy(l_current_tccp,l_default_tcp->tccps,l_tccp_size);
\r
7669 p_j2k->m_tcd = tcd_create(true);
\r
7676 (! tcd_init(p_j2k->m_tcd, l_image, &(p_j2k->m_cp)))
\r
7678 tcd_destroy(p_j2k->m_tcd);
\r
7679 p_j2k->m_tcd = 00;
\r
7680 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
\r
7687 * Destroys the memory associated with the decoding of headers.
\r
7689 bool j2k_destroy_header_memory (
\r
7690 opj_j2k_t * p_j2k,
\r
7691 opj_stream_private_t *p_stream,
\r
7692 opj_event_mgr_t * p_manager
\r
7695 // preconditions in debug
\r
7696 assert(p_j2k != 00);
\r
7697 assert(p_stream != 00);
\r
7698 assert(p_manager != 00);
\r
7701 (p_j2k->m_specific_param.m_encoder.m_header_tile_data)
\r
7703 opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
\r
7704 p_j2k->m_specific_param.m_encoder.m_header_tile_data = 0;
\r
7706 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
\r
7711 * Sets up the decoder decoding parameters using user parameters.
\r
7712 * Decoding parameters are stored in p_j2k->m_cp.
\r
7714 * @param p_j2k J2K codec
\r
7715 * @param p_parameters decompression parameters
\r
7718 void j2k_setup_decoder(
\r
7719 opj_j2k_t *p_j2k,
\r
7720 opj_dparameters_t *p_parameters
\r
7724 (p_j2k && p_parameters)
\r
7726 /* create and initialize the coding parameters structure */
\r
7727 p_j2k->m_cp.m_specific_param.m_dec.m_reduce = p_parameters->cp_reduce;
\r
7728 p_j2k->m_cp.m_specific_param.m_dec.m_layer = p_parameters->cp_layer;
\r
7729 p_j2k->m_specific_param.m_decoder.m_discard_tiles = p_parameters->m_use_restrict_decode;
\r
7731 (p_parameters->m_use_restrict_decode)
\r
7733 p_j2k->m_specific_param.m_decoder.m_start_tile_x = p_parameters->m_decode_start_x;
\r
7734 p_j2k->m_specific_param.m_decoder.m_start_tile_y = p_parameters->m_decode_start_y;
\r
7735 p_j2k->m_specific_param.m_decoder.m_end_tile_x = p_parameters->m_decode_end_x;
\r
7736 p_j2k->m_specific_param.m_decoder.m_end_tile_y = p_parameters->m_decode_end_y;
\r
7740 cp->correct = parameters->jpwl_correct;
\r
7741 cp->exp_comps = parameters->jpwl_exp_comps;
\r
7742 cp->max_tiles = parameters->jpwl_max_tiles;
\r
7743 #endif /* USE_JPWL */
\r
7747 void j2k_setup_encoder(opj_j2k_t *p_j2k, opj_cparameters_t *parameters, opj_image_t *image, struct opj_event_mgr * p_manager) {
\r
7748 OPJ_UINT32 i, j, tileno, numpocs_tile;
\r
7749 opj_cp_t *cp = 00;
\r
7751 if(!p_j2k || !parameters || ! image) {
\r
7755 /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */
\r
7756 cp = &(p_j2k->m_cp);
\r
7758 /* set default values for cp */
\r
7763 copy user encoding parameters
\r
7765 cp->m_specific_param.m_enc.m_cinema = parameters->cp_cinema;
\r
7766 cp->m_specific_param.m_enc.m_max_comp_size = parameters->max_comp_size;
\r
7767 cp->rsiz = parameters->cp_rsiz;
\r
7768 cp->m_specific_param.m_enc.m_disto_alloc = parameters->cp_disto_alloc;
\r
7769 cp->m_specific_param.m_enc.m_fixed_alloc = parameters->cp_fixed_alloc;
\r
7770 cp->m_specific_param.m_enc.m_fixed_quality = parameters->cp_fixed_quality;
\r
7772 /* mod fixed_quality */
\r
7774 (parameters->cp_matrice)
\r
7776 size_t array_size = parameters->tcp_numlayers * parameters->numresolution * 3 * sizeof(OPJ_INT32);
\r
7777 cp->m_specific_param.m_enc.m_matrice = (OPJ_INT32 *) opj_malloc(array_size);
\r
7778 memcpy(cp->m_specific_param.m_enc.m_matrice, parameters->cp_matrice, array_size);
\r
7782 cp->tdx = parameters->cp_tdx;
\r
7783 cp->tdy = parameters->cp_tdy;
\r
7786 cp->tx0 = parameters->cp_tx0;
\r
7787 cp->ty0 = parameters->cp_ty0;
\r
7789 /* comment string */
\r
7790 if(parameters->cp_comment) {
\r
7791 cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1);
\r
7793 strcpy(cp->comment, parameters->cp_comment);
\r
7798 calculate other encoding parameters
\r
7801 if (parameters->tile_size_on) {
\r
7802 cp->tw = int_ceildiv(image->x1 - cp->tx0, cp->tdx);
\r
7803 cp->th = int_ceildiv(image->y1 - cp->ty0, cp->tdy);
\r
7805 cp->tdx = image->x1 - cp->tx0;
\r
7806 cp->tdy = image->y1 - cp->ty0;
\r
7810 (parameters->tp_on)
\r
7812 cp->m_specific_param.m_enc.m_tp_flag = parameters->tp_flag;
\r
7813 cp->m_specific_param.m_enc.m_tp_on = 1;
\r
7818 calculate JPWL encoding parameters
\r
7821 if (parameters->jpwl_epc_on) {
\r
7825 cp->epc_on = true;
\r
7826 cp->info_on = false; /* no informative technique */
\r
7829 if ((parameters->jpwl_hprot_MH > 0) || (parameters->jpwl_hprot_TPH[0] > 0)) {
\r
7830 cp->epb_on = true;
\r
7832 cp->hprot_MH = parameters->jpwl_hprot_MH;
\r
7833 for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
\r
7834 cp->hprot_TPH_tileno[i] = parameters->jpwl_hprot_TPH_tileno[i];
\r
7835 cp->hprot_TPH[i] = parameters->jpwl_hprot_TPH[i];
\r
7837 /* if tile specs are not specified, copy MH specs */
\r
7838 if (cp->hprot_TPH[0] == -1) {
\r
7839 cp->hprot_TPH_tileno[0] = 0;
\r
7840 cp->hprot_TPH[0] = parameters->jpwl_hprot_MH;
\r
7842 for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
\r
7843 cp->pprot_tileno[i] = parameters->jpwl_pprot_tileno[i];
\r
7844 cp->pprot_packno[i] = parameters->jpwl_pprot_packno[i];
\r
7845 cp->pprot[i] = parameters->jpwl_pprot[i];
\r
7849 /* set ESD writing */
\r
7850 if ((parameters->jpwl_sens_size == 1) || (parameters->jpwl_sens_size == 2)) {
\r
7851 cp->esd_on = true;
\r
7853 cp->sens_size = parameters->jpwl_sens_size;
\r
7854 cp->sens_addr = parameters->jpwl_sens_addr;
\r
7855 cp->sens_range = parameters->jpwl_sens_range;
\r
7857 cp->sens_MH = parameters->jpwl_sens_MH;
\r
7858 for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
\r
7859 cp->sens_TPH_tileno[i] = parameters->jpwl_sens_TPH_tileno[i];
\r
7860 cp->sens_TPH[i] = parameters->jpwl_sens_TPH[i];
\r
7864 /* always set RED writing to false: we are at the encoder */
\r
7865 cp->red_on = false;
\r
7868 cp->epc_on = false;
\r
7870 #endif /* USE_JPWL */
\r
7873 /* initialize the mutiple tiles */
\r
7874 /* ---------------------------- */
\r
7875 cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t));
\r
7877 (parameters->numpocs)
\r
7879 /* initialisation of POC */
\r
7880 l_res = j2k_check_poc_val(parameters->POC,parameters->numpocs, parameters->numresolution, image->numcomps, parameters->tcp_numlayers, p_manager);
\r
7883 for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
\r
7884 opj_tcp_t *tcp = &cp->tcps[tileno];
\r
7885 tcp->numlayers = parameters->tcp_numlayers;
\r
7886 for (j = 0; j < tcp->numlayers; j++) {
\r
7887 if(cp->m_specific_param.m_enc.m_cinema){
\r
7888 if (cp->m_specific_param.m_enc.m_fixed_quality) {
\r
7889 tcp->distoratio[j] = parameters->tcp_distoratio[j];
\r
7891 tcp->rates[j] = parameters->tcp_rates[j];
\r
7893 if (cp->m_specific_param.m_enc.m_fixed_quality) { /* add fixed_quality */
\r
7894 tcp->distoratio[j] = parameters->tcp_distoratio[j];
\r
7896 tcp->rates[j] = parameters->tcp_rates[j];
\r
7900 tcp->csty = parameters->csty;
\r
7901 tcp->prg = parameters->prog_order;
\r
7902 tcp->mct = parameters->tcp_mct;
\r
7909 (parameters->numpocs)
\r
7911 /* initialisation of POC */
\r
7914 for (i = 0; i < (unsigned int) parameters->numpocs; i++) {
\r
7915 if((tileno == parameters->POC[i].tile - 1) || (parameters->POC[i].tile == -1)) {
\r
7916 opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
\r
7917 tcp_poc->resno0 = parameters->POC[numpocs_tile].resno0;
\r
7918 tcp_poc->compno0 = parameters->POC[numpocs_tile].compno0;
\r
7919 tcp_poc->layno1 = parameters->POC[numpocs_tile].layno1;
\r
7920 tcp_poc->resno1 = parameters->POC[numpocs_tile].resno1;
\r
7921 tcp_poc->compno1 = parameters->POC[numpocs_tile].compno1;
\r
7922 tcp_poc->prg1 = parameters->POC[numpocs_tile].prg1;
\r
7923 tcp_poc->tile = parameters->POC[numpocs_tile].tile;
\r
7927 tcp->numpocs = numpocs_tile -1 ;
\r
7932 tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t));
\r
7934 (parameters->mct_data)
\r
7936 OPJ_UINT32 lMctSize = image->numcomps * image->numcomps * sizeof(OPJ_FLOAT32);
\r
7937 OPJ_FLOAT32 * lTmpBuf = opj_malloc(lMctSize);
\r
7938 OPJ_INT32 * l_dc_shift = (OPJ_INT32 *) ((OPJ_BYTE *) parameters->mct_data + lMctSize);
\r
7940 tcp->m_mct_coding_matrix = opj_malloc(lMctSize);
\r
7941 memcpy(tcp->m_mct_coding_matrix,parameters->mct_data,lMctSize);
\r
7942 memcpy(lTmpBuf,parameters->mct_data,lMctSize);
\r
7943 tcp->m_mct_decoding_matrix = opj_malloc(lMctSize);
\r
7944 assert(opj_matrix_inversion_f(lTmpBuf,(tcp->m_mct_decoding_matrix),image->numcomps));
\r
7945 tcp->mct_norms = opj_malloc(image->numcomps * sizeof(OPJ_FLOAT64));
\r
7946 opj_calculate_norms(tcp->mct_norms,image->numcomps,tcp->m_mct_decoding_matrix);
\r
7947 opj_free(lTmpBuf);
\r
7949 (i = 0; i < image->numcomps; i++)
\r
7951 opj_tccp_t *tccp = &tcp->tccps[i];
\r
7952 tccp->m_dc_level_shift = l_dc_shift[i];
\r
7954 j2k_setup_mct_encoding(tcp,image);
\r
7959 (i = 0; i < image->numcomps; i++)
\r
7961 opj_tccp_t *tccp = &tcp->tccps[i];
\r
7962 opj_image_comp_t * l_comp = &(image->comps[i]);
\r
7966 tccp->m_dc_level_shift = 1 << (l_comp->prec - 1);
\r
7972 for (i = 0; i < image->numcomps; i++) {
\r
7973 opj_tccp_t *tccp = &tcp->tccps[i];
\r
7974 tccp->csty = parameters->csty & 0x01; /* 0 => one precinct || 1 => custom precinct */
\r
7975 tccp->numresolutions = parameters->numresolution;
\r
7976 tccp->cblkw = int_floorlog2(parameters->cblockw_init);
\r
7977 tccp->cblkh = int_floorlog2(parameters->cblockh_init);
\r
7978 tccp->cblksty = parameters->mode;
\r
7979 tccp->qmfbid = parameters->irreversible ? 0 : 1;
\r
7980 tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
\r
7981 tccp->numgbits = 2;
\r
7982 if (i == parameters->roi_compno) {
\r
7983 tccp->roishift = parameters->roi_shift;
\r
7985 tccp->roishift = 0;
\r
7988 if(parameters->cp_cinema)
\r
7990 //Precinct size for lowest frequency subband=128
\r
7991 tccp->prcw[0] = 7;
\r
7992 tccp->prch[0] = 7;
\r
7993 //Precinct size at all other resolutions = 256
\r
7994 for (j = 1; j < tccp->numresolutions; j++) {
\r
7995 tccp->prcw[j] = 8;
\r
7996 tccp->prch[j] = 8;
\r
7999 if (parameters->csty & J2K_CCP_CSTY_PRT) {
\r
8001 for (j = tccp->numresolutions - 1; j >= 0; j--) {
\r
8002 if (p < parameters->res_spec) {
\r
8004 if (parameters->prcw_init[p] < 1) {
\r
8005 tccp->prcw[j] = 1;
\r
8007 tccp->prcw[j] = int_floorlog2(parameters->prcw_init[p]);
\r
8010 if (parameters->prch_init[p] < 1) {
\r
8011 tccp->prch[j] = 1;
\r
8013 tccp->prch[j] = int_floorlog2(parameters->prch_init[p]);
\r
8017 int res_spec = parameters->res_spec;
\r
8018 int size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1));
\r
8019 int size_prch = parameters->prch_init[res_spec - 1] >> (p - (res_spec - 1));
\r
8021 if (size_prcw < 1) {
\r
8022 tccp->prcw[j] = 1;
\r
8024 tccp->prcw[j] = int_floorlog2(size_prcw);
\r
8027 if (size_prch < 1) {
\r
8028 tccp->prch[j] = 1;
\r
8030 tccp->prch[j] = int_floorlog2(size_prch);
\r
8034 /*printf("\nsize precinct for level %d : %d,%d\n", j,tccp->prcw[j], tccp->prch[j]); */
\r
8037 for (j = 0; j < tccp->numresolutions; j++) {
\r
8038 tccp->prcw[j] = 15;
\r
8039 tccp->prch[j] = 15;
\r
8044 dwt_calc_explicit_stepsizes(tccp, image->comps[i].prec);
\r
8048 (parameters->mct_data)
\r
8050 opj_free(parameters->mct_data);
\r
8051 parameters->mct_data = 00;
\r
8055 bool j2k_write_first_tile_part (
\r
8057 OPJ_BYTE * p_data,
\r
8058 OPJ_UINT32 * p_data_written,
\r
8059 OPJ_UINT32 p_total_data_size,
\r
8060 opj_stream_private_t *p_stream,
\r
8061 struct opj_event_mgr * p_manager
\r
8064 OPJ_UINT32 compno;
\r
8065 OPJ_UINT32 l_nb_bytes_written = 0;
\r
8066 OPJ_UINT32 l_current_nb_bytes_written;
\r
8067 OPJ_BYTE * l_begin_data = 00;
\r
8069 opj_tcp_t *l_tcp = 00;
\r
8070 opj_tcd_t * l_tcd = 00;
\r
8071 opj_cp_t * l_cp = 00;
\r
8073 l_tcd = p_j2k->m_tcd;
\r
8074 l_cp = &(p_j2k->m_cp);
\r
8075 l_tcp = l_cp->tcps + p_j2k->m_current_tile_number;
\r
8077 l_tcd->cur_pino = 0;
\r
8078 /*Get number of tile parts*/
\r
8080 p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
\r
8084 l_current_nb_bytes_written = 0;
\r
8085 l_begin_data = p_data;
\r
8087 (! j2k_write_sot(p_j2k,p_data,&l_current_nb_bytes_written,p_stream,p_manager))
\r
8091 l_nb_bytes_written += l_current_nb_bytes_written;
\r
8092 p_data += l_current_nb_bytes_written;
\r
8093 p_total_data_size -= l_current_nb_bytes_written;
\r
8096 (l_cp->m_specific_param.m_enc.m_cinema == 0)
\r
8099 (compno = 1; compno < p_j2k->m_image->numcomps; compno++)
\r
8101 l_current_nb_bytes_written = 0;
\r
8102 j2k_write_coc_in_memory(p_j2k,compno,p_data,&l_current_nb_bytes_written,p_manager);
\r
8103 l_nb_bytes_written += l_current_nb_bytes_written;
\r
8104 p_data += l_current_nb_bytes_written;
\r
8105 p_total_data_size -= l_current_nb_bytes_written;
\r
8107 l_current_nb_bytes_written = 0;
\r
8108 j2k_write_qcc_in_memory(p_j2k,compno,p_data,&l_current_nb_bytes_written,p_manager);
\r
8109 l_nb_bytes_written += l_current_nb_bytes_written;
\r
8110 p_data += l_current_nb_bytes_written;
\r
8111 p_total_data_size -= l_current_nb_bytes_written;
\r
8114 (l_cp->tcps[p_j2k->m_current_tile_number].numpocs)
\r
8116 l_current_nb_bytes_written = 0;
\r
8117 j2k_write_poc_in_memory(p_j2k,p_data,&l_current_nb_bytes_written,p_manager);
\r
8118 l_nb_bytes_written += l_current_nb_bytes_written;
\r
8119 p_data += l_current_nb_bytes_written;
\r
8120 p_total_data_size -= l_current_nb_bytes_written;
\r
8123 l_current_nb_bytes_written = 0;
\r
8125 (! j2k_write_sod(p_j2k,l_tcd,p_data,&l_current_nb_bytes_written,p_total_data_size,p_stream,p_manager))
\r
8129 l_nb_bytes_written += l_current_nb_bytes_written;
\r
8130 * p_data_written = l_nb_bytes_written;
\r
8132 /* Writing Psot in SOT marker */
\r
8133 opj_write_bytes(l_begin_data + 6,l_nb_bytes_written,4); /* PSOT */
\r
8135 (l_cp->m_specific_param.m_enc.m_cinema)
\r
8137 j2k_update_tlm(p_j2k,l_nb_bytes_written);
\r
8142 bool j2k_write_all_tile_parts(
\r
8144 OPJ_BYTE * p_data,
\r
8145 OPJ_UINT32 * p_data_written,
\r
8146 OPJ_UINT32 p_total_data_size,
\r
8147 opj_stream_private_t *p_stream,
\r
8148 struct opj_event_mgr * p_manager
\r
8151 OPJ_UINT32 tilepartno=0;
\r
8152 OPJ_UINT32 l_nb_bytes_written = 0;
\r
8153 OPJ_UINT32 l_current_nb_bytes_written;
\r
8154 OPJ_UINT32 l_part_tile_size;
\r
8155 OPJ_UINT32 tot_num_tp;
\r
8158 OPJ_BYTE * l_begin_data;
\r
8159 opj_tcp_t *l_tcp = 00;
\r
8160 opj_tcd_t * l_tcd = 00;
\r
8161 opj_cp_t * l_cp = 00;
\r
8164 l_tcd = p_j2k->m_tcd;
\r
8165 l_cp = &(p_j2k->m_cp);
\r
8166 l_tcp = l_cp->tcps + p_j2k->m_current_tile_number;
\r
8168 /*Get number of tile parts*/
\r
8169 tot_num_tp = j2k_get_num_tp(l_cp,0,p_j2k->m_current_tile_number);
\r
8171 (tilepartno = 1; tilepartno < tot_num_tp ; ++tilepartno)
\r
8173 p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno;
\r
8174 l_current_nb_bytes_written = 0;
\r
8175 l_part_tile_size = 0;
\r
8176 l_begin_data = p_data;
\r
8178 (! j2k_write_sot(p_j2k,p_data,&l_current_nb_bytes_written,p_stream,p_manager))
\r
8182 l_nb_bytes_written += l_current_nb_bytes_written;
\r
8183 p_data += l_current_nb_bytes_written;
\r
8184 p_total_data_size -= l_current_nb_bytes_written;
\r
8185 l_part_tile_size += l_nb_bytes_written;
\r
8187 l_current_nb_bytes_written = 0;
\r
8189 (! j2k_write_sod(p_j2k,l_tcd,p_data,&l_current_nb_bytes_written,p_total_data_size,p_stream,p_manager))
\r
8193 p_data += l_current_nb_bytes_written;
\r
8194 l_nb_bytes_written += l_current_nb_bytes_written;
\r
8195 p_total_data_size -= l_current_nb_bytes_written;
\r
8196 l_part_tile_size += l_nb_bytes_written;
\r
8198 /* Writing Psot in SOT marker */
\r
8199 opj_write_bytes(l_begin_data + 6,l_part_tile_size,4); /* PSOT */
\r
8202 (l_cp->m_specific_param.m_enc.m_cinema)
\r
8204 j2k_update_tlm(p_j2k,l_part_tile_size);
\r
8206 ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
\r
8209 (pino = 1; pino <= l_tcp->numpocs; ++pino)
\r
8211 l_tcd->cur_pino = pino;
\r
8212 /*Get number of tile parts*/
\r
8213 tot_num_tp = j2k_get_num_tp(l_cp,pino,p_j2k->m_current_tile_number);
\r
8215 (tilepartno = 0; tilepartno < tot_num_tp ; ++tilepartno)
\r
8217 p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno;
\r
8218 l_current_nb_bytes_written = 0;
\r
8219 l_part_tile_size = 0;
\r
8220 l_begin_data = p_data;
\r
8222 (! j2k_write_sot(p_j2k,p_data,&l_current_nb_bytes_written,p_stream,p_manager))
\r
8226 l_nb_bytes_written += l_current_nb_bytes_written;
\r
8227 p_data += l_current_nb_bytes_written;
\r
8228 p_total_data_size -= l_current_nb_bytes_written;
\r
8229 l_part_tile_size += l_current_nb_bytes_written;
\r
8231 l_current_nb_bytes_written = 0;
\r
8233 (! j2k_write_sod(p_j2k,l_tcd,p_data,&l_current_nb_bytes_written,p_total_data_size,p_stream,p_manager))
\r
8237 l_nb_bytes_written += l_current_nb_bytes_written;
\r
8238 p_data += l_current_nb_bytes_written;
\r
8239 p_total_data_size -= l_current_nb_bytes_written;
\r
8240 l_part_tile_size += l_current_nb_bytes_written;
\r
8242 /* Writing Psot in SOT marker */
\r
8243 opj_write_bytes(l_begin_data + 6,l_part_tile_size,4); /* PSOT */
\r
8246 (l_cp->m_specific_param.m_enc.m_cinema)
\r
8248 j2k_update_tlm(p_j2k,l_part_tile_size);
\r
8250 ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
\r
8253 *p_data_written = l_nb_bytes_written;
\r
8258 bool j2k_pre_write_tile (
\r
8259 opj_j2k_t * p_j2k,
\r
8260 OPJ_UINT32 p_tile_index,
\r
8261 opj_stream_private_t *p_stream,
\r
8262 opj_event_mgr_t * p_manager
\r
8266 (p_tile_index != p_j2k->m_current_tile_number)
\r
8268 opj_event_msg(p_manager, EVT_ERROR, "The given tile index does not match." );
\r
8272 opj_event_msg(p_manager, EVT_INFO, "tile number %d / %d\n", p_j2k->m_current_tile_number + 1, p_j2k->m_cp.tw * p_j2k->m_cp.th);
\r
8274 p_j2k->m_specific_param.m_encoder.m_current_tile_part_number = 0;
\r
8275 p_j2k->m_tcd->cur_totnum_tp = p_j2k->m_cp.tcps[p_tile_index].m_nb_tile_parts;
\r
8276 p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
\r
8277 /* initialisation before tile encoding */
\r
8279 (! tcd_init_encode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number))
\r
8288 * @param p_j2k the jpeg2000 codec.
\r
8289 * @param p_stream the stream to write data to.
\r
8290 * @param p_manager the user event manager.
\r
8292 bool j2k_write_tile (
\r
8293 opj_j2k_t * p_j2k,
\r
8294 OPJ_UINT32 p_tile_index,
\r
8295 OPJ_BYTE * p_data,
\r
8296 OPJ_UINT32 p_data_size,
\r
8297 opj_stream_private_t *p_stream,
\r
8298 opj_event_mgr_t * p_manager
\r
8302 (! j2k_pre_write_tile(p_j2k,p_tile_index,p_stream,p_manager))
\r
8306 return j2k_post_write_tile(p_j2k,p_data,p_data_size,p_stream,p_manager);
\r
8311 * @param p_j2k the jpeg2000 codec.
\r
8312 * @param p_stream the stream to write data to.
\r
8313 * @param p_manager the user event manager.
\r
8315 bool j2k_post_write_tile (
\r
8316 opj_j2k_t * p_j2k,
\r
8317 OPJ_BYTE * p_data,
\r
8318 OPJ_UINT32 p_data_size,
\r
8319 opj_stream_private_t *p_stream,
\r
8320 opj_event_mgr_t * p_manager
\r
8323 opj_tcd_t * l_tcd = 00;
\r
8324 opj_cp_t * l_cp = 00;
\r
8325 opj_tcp_t * l_tcp = 00;
\r
8326 OPJ_UINT32 l_nb_bytes_written;
\r
8327 OPJ_BYTE * l_current_data = 00;
\r
8328 OPJ_UINT32 l_tile_size = 0;
\r
8329 OPJ_UINT32 l_available_data;
\r
8331 assert(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
\r
8333 l_tcd = p_j2k->m_tcd;
\r
8334 l_cp = &(p_j2k->m_cp);
\r
8335 l_tcp = l_cp->tcps + p_j2k->m_current_tile_number;
\r
8337 l_tile_size = p_j2k->m_specific_param.m_encoder.m_encoded_tile_size;
\r
8338 l_available_data = l_tile_size;
\r
8339 l_current_data = p_j2k->m_specific_param.m_encoder.m_encoded_tile_data;
\r
8341 (! tcd_copy_tile_data(l_tcd,p_data,p_data_size))
\r
8343 opj_event_msg(p_manager, EVT_ERROR, "Size mismtach between tile data and sent data." );
\r
8347 l_nb_bytes_written = 0;
\r
8349 (! j2k_write_first_tile_part(p_j2k,l_current_data,&l_nb_bytes_written,l_available_data,p_stream,p_manager))
\r
8353 l_current_data += l_nb_bytes_written;
\r
8354 l_available_data -= l_nb_bytes_written;
\r
8356 l_nb_bytes_written = 0;
\r
8358 (! j2k_write_all_tile_parts(p_j2k,l_current_data,&l_nb_bytes_written,l_available_data,p_stream,p_manager))
\r
8363 l_available_data -= l_nb_bytes_written;
\r
8364 l_nb_bytes_written = l_tile_size - l_available_data;
\r
8367 (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_encoded_tile_data,l_nb_bytes_written,p_manager) != l_nb_bytes_written)
\r
8371 ++p_j2k->m_current_tile_number;
\r
8376 * Reads a tile header.
\r
8377 * @param p_j2k the jpeg2000 codec.
\r
8378 * @param p_stream the stream to write data to.
\r
8379 * @param p_manager the user event manager.
\r
8381 bool j2k_read_tile_header (
\r
8382 opj_j2k_t * p_j2k,
\r
8383 OPJ_UINT32 * p_tile_index,
\r
8384 OPJ_UINT32 * p_data_size,
\r
8385 OPJ_INT32 * p_tile_x0,
\r
8386 OPJ_INT32 * p_tile_y0,
\r
8387 OPJ_INT32 * p_tile_x1,
\r
8388 OPJ_INT32 * p_tile_y1,
\r
8389 OPJ_UINT32 * p_nb_comps,
\r
8391 opj_stream_private_t *p_stream,
\r
8392 opj_event_mgr_t * p_manager
\r
8395 OPJ_UINT32 l_current_marker = J2K_MS_SOT;
\r
8396 OPJ_UINT32 l_marker_size;
\r
8397 const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
\r
8398 opj_tcp_t * l_tcp = 00;
\r
8399 OPJ_UINT32 l_nb_tiles;
\r
8402 assert(p_stream != 00);
\r
8403 assert(p_j2k != 00);
\r
8404 assert(p_manager != 00);
\r
8407 (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_EOC)
\r
8409 l_current_marker = J2K_MS_EOC;
\r
8412 (p_j2k->m_specific_param.m_decoder.m_state != J2K_DEC_STATE_TPHSOT)
\r
8418 (! p_j2k->m_specific_param.m_decoder.m_can_decode && l_current_marker != J2K_MS_EOC)
\r
8421 (l_current_marker != J2K_MS_SOD)
\r
8424 (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
\r
8426 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
\r
8429 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_marker_size,2);
\r
8431 (p_j2k->m_specific_param.m_decoder.m_state & J2K_DEC_STATE_TPH)
\r
8433 p_j2k->m_specific_param.m_decoder.m_sot_length -= (l_marker_size + 2);
\r
8435 l_marker_size -= 2;
\r
8437 l_marker_handler = j2k_get_marker_handler(l_current_marker);
\r
8438 // Check if the marker is known
\r
8440 (! (p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states) )
\r
8442 opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
\r
8446 (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size)
\r
8448 p_j2k->m_specific_param.m_decoder.m_header_data = opj_realloc(p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size);
\r
8450 (p_j2k->m_specific_param.m_decoder.m_header_data == 00)
\r
8454 p_j2k->m_specific_param.m_decoder.m_header_data_size = l_marker_size;
\r
8458 (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager) != l_marker_size)
\r
8460 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
\r
8464 (! (*(l_marker_handler->handler))(p_j2k,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager))
\r
8466 opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
\r
8470 (p_j2k->m_specific_param.m_decoder.m_skip_data)
\r
8473 (opj_stream_skip(p_stream,p_j2k->m_specific_param.m_decoder.m_sot_length,p_manager) != p_j2k->m_specific_param.m_decoder.m_sot_length)
\r
8475 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
\r
8478 l_current_marker = J2K_MS_SOD;
\r
8483 (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
\r
8485 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
\r
8488 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
\r
8493 (! p_j2k->m_specific_param.m_decoder.m_skip_data)
\r
8496 (! j2k_read_sod(p_j2k,p_stream,p_manager))
\r
8503 p_j2k->m_specific_param.m_decoder.m_skip_data = 0;
\r
8504 p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
\r
8505 p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_TPHSOT;
\r
8507 (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
\r
8509 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
\r
8512 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
\r
8517 (l_current_marker == J2K_MS_EOC)
\r
8520 (p_j2k->m_specific_param.m_decoder.m_state != J2K_DEC_STATE_EOC)
\r
8522 p_j2k->m_current_tile_number = 0;
\r
8523 p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_EOC;
\r
8527 ( ! p_j2k->m_specific_param.m_decoder.m_can_decode)
\r
8529 l_tcp = p_j2k->m_cp.tcps + p_j2k->m_current_tile_number;
\r
8530 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
\r
8533 (p_j2k->m_current_tile_number < l_nb_tiles)
\r
8534 && (l_tcp->m_data == 00)
\r
8537 ++p_j2k->m_current_tile_number;
\r
8541 (p_j2k->m_current_tile_number == l_nb_tiles)
\r
8548 (! tcd_init_decode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number))
\r
8550 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
\r
8553 *p_tile_index = p_j2k->m_current_tile_number;
\r
8555 *p_data_size = tcd_get_decoded_tile_size(p_j2k->m_tcd);
\r
8556 * p_tile_x0 = p_j2k->m_tcd->tcd_image->tiles->x0;
\r
8557 * p_tile_y0 = p_j2k->m_tcd->tcd_image->tiles->y0;
\r
8558 * p_tile_x1 = p_j2k->m_tcd->tcd_image->tiles->x1;
\r
8559 * p_tile_y1 = p_j2k->m_tcd->tcd_image->tiles->y1;
\r
8560 * p_nb_comps = p_j2k->m_tcd->tcd_image->tiles->numcomps;
\r
8561 p_j2k->m_specific_param.m_decoder.m_state |= J2K_DEC_STATE_DATA;
\r
8565 bool j2k_decode_tile (
\r
8566 opj_j2k_t * p_j2k,
\r
8567 OPJ_UINT32 p_tile_index,
\r
8568 OPJ_BYTE * p_data,
\r
8569 OPJ_UINT32 p_data_size,
\r
8570 opj_stream_private_t *p_stream,
\r
8571 opj_event_mgr_t * p_manager
\r
8574 OPJ_UINT32 l_current_marker;
\r
8575 OPJ_BYTE l_data [2];
\r
8576 opj_tcp_t * l_tcp;
\r
8579 assert(p_stream != 00);
\r
8580 assert(p_j2k != 00);
\r
8581 assert(p_manager != 00);
\r
8584 (! (p_j2k->m_specific_param.m_decoder.m_state & J2K_DEC_STATE_DATA) || p_tile_index != p_j2k->m_current_tile_number)
\r
8588 l_tcp = &(p_j2k->m_cp.tcps[p_tile_index]);
\r
8592 j2k_tcp_destroy(&(p_j2k->m_cp.tcps[p_tile_index]));
\r
8596 (! tcd_decode_tile(p_j2k->m_tcd, l_tcp->m_data, l_tcp->m_data_size, p_tile_index, p_j2k->cstr_info))
\r
8598 j2k_tcp_destroy(l_tcp);
\r
8599 p_j2k->m_specific_param.m_decoder.m_state |= J2K_DEC_STATE_ERR;
\r
8603 (! tcd_update_tile_data(p_j2k->m_tcd,p_data,p_data_size))
\r
8607 j2k_tcp_destroy(l_tcp);
\r
8608 p_j2k->m_tcd->tcp = 0;
\r
8610 p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
\r
8611 p_j2k->m_specific_param.m_decoder.m_state &= (~J2K_DEC_STATE_DATA);
\r
8613 (p_j2k->m_specific_param.m_decoder.m_state != J2K_DEC_STATE_EOC)
\r
8616 (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2)
\r
8618 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
\r
8621 opj_read_bytes(l_data,&l_current_marker,2);
\r
8623 (l_current_marker == J2K_MS_EOC)
\r
8625 p_j2k->m_current_tile_number = 0;
\r
8626 p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_EOC;
\r
8629 (l_current_marker != J2K_MS_SOT)
\r
8631 opj_event_msg(p_manager, EVT_ERROR, "Stream too short, expected SOT\n");
\r
8640 * Ends the compression procedures and possibiliy add data to be read after the
\r
8643 bool j2k_end_compress(opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager)
\r
8645 /* customization of the encoding */
\r
8646 j2k_setup_end_compress(p_j2k);
\r
8649 (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager))
\r
8657 * Reads a jpeg2000 codestream header structure.
\r
8659 * @param p_stream the stream to read data from.
\r
8660 * @param p_j2k the jpeg2000 codec.
\r
8661 * @param p_manager the user event manager.
\r
8663 * @return true if the box is valid.
\r
8665 bool j2k_read_header(
\r
8667 struct opj_image ** p_image,
\r
8668 OPJ_INT32 * p_tile_x0,
\r
8669 OPJ_INT32 * p_tile_y0,
\r
8670 OPJ_UINT32 * p_tile_width,
\r
8671 OPJ_UINT32 * p_tile_height,
\r
8672 OPJ_UINT32 * p_nb_tiles_x,
\r
8673 OPJ_UINT32 * p_nb_tiles_y,
\r
8674 struct opj_stream_private *p_stream,
\r
8675 struct opj_event_mgr * p_manager
\r
8679 assert(p_j2k != 00);
\r
8680 assert(p_stream != 00);
\r
8681 assert(p_manager != 00);
\r
8684 /* create an empty image */
\r
8685 p_j2k->m_image = opj_image_create0();
\r
8687 (! p_j2k->m_image)
\r
8692 /* customization of the validation */
\r
8693 j2k_setup_decoding_validation (p_j2k);
\r
8695 /* validation of the parameters codec */
\r
8697 (! j2k_exec(p_j2k,p_j2k->m_validation_list,p_stream,p_manager))
\r
8699 opj_image_destroy(p_j2k->m_image);
\r
8700 p_j2k->m_image = 00;
\r
8704 /* customization of the encoding */
\r
8705 j2k_setup_header_reading(p_j2k);
\r
8709 (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager))
\r
8711 opj_image_destroy(p_j2k->m_image);
\r
8712 p_j2k->m_image = 00;
\r
8715 *p_image = p_j2k->m_image;
\r
8716 * p_tile_x0 = p_j2k->m_cp.tx0;
\r
8717 * p_tile_y0 = p_j2k->m_cp.ty0;
\r
8718 * p_tile_width = p_j2k->m_cp.tdx;
\r
8719 * p_tile_height = p_j2k->m_cp.tdy;
\r
8720 * p_nb_tiles_x = p_j2k->m_cp.tw;
\r
8721 * p_nb_tiles_y = p_j2k->m_cp.th;
\r
8726 * The read header procedure.
\r
8728 bool j2k_read_header_procedure(
\r
8730 struct opj_stream_private *p_stream,
\r
8731 struct opj_event_mgr * p_manager)
\r
8733 OPJ_UINT32 l_current_marker;
\r
8734 OPJ_UINT32 l_marker_size;
\r
8735 const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
\r
8738 assert(p_stream != 00);
\r
8739 assert(p_j2k != 00);
\r
8740 assert(p_manager != 00);
\r
8742 p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_MHSOC;
\r
8745 (! j2k_read_soc(p_j2k,p_stream,p_manager))
\r
8747 opj_event_msg(p_manager, EVT_ERROR, "Expected a SOC marker \n");
\r
8751 (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
\r
8753 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
\r
8756 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
\r
8759 (l_current_marker != J2K_MS_SOT)
\r
8762 (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
\r
8764 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
\r
8767 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_marker_size,2);
\r
8768 l_marker_size -= 2;
\r
8770 (l_current_marker < 0xff00)
\r
8772 opj_event_msg(p_manager, EVT_ERROR, "%.8x: expected a marker instead of %x\n", opj_stream_tell(p_stream) - 2, l_current_marker);
\r
8776 l_marker_handler = j2k_get_marker_handler(l_current_marker);
\r
8777 // Check if the marker is known
\r
8779 (! (p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states) )
\r
8781 opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
\r
8785 (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size)
\r
8787 p_j2k->m_specific_param.m_decoder.m_header_data = opj_realloc(p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size);
\r
8789 (p_j2k->m_specific_param.m_decoder.m_header_data == 00)
\r
8793 p_j2k->m_specific_param.m_decoder.m_header_data_size = l_marker_size;
\r
8796 (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager) != l_marker_size)
\r
8798 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
\r
8802 (! (*(l_marker_handler->handler))(p_j2k,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager))
\r
8804 opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
\r
8808 (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
\r
8810 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
\r
8813 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
\r
8815 p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_TPHSOT;
\r
8822 * Reads the tiles.
\r
8824 bool j2k_decode_tiles (
\r
8826 struct opj_stream_private *p_stream,
\r
8827 struct opj_event_mgr * p_manager)
\r
8829 bool l_go_on = true;
\r
8830 OPJ_UINT32 l_current_tile_no;
\r
8831 OPJ_UINT32 l_data_size,l_max_data_size;
\r
8832 OPJ_INT32 l_tile_x0,l_tile_y0,l_tile_x1,l_tile_y1;
\r
8833 OPJ_UINT32 l_nb_comps;
\r
8834 OPJ_BYTE * l_current_data;
\r
8836 l_current_data = opj_malloc(1000);
\r
8838 (! l_current_data)
\r
8842 l_max_data_size = 1000;
\r
8848 (! j2k_read_tile_header(
\r
8849 p_j2k,&l_current_tile_no,
\r
8868 (l_data_size > l_max_data_size)
\r
8870 l_current_data = opj_realloc(l_current_data,l_data_size);
\r
8872 (! l_current_data)
\r
8876 l_max_data_size = l_data_size;
\r
8879 (! j2k_decode_tile(p_j2k,l_current_tile_no,l_current_data,l_data_size,p_stream,p_manager))
\r
8881 opj_free(l_current_data);
\r
8885 (! j2k_update_image_data(p_j2k->m_tcd,l_current_data))
\r
8887 opj_free(l_current_data);
\r
8892 opj_free(l_current_data);
\r
8902 * Decodes the tiles of the stream.
\r
8904 opj_image_t * j2k_decode(
\r
8905 opj_j2k_t * p_j2k,
\r
8906 opj_stream_private_t * p_stream,
\r
8907 opj_event_mgr_t * p_manager)
\r
8909 /* customization of the encoding */
\r
8910 j2k_setup_decoding(p_j2k);
\r
8912 /* write header */
\r
8914 (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager))
\r
8916 opj_image_destroy(p_j2k->m_image);
\r
8917 p_j2k->m_image = 00;
\r
8919 return p_j2k->m_image;
\r
8923 * Encodes all the tiles in a row.
\r
8926 opj_j2k_t * p_j2k,
\r
8927 opj_stream_private_t *p_stream,
\r
8928 opj_event_mgr_t * p_manager
\r
8932 OPJ_UINT32 l_nb_tiles;
\r
8933 OPJ_UINT32 l_max_tile_size, l_current_tile_size;
\r
8934 OPJ_BYTE * l_current_data;
\r
8937 assert(p_j2k != 00);
\r
8938 assert(p_stream != 00);
\r
8939 assert(p_manager != 00);
\r
8941 l_current_data = opj_malloc(1000);
\r
8943 (! l_current_data)
\r
8947 l_max_tile_size = 1000;
\r
8949 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
\r
8951 (i=0;i<l_nb_tiles;++i)
\r
8954 (! j2k_pre_write_tile(p_j2k,i,p_stream,p_manager))
\r
8956 opj_free(l_current_data);
\r
8959 l_current_tile_size = tcd_get_encoded_tile_size(p_j2k->m_tcd);
\r
8961 (l_current_tile_size > l_max_tile_size)
\r
8963 l_current_data = opj_realloc(l_current_data,l_current_tile_size);
\r
8965 (! l_current_data)
\r
8969 l_max_tile_size = l_current_tile_size;
\r
8971 j2k_get_tile_data(p_j2k->m_tcd,l_current_data);
\r
8973 (! j2k_post_write_tile (p_j2k,l_current_data,l_current_tile_size,p_stream,p_manager))
\r
8978 opj_free(l_current_data);
\r
8985 * Ends the decompression procedures and possibiliy add data to be read after the
\r
8988 bool j2k_end_decompress(
\r
8989 opj_j2k_t *p_j2k,
\r
8990 struct opj_stream_private *p_stream,
\r
8991 struct opj_event_mgr * p_manager)
\r
8998 void j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data)
\r
9000 OPJ_UINT32 i,j,k = 0;
\r
9001 OPJ_UINT32 l_width,l_height,l_stride, l_offset_x,l_offset_y, l_image_width;
\r
9002 opj_image_comp_t * l_img_comp = 00;
\r
9003 opj_tcd_tilecomp_t * l_tilec = 00;
\r
9004 opj_image_t * l_image = 00;
\r
9005 OPJ_UINT32 l_size_comp, l_remaining;
\r
9006 OPJ_INT32 * l_src_ptr;
\r
9007 l_tilec = p_tcd->tcd_image->tiles->comps;
\r
9008 l_image = p_tcd->image;
\r
9009 l_img_comp = l_image->comps;
\r
9011 (i=0;i<p_tcd->image->numcomps;++i)
\r
9013 l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
\r
9014 l_remaining = l_img_comp->prec & 7; /* (%8) */
\r
9021 (l_size_comp == 3)
\r
9025 l_width = (l_tilec->x1 - l_tilec->x0);
\r
9026 l_height = (l_tilec->y1 - l_tilec->y0);
\r
9027 l_offset_x = int_ceildiv(l_image->x0, l_img_comp->dx);
\r
9028 l_offset_y = int_ceildiv(l_image->y0, l_img_comp->dy);
\r
9029 l_image_width = int_ceildiv(l_image->x1 - l_image->x0, l_img_comp->dx);
\r
9030 l_stride = l_image_width - l_width;
\r
9031 l_src_ptr = l_img_comp->data + (l_tilec->x0 - l_offset_x) + (l_tilec->y0 - l_offset_y) * l_image_width;
\r
9038 OPJ_CHAR * l_dest_ptr = (OPJ_CHAR*) p_data;
\r
9040 (l_img_comp->sgnd)
\r
9043 (j=0;j<l_height;++j)
\r
9046 (k=0;k<l_width;++k)
\r
9048 *(l_dest_ptr) = (OPJ_CHAR) (*l_src_ptr);
\r
9052 l_src_ptr += l_stride;
\r
9058 (j=0;j<l_height;++j)
\r
9061 (k=0;k<l_width;++k)
\r
9063 *(l_dest_ptr) = (*l_src_ptr)&0xff;
\r
9067 l_src_ptr += l_stride;
\r
9070 p_data = (OPJ_BYTE*) l_dest_ptr;
\r
9075 OPJ_INT16 * l_dest_ptr = (OPJ_INT16 *) p_data;
\r
9077 (l_img_comp->sgnd)
\r
9080 (j=0;j<l_height;++j)
\r
9083 (k=0;k<l_width;++k)
\r
9085 *(l_dest_ptr++) = (OPJ_INT16) (*(l_src_ptr++));
\r
9087 l_src_ptr += l_stride;
\r
9093 (j=0;j<l_height;++j)
\r
9096 (k=0;k<l_width;++k)
\r
9098 *(l_dest_ptr++) = (*(l_src_ptr++))&0xffff;
\r
9100 l_src_ptr += l_stride;
\r
9103 p_data = (OPJ_BYTE*) l_dest_ptr;
\r
9108 OPJ_INT32 * l_dest_ptr = (OPJ_INT32 *) p_data;
\r
9110 (j=0;j<l_height;++j)
\r
9113 (k=0;k<l_width;++k)
\r
9115 *(l_dest_ptr++) = *(l_src_ptr++);
\r
9117 l_src_ptr += l_stride;
\r
9119 p_data = (OPJ_BYTE*) l_dest_ptr;
\r
9128 bool j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data)
\r
9130 OPJ_UINT32 i,j,k = 0;
\r
9131 OPJ_UINT32 l_width,l_height,l_offset_x,l_offset_y;
\r
9132 opj_image_comp_t * l_img_comp = 00;
\r
9133 opj_tcd_tilecomp_t * l_tilec = 00;
\r
9134 opj_image_t * l_image = 00;
\r
9135 OPJ_UINT32 l_size_comp, l_remaining;
\r
9136 OPJ_UINT32 l_dest_stride;
\r
9137 OPJ_INT32 * l_dest_ptr;
\r
9138 opj_tcd_resolution_t* l_res= 00;
\r
9141 l_tilec = p_tcd->tcd_image->tiles->comps;
\r
9142 l_image = p_tcd->image;
\r
9143 l_img_comp = l_image->comps;
\r
9145 (i=0;i<p_tcd->image->numcomps;++i)
\r
9148 (!l_img_comp->data)
\r
9150 l_img_comp->data = (OPJ_INT32*) opj_malloc(l_img_comp->w * l_img_comp->h * sizeof(OPJ_INT32));
\r
9152 (! l_img_comp->data)
\r
9156 memset(l_img_comp->data,0,l_img_comp->w * l_img_comp->h * sizeof(OPJ_INT32));
\r
9159 l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
\r
9160 l_remaining = l_img_comp->prec & 7; /* (%8) */
\r
9161 l_res = l_tilec->resolutions + l_img_comp->resno_decoded;
\r
9169 (l_size_comp == 3)
\r
9173 l_width = (l_res->x1 - l_res->x0);
\r
9174 l_height = (l_res->y1 - l_res->y0);
\r
9175 l_dest_stride = (l_img_comp->w) - l_width;
\r
9176 l_offset_x = int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
\r
9177 l_offset_y = int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
\r
9178 l_dest_ptr = l_img_comp->data + (l_res->x0 - l_offset_x) + (l_res->y0 - l_offset_y) * l_img_comp->w;
\r
9185 OPJ_CHAR * l_src_ptr = (OPJ_CHAR*) p_data;
\r
9187 (l_img_comp->sgnd)
\r
9190 (j=0;j<l_height;++j)
\r
9193 (k=0;k<l_width;++k)
\r
9195 *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++));
\r
9197 l_dest_ptr += l_dest_stride;
\r
9204 (j=0;j<l_height;++j)
\r
9207 (k=0;k<l_width;++k)
\r
9209 *(l_dest_ptr++) = (OPJ_INT32) ((*(l_src_ptr++))&0xff);
\r
9211 l_dest_ptr += l_dest_stride;
\r
9214 p_data = (OPJ_BYTE*) l_src_ptr;
\r
9219 OPJ_INT16 * l_src_ptr = (OPJ_INT16 *) p_data;
\r
9221 (l_img_comp->sgnd)
\r
9224 (j=0;j<l_height;++j)
\r
9227 (k=0;k<l_width;++k)
\r
9229 *(l_dest_ptr++) = *(l_src_ptr++);
\r
9231 l_dest_ptr += l_dest_stride;
\r
9237 (j=0;j<l_height;++j)
\r
9240 (k=0;k<l_width;++k)
\r
9242 *(l_dest_ptr++) = (*(l_src_ptr++))&0xffff;
\r
9244 l_dest_ptr += l_dest_stride;
\r
9247 p_data = (OPJ_BYTE*) l_src_ptr;
\r
9252 OPJ_INT32 * l_src_ptr = (OPJ_INT32 *) p_data;
\r
9254 (j=0;j<l_height;++j)
\r
9257 (k=0;k<l_width;++k)
\r
9259 *(l_dest_ptr++) = (*(l_src_ptr++));
\r
9261 l_dest_ptr += l_dest_stride;
\r
9263 p_data = (OPJ_BYTE*) l_src_ptr;
\r
9274 * Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.
\r
9276 * @param p_j2k the jpeg2000 codec.
\r
9277 * @param p_start_x the left position of the rectangle to decode (in image coordinates).
\r
9278 * @param p_end_x the right position of the rectangle to decode (in image coordinates).
\r
9279 * @param p_start_y the up position of the rectangle to decode (in image coordinates).
\r
9280 * @param p_end_y the bottom position of the rectangle to decode (in image coordinates).
\r
9281 * @param p_manager the user event manager
\r
9283 * @return true if the area could be set.
\r
9285 bool j2k_set_decode_area(
\r
9287 OPJ_INT32 p_start_x,
\r
9288 OPJ_INT32 p_start_y,
\r
9289 OPJ_INT32 p_end_x,
\r
9290 OPJ_INT32 p_end_y,
\r
9291 struct opj_event_mgr * p_manager
\r
9294 opj_cp_t * l_cp = &(p_j2k->m_cp);
\r
9297 (p_j2k->m_specific_param.m_decoder.m_state != J2K_DEC_STATE_TPHSOT)
\r
9301 p_j2k->m_specific_param.m_decoder.m_start_tile_x = (p_start_x - l_cp->tx0) / l_cp->tdx;
\r
9302 p_j2k->m_specific_param.m_decoder.m_start_tile_y = (p_start_y - l_cp->ty0) / l_cp->tdy;
\r
9303 p_j2k->m_specific_param.m_decoder.m_end_tile_x = int_ceildiv((p_end_x - l_cp->tx0), l_cp->tdx);
\r
9304 p_j2k->m_specific_param.m_decoder.m_end_tile_y = int_ceildiv((p_end_y - l_cp->ty0), l_cp->tdy);
\r
9305 p_j2k->m_specific_param.m_decoder.m_discard_tiles = 1;
\r
projects / openjpeg.git / blob