• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * The copyright in this software is being made available under the 2-clauses
3  * BSD License, included below. This software may be subject to other third
4  * party and contributor rights, including patent rights, and no such rights
5  * are granted under this license.
6  *
7  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
8  * Copyright (c) 2002-2014, Professor Benoit Macq
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  */
32 #ifndef OPJ_CODEC_H
33 #define OPJ_CODEC_H
34 /**
35 @file opj_codec.h
36 */
37 
38 
39 /**
40  * Main codec handler used for compression or decompression.
41  */
42 typedef struct opj_codec_private {
43     /** FIXME DOC */
44     union {
45         /**
46          * Decompression handler.
47          */
48         struct opj_decompression {
49             /** Main header reading function handler */
50             OPJ_BOOL(*opj_read_header)(struct opj_stream_private * cio,
51                                        void * p_codec,
52                                        opj_image_t **p_image,
53                                        struct opj_event_mgr * p_manager);
54 
55             /** Decoding function */
56             OPJ_BOOL(*opj_decode)(void * p_codec,
57                                   struct opj_stream_private * p_cio,
58                                   opj_image_t * p_image,
59                                   struct opj_event_mgr * p_manager);
60 
61             /** FIXME DOC */
62             OPJ_BOOL(*opj_read_tile_header)(void * p_codec,
63                                             OPJ_UINT32 * p_tile_index,
64                                             OPJ_UINT32 * p_data_size,
65                                             OPJ_INT32 * p_tile_x0,
66                                             OPJ_INT32 * p_tile_y0,
67                                             OPJ_INT32 * p_tile_x1,
68                                             OPJ_INT32 * p_tile_y1,
69                                             OPJ_UINT32 * p_nb_comps,
70                                             OPJ_BOOL * p_should_go_on,
71                                             struct opj_stream_private * p_cio,
72                                             struct opj_event_mgr * p_manager);
73 
74             /** FIXME DOC */
75             OPJ_BOOL(*opj_decode_tile_data)(void * p_codec,
76                                             OPJ_UINT32 p_tile_index,
77                                             OPJ_BYTE * p_data,
78                                             OPJ_UINT32 p_data_size,
79                                             struct opj_stream_private * p_cio,
80                                             struct opj_event_mgr * p_manager);
81 
82             /** Reading function used after codestream if necessary */
83             OPJ_BOOL(* opj_end_decompress)(void *p_codec,
84                                            struct opj_stream_private * cio,
85                                            struct opj_event_mgr * p_manager);
86 
87             /** Codec destroy function handler */
88             void (*opj_destroy)(void * p_codec);
89 
90             /** Setup decoder function handler */
91             void (*opj_setup_decoder)(void * p_codec, opj_dparameters_t * p_param);
92 
93             /** Set decode area function handler */
94             OPJ_BOOL(*opj_set_decode_area)(void * p_codec,
95                                            opj_image_t * p_image,
96                                            OPJ_INT32 p_start_x,
97                                            OPJ_INT32 p_end_x,
98                                            OPJ_INT32 p_start_y,
99                                            OPJ_INT32 p_end_y,
100                                            struct opj_event_mgr * p_manager);
101 
102             /** Get tile function */
103             OPJ_BOOL(*opj_get_decoded_tile)(void *p_codec,
104                                             opj_stream_private_t * p_cio,
105                                             opj_image_t *p_image,
106                                             struct opj_event_mgr * p_manager,
107                                             OPJ_UINT32 tile_index);
108 
109             /** Set the decoded resolution factor */
110             OPJ_BOOL(*opj_set_decoded_resolution_factor)(void * p_codec,
111                     OPJ_UINT32 res_factor,
112                     opj_event_mgr_t * p_manager);
113 
114             /** Set the decoded components */
115             OPJ_BOOL(*opj_set_decoded_components)(void * p_codec,
116                                                   OPJ_UINT32 num_comps,
117                                                   const OPJ_UINT32* comps_indices,
118                                                   opj_event_mgr_t * p_manager);
119         } m_decompression;
120 
121         /**
122          * Compression handler. FIXME DOC
123          */
124         struct opj_compression {
125             OPJ_BOOL(* opj_start_compress)(void *p_codec,
126                                            struct opj_stream_private * cio,
127                                            struct opj_image * p_image,
128                                            struct opj_event_mgr * p_manager);
129 
130             OPJ_BOOL(* opj_encode)(void * p_codec,
131                                    struct opj_stream_private *p_cio,
132                                    struct opj_event_mgr * p_manager);
133 
134             OPJ_BOOL(* opj_write_tile)(void * p_codec,
135                                        OPJ_UINT32 p_tile_index,
136                                        OPJ_BYTE * p_data,
137                                        OPJ_UINT32 p_data_size,
138                                        struct opj_stream_private * p_cio,
139                                        struct opj_event_mgr * p_manager);
140 
141             OPJ_BOOL(* opj_end_compress)(void * p_codec,
142                                          struct opj_stream_private * p_cio,
143                                          struct opj_event_mgr * p_manager);
144 
145             void (* opj_destroy)(void * p_codec);
146 
147             OPJ_BOOL(* opj_setup_encoder)(void * p_codec,
148                                           opj_cparameters_t * p_param,
149                                           struct opj_image * p_image,
150                                           struct opj_event_mgr * p_manager);
151         } m_compression;
152     } m_codec_data;
153     /** FIXME DOC*/
154     void * m_codec;
155     /** Event handler */
156     opj_event_mgr_t m_event_mgr;
157     /** Flag to indicate if the codec is used to decode or encode*/
158     OPJ_BOOL is_decompressor;
159     void (*opj_dump_codec)(void * p_codec, OPJ_INT32 info_flag,
160                            FILE* output_stream);
161     opj_codestream_info_v2_t* (*opj_get_codec_info)(void* p_codec);
162     opj_codestream_index_t* (*opj_get_codec_index)(void* p_codec);
163 
164     /** Set number of threads */
165     OPJ_BOOL(*opj_set_threads)(void * p_codec, OPJ_UINT32 num_threads);
166 }
167 opj_codec_private_t;
168 
169 
170 #endif /* OPJ_CODEC_H */
171 
172