1 /*
2  * Copyright (c) 1999-2000 Image Power, Inc. and the University of
3  *   British Columbia.
4  * Copyright (c) 2001-2003 Michael David Adams.
5  * All rights reserved.
6  */
7 
8 /* __START_OF_JASPER_LICENSE__
9  *
10  * JasPer License Version 2.0
11  *
12  * Copyright (c) 2001-2006 Michael David Adams
13  * Copyright (c) 1999-2000 Image Power, Inc.
14  * Copyright (c) 1999-2000 The University of British Columbia
15  *
16  * All rights reserved.
17  *
18  * Permission is hereby granted, free of charge, to any person (the
19  * "User") obtaining a copy of this software and associated documentation
20  * files (the "Software"), to deal in the Software without restriction,
21  * including without limitation the rights to use, copy, modify, merge,
22  * publish, distribute, and/or sell copies of the Software, and to permit
23  * persons to whom the Software is furnished to do so, subject to the
24  * following conditions:
25  *
26  * 1.  The above copyright notices and this permission notice (which
27  * includes the disclaimer below) shall be included in all copies or
28  * substantial portions of the Software.
29  *
30  * 2.  The name of a copyright holder shall not be used to endorse or
31  * promote products derived from the Software without specific prior
32  * written permission.
33  *
34  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
35  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
36  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
37  * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
38  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
39  * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO
40  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
41  * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
42  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
43  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
44  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE
45  * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
46  * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
47  * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
48  * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
49  * PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS
50  * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
51  * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE
52  * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
53  * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
54  * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
55  * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
56  * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
57  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
58  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
59  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
60  *
61  * __END_OF_JASPER_LICENSE__
62  */
63 
64 /*
65  * Image Library
66  *
67  * $Id: jas_image.c,v 1.2 2008-05-26 09:40:52 vp153 Exp $
68  */
69 
70 /******************************************************************************\
71 * Includes.
72 \******************************************************************************/
73 
74 #include <stdlib.h>
75 #include <stdio.h>
76 #include <string.h>
77 #include <assert.h>
78 #include <ctype.h>
79 
80 #include "jasper/jas_math.h"
81 #include "jasper/jas_image.h"
82 #include "jasper/jas_malloc.h"
83 #include "jasper/jas_string.h"
84 
85 /******************************************************************************\
86 * Types.
87 \******************************************************************************/
88 
89 #define	FLOORDIV(x, y) ((x) / (y))
90 
91 /******************************************************************************\
92 * Local prototypes.
93 \******************************************************************************/
94 
95 static jas_image_cmpt_t *jas_image_cmpt_create0(void);
96 static void jas_image_cmpt_destroy(jas_image_cmpt_t *cmpt);
97 static jas_image_cmpt_t *jas_image_cmpt_create(uint_fast32_t tlx, uint_fast32_t tly,
98   uint_fast32_t hstep, uint_fast32_t vstep, uint_fast32_t width, uint_fast32_t
99   height, uint_fast16_t depth, bool sgnd, uint_fast32_t inmem);
100 static void jas_image_setbbox(jas_image_t *image);
101 static jas_image_cmpt_t *jas_image_cmpt_copy(jas_image_cmpt_t *cmpt);
102 static int jas_image_growcmpts(jas_image_t *image, int maxcmpts);
103 static uint_fast32_t inttobits(jas_seqent_t v, int prec, bool sgnd);
104 static jas_seqent_t bitstoint(uint_fast32_t v, int prec, bool sgnd);
105 static int putint(jas_stream_t *out, int sgnd, int prec, long val);
106 static int getint(jas_stream_t *in, int sgnd, int prec, long *val);
107 static void jas_image_calcbbox2(jas_image_t *image, jas_image_coord_t *tlx,
108   jas_image_coord_t *tly, jas_image_coord_t *brx, jas_image_coord_t *bry);
109 static long uptomult(long x, long y);
110 static long downtomult(long x, long y);
111 static long convert(long val, int oldsgnd, int oldprec, int newsgnd,
112   int newprec);
113 static void jas_image_calcbbox2(jas_image_t *image, jas_image_coord_t *tlx,
114   jas_image_coord_t *tly, jas_image_coord_t *brx, jas_image_coord_t *bry);
115 
116 /******************************************************************************\
117 * Global data.
118 \******************************************************************************/
119 
120 static int jas_image_numfmts = 0;
121 static jas_image_fmtinfo_t jas_image_fmtinfos[JAS_IMAGE_MAXFMTS];
122 
123 /******************************************************************************\
124 * Create and destroy operations.
125 \******************************************************************************/
126 
jas_image_create(int numcmpts,jas_image_cmptparm_t * cmptparms,int clrspc)127 jas_image_t *jas_image_create(int numcmpts, jas_image_cmptparm_t *cmptparms,
128   int clrspc)
129 {
130     jas_image_t *image;
131     uint_fast32_t rawsize;
132     uint_fast32_t inmem;
133     int cmptno;
134     jas_image_cmptparm_t *cmptparm;
135 
136     if (!(image = jas_image_create0())) {
137         return 0;
138     }
139 
140     image->clrspc_ = clrspc;
141     image->maxcmpts_ = numcmpts;
142     image->inmem_ = true;
143 
144     /* Allocate memory for the per-component information. */
145     if (!(image->cmpts_ = jas_alloc2(image->maxcmpts_,
146       sizeof(jas_image_cmpt_t *)))) {
147         jas_image_destroy(image);
148         return 0;
149     }
150     /* Initialize in case of failure. */
151     for (cmptno = 0; cmptno < image->maxcmpts_; ++cmptno) {
152         image->cmpts_[cmptno] = 0;
153     }
154 
155     /* Compute the approximate raw size of the image. */
156     rawsize = 0;
157     for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno,
158       ++cmptparm) {
159         rawsize += cmptparm->width * cmptparm->height *
160           (cmptparm->prec + 7) / 8;
161     }
162     /* Decide whether to buffer the image data in memory, based on the
163       raw size of the image. */
164     inmem = (rawsize < JAS_IMAGE_INMEMTHRESH);
165 
166     /* Create the individual image components. */
167     for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno,
168       ++cmptparm) {
169         if (!(image->cmpts_[cmptno] = jas_image_cmpt_create(cmptparm->tlx,
170           cmptparm->tly, cmptparm->hstep, cmptparm->vstep,
171           cmptparm->width, cmptparm->height, cmptparm->prec,
172           cmptparm->sgnd, inmem))) {
173             jas_image_destroy(image);
174             return 0;
175         }
176         ++image->numcmpts_;
177     }
178 
179     /* Determine the bounding box for all of the components on the
180       reference grid (i.e., the image area) */
181     jas_image_setbbox(image);
182 
183     return image;
184 }
185 
jas_image_create0()186 jas_image_t *jas_image_create0()
187 {
188     jas_image_t *image;
189 
190     if (!(image = jas_malloc(sizeof(jas_image_t)))) {
191         return 0;
192     }
193 
194     image->tlx_ = 0;
195     image->tly_ = 0;
196     image->brx_ = 0;
197     image->bry_ = 0;
198     image->clrspc_ = JAS_CLRSPC_UNKNOWN;
199     image->numcmpts_ = 0;
200     image->maxcmpts_ = 0;
201     image->cmpts_ = 0;
202     image->inmem_ = true;
203     image->cmprof_ = 0;
204 
205     return image;
206 }
207 
jas_image_copy(jas_image_t * image)208 jas_image_t *jas_image_copy(jas_image_t *image)
209 {
210     jas_image_t *newimage;
211     int cmptno;
212 
213     newimage = jas_image_create0();
214     if (jas_image_growcmpts(newimage, image->numcmpts_)) {
215         goto error;
216     }
217     for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {
218         if (!(newimage->cmpts_[cmptno] = jas_image_cmpt_copy(image->cmpts_[cmptno]))) {
219             goto error;
220         }
221         ++newimage->numcmpts_;
222     }
223 
224     jas_image_setbbox(newimage);
225 
226     if (image->cmprof_) {
227         if (!(newimage->cmprof_ = jas_cmprof_copy(image->cmprof_)))
228             goto error;
229     }
230 
231     return newimage;
232 error:
233     if (newimage) {
234         jas_image_destroy(newimage);
235     }
236     return 0;
237 }
238 
jas_image_cmpt_create0()239 static jas_image_cmpt_t *jas_image_cmpt_create0()
240 {
241     jas_image_cmpt_t *cmpt;
242     if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) {
243         return 0;
244     }
245     memset(cmpt, 0, sizeof(jas_image_cmpt_t));
246     cmpt->type_ = JAS_IMAGE_CT_UNKNOWN;
247     return cmpt;
248 }
249 
jas_image_cmpt_copy(jas_image_cmpt_t * cmpt)250 static jas_image_cmpt_t *jas_image_cmpt_copy(jas_image_cmpt_t *cmpt)
251 {
252     jas_image_cmpt_t *newcmpt;
253 
254     if (!(newcmpt = jas_image_cmpt_create0())) {
255         return 0;
256     }
257     newcmpt->tlx_ = cmpt->tlx_;
258     newcmpt->tly_ = cmpt->tly_;
259     newcmpt->hstep_ = cmpt->hstep_;
260     newcmpt->vstep_ = cmpt->vstep_;
261     newcmpt->width_ = cmpt->width_;
262     newcmpt->height_ = cmpt->height_;
263     newcmpt->prec_ = cmpt->prec_;
264     newcmpt->sgnd_ = cmpt->sgnd_;
265     newcmpt->cps_ = cmpt->cps_;
266     newcmpt->type_ = cmpt->type_;
267     if (!(newcmpt->stream_ = jas_stream_memopen(0, 0))) {
268         return 0;
269     }
270     if (jas_stream_seek(cmpt->stream_, 0, SEEK_SET)) {
271         return 0;
272     }
273     if (jas_stream_copy(newcmpt->stream_, cmpt->stream_, -1)) {
274         return 0;
275     }
276     if (jas_stream_seek(newcmpt->stream_, 0, SEEK_SET)) {
277         return 0;
278     }
279     return newcmpt;
280 }
281 
jas_image_destroy(jas_image_t * image)282 void jas_image_destroy(jas_image_t *image)
283 {
284     int i;
285 
286     if (image->cmpts_) {
287         for (i = 0; i < image->numcmpts_; ++i) {
288             jas_image_cmpt_destroy(image->cmpts_[i]);
289             image->cmpts_[i] = 0;
290         }
291         jas_free(image->cmpts_);
292     }
293     if (image->cmprof_)
294         jas_cmprof_destroy(image->cmprof_);
295     jas_free(image);
296 }
297 
jas_image_cmpt_create(uint_fast32_t tlx,uint_fast32_t tly,uint_fast32_t hstep,uint_fast32_t vstep,uint_fast32_t width,uint_fast32_t height,uint_fast16_t depth,bool sgnd,uint_fast32_t inmem)298 static jas_image_cmpt_t *jas_image_cmpt_create(uint_fast32_t tlx, uint_fast32_t tly,
299   uint_fast32_t hstep, uint_fast32_t vstep, uint_fast32_t width, uint_fast32_t
300   height, uint_fast16_t depth, bool sgnd, uint_fast32_t inmem)
301 {
302     jas_image_cmpt_t *cmpt;
303     long size;
304 
305     if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) {
306         return 0;
307     }
308 
309     cmpt->type_ = JAS_IMAGE_CT_UNKNOWN;
310     cmpt->tlx_ = tlx;
311     cmpt->tly_ = tly;
312     cmpt->hstep_ = hstep;
313     cmpt->vstep_ = vstep;
314     cmpt->width_ = width;
315     cmpt->height_ = height;
316     cmpt->prec_ = depth;
317     cmpt->sgnd_ = sgnd;
318     cmpt->stream_ = 0;
319     cmpt->cps_ = (depth + 7) / 8;
320 
321     size = cmpt->width_ * cmpt->height_ * cmpt->cps_;
322     cmpt->stream_ = (inmem) ? jas_stream_memopen(0, size) : jas_stream_tmpfile();
323     if (!cmpt->stream_) {
324         jas_image_cmpt_destroy(cmpt);
325         return 0;
326     }
327 
328     /* Zero the component data.  This isn't necessary, but it is
329     convenient for debugging purposes. */
330     if (jas_stream_seek(cmpt->stream_, size - 1, SEEK_SET) < 0 ||
331       jas_stream_putc(cmpt->stream_, 0) == EOF ||
332       jas_stream_seek(cmpt->stream_, 0, SEEK_SET) < 0) {
333         jas_image_cmpt_destroy(cmpt);
334         return 0;
335     }
336 
337     return cmpt;
338 }
339 
jas_image_cmpt_destroy(jas_image_cmpt_t * cmpt)340 static void jas_image_cmpt_destroy(jas_image_cmpt_t *cmpt)
341 {
342     if (cmpt->stream_) {
343         jas_stream_close(cmpt->stream_);
344     }
345     jas_free(cmpt);
346 }
347 
348 /******************************************************************************\
349 * Load and save operations.
350 \******************************************************************************/
351 
jas_image_decode(jas_stream_t * in,int fmt,char * optstr)352 jas_image_t *jas_image_decode(jas_stream_t *in, int fmt, char *optstr)
353 {
354     jas_image_fmtinfo_t *fmtinfo;
355     jas_image_t *image;
356 
357     image = 0;
358 
359     /* If possible, try to determine the format of the input data. */
360     if (fmt < 0) {
361         if ((fmt = jas_image_getfmt(in)) < 0)
362             goto error;
363     }
364 
365     /* Is it possible to decode an image represented in this format? */
366     if (!(fmtinfo = jas_image_lookupfmtbyid(fmt)))
367         goto error;
368     if (!fmtinfo->ops.decode)
369         goto error;
370 
371     /* Decode the image. */
372     if (!(image = (*fmtinfo->ops.decode)(in, optstr)))
373         goto error;
374 
375     /* Create a color profile if needed. */
376     if (!jas_clrspc_isunknown(image->clrspc_) &&
377       !jas_clrspc_isgeneric(image->clrspc_) && !image->cmprof_) {
378         if (!(image->cmprof_ =
379           jas_cmprof_createfromclrspc(jas_image_clrspc(image))))
380             goto error;
381     }
382 
383     return image;
384 error:
385     if (image)
386         jas_image_destroy(image);
387     return 0;
388 }
389 
jas_image_encode(jas_image_t * image,jas_stream_t * out,int fmt,char * optstr)390 int jas_image_encode(jas_image_t *image, jas_stream_t *out, int fmt, char *optstr)
391 {
392     jas_image_fmtinfo_t *fmtinfo;
393     if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) {
394         return -1;
395     }
396     return (fmtinfo->ops.encode) ? (*fmtinfo->ops.encode)(image, out,
397       optstr) : (-1);
398 }
399 
400 /******************************************************************************\
401 * Component read and write operations.
402 \******************************************************************************/
403 
jas_image_readcmpt(jas_image_t * image,int cmptno,jas_image_coord_t x,jas_image_coord_t y,jas_image_coord_t width,jas_image_coord_t height,jas_matrix_t * data)404 int jas_image_readcmpt(jas_image_t *image, int cmptno, jas_image_coord_t x,
405   jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
406   jas_matrix_t *data)
407 {
408     jas_image_cmpt_t *cmpt;
409     jas_image_coord_t i;
410     jas_image_coord_t j;
411     int k;
412     jas_seqent_t v;
413     int c;
414     jas_seqent_t *dr;
415     jas_seqent_t *d;
416     int drs;
417 
418     if (cmptno < 0 || cmptno >= image->numcmpts_) {
419         return -1;
420     }
421 
422     cmpt = image->cmpts_[cmptno];
423     if (x >= cmpt->width_ || y >= cmpt->height_ ||
424       x + width > cmpt->width_ ||
425       y + height > cmpt->height_) {
426         return -1;
427     }
428 
429     if (jas_matrix_numrows(data) != height || jas_matrix_numcols(data) != width) {
430         if (jas_matrix_resize(data, height, width)) {
431             return -1;
432         }
433     }
434 
435     dr = jas_matrix_getref(data, 0, 0);
436     drs = jas_matrix_rowstep(data);
437     for (i = 0; i < height; ++i, dr += drs) {
438         d = dr;
439         if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
440           * cmpt->cps_, SEEK_SET) < 0) {
441             return -1;
442         }
443         for (j = width; j > 0; --j, ++d) {
444             v = 0;
445             for (k = cmpt->cps_; k > 0; --k) {
446                 if ((c = jas_stream_getc(cmpt->stream_)) == EOF) {
447                     return -1;
448                 }
449                 v = (v << 8) | (c & 0xff);
450             }
451             *d = bitstoint(v, cmpt->prec_, cmpt->sgnd_);
452         }
453     }
454 
455     return 0;
456 }
457 
jas_image_writecmpt(jas_image_t * image,int cmptno,jas_image_coord_t x,jas_image_coord_t y,jas_image_coord_t width,jas_image_coord_t height,jas_matrix_t * data)458 int jas_image_writecmpt(jas_image_t *image, int cmptno, jas_image_coord_t x, jas_image_coord_t y, jas_image_coord_t width,
459   jas_image_coord_t height, jas_matrix_t *data)
460 {
461     jas_image_cmpt_t *cmpt;
462     jas_image_coord_t i;
463     jas_image_coord_t j;
464     jas_seqent_t *d;
465     jas_seqent_t *dr;
466     int drs;
467     jas_seqent_t v;
468     int k;
469     int c;
470 
471     if (cmptno < 0 || cmptno >= image->numcmpts_) {
472         return -1;
473     }
474 
475     cmpt = image->cmpts_[cmptno];
476     if (x >= cmpt->width_ || y >= cmpt->height_ ||
477       x + width > cmpt->width_ ||
478       y + height > cmpt->height_) {
479         return -1;
480     }
481 
482     if (jas_matrix_numrows(data) != height || jas_matrix_numcols(data) != width) {
483         return -1;
484     }
485 
486     dr = jas_matrix_getref(data, 0, 0);
487     drs = jas_matrix_rowstep(data);
488     for (i = 0; i < height; ++i, dr += drs) {
489         d = dr;
490         if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
491           * cmpt->cps_, SEEK_SET) < 0) {
492             return -1;
493         }
494         for (j = width; j > 0; --j, ++d) {
495             v = inttobits(*d, cmpt->prec_, cmpt->sgnd_);
496             for (k = cmpt->cps_; k > 0; --k) {
497                 c = (v >> (8 * (cmpt->cps_ - 1))) & 0xff;
498                 if (jas_stream_putc(cmpt->stream_,
499                   (unsigned char) c) == EOF) {
500                     return -1;
501                 }
502                 v <<= 8;
503             }
504         }
505     }
506 
507     return 0;
508 }
509 
510 /******************************************************************************\
511 * File format operations.
512 \******************************************************************************/
513 
jas_image_clearfmts()514 void jas_image_clearfmts()
515 {
516     int i;
517     jas_image_fmtinfo_t *fmtinfo;
518     for (i = 0; i < jas_image_numfmts; ++i) {
519         fmtinfo = &jas_image_fmtinfos[i];
520         if (fmtinfo->name) {
521             jas_free(fmtinfo->name);
522             fmtinfo->name = 0;
523         }
524         if (fmtinfo->ext) {
525             jas_free(fmtinfo->ext);
526             fmtinfo->ext = 0;
527         }
528         if (fmtinfo->desc) {
529             jas_free(fmtinfo->desc);
530             fmtinfo->desc = 0;
531         }
532     }
533     jas_image_numfmts = 0;
534 }
535 
jas_image_addfmt(int id,char * name,char * ext,char * desc,jas_image_fmtops_t * ops)536 int jas_image_addfmt(int id, char *name, char *ext, char *desc,
537   jas_image_fmtops_t *ops)
538 {
539     jas_image_fmtinfo_t *fmtinfo;
540     assert(id >= 0 && name && ext && ops);
541     if (jas_image_numfmts >= JAS_IMAGE_MAXFMTS) {
542         return -1;
543     }
544     fmtinfo = &jas_image_fmtinfos[jas_image_numfmts];
545     fmtinfo->id = id;
546     if (!(fmtinfo->name = jas_strdup(name))) {
547         return -1;
548     }
549     if (!(fmtinfo->ext = jas_strdup(ext))) {
550         jas_free(fmtinfo->name);
551         return -1;
552     }
553     if (!(fmtinfo->desc = jas_strdup(desc))) {
554         jas_free(fmtinfo->name);
555         jas_free(fmtinfo->ext);
556         return -1;
557     }
558     fmtinfo->ops = *ops;
559     ++jas_image_numfmts;
560     return 0;
561 }
562 
jas_image_strtofmt(char * name)563 int jas_image_strtofmt(char *name)
564 {
565     jas_image_fmtinfo_t *fmtinfo;
566     if (!(fmtinfo = jas_image_lookupfmtbyname(name))) {
567         return -1;
568     }
569     return fmtinfo->id;
570 }
571 
jas_image_fmttostr(int fmt)572 char *jas_image_fmttostr(int fmt)
573 {
574     jas_image_fmtinfo_t *fmtinfo;
575     if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) {
576         return 0;
577     }
578     return fmtinfo->name;
579 }
580 
jas_image_getfmt(jas_stream_t * in)581 int jas_image_getfmt(jas_stream_t *in)
582 {
583     jas_image_fmtinfo_t *fmtinfo;
584     int found;
585     int i;
586 
587     /* Check for data in each of the supported formats. */
588     found = 0;
589     for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i,
590       ++fmtinfo) {
591         if (fmtinfo->ops.validate) {
592             /* Is the input data valid for this format? */
593             if (!(*fmtinfo->ops.validate)(in)) {
594                 found = 1;
595                 break;
596             }
597         }
598     }
599     return found ? fmtinfo->id : (-1);
600 }
601 
jas_image_fmtfromname(char * name)602 int jas_image_fmtfromname(char *name)
603 {
604     int i;
605     char *ext;
606     jas_image_fmtinfo_t *fmtinfo;
607     /* Get the file name extension. */
608     if (!(ext = strrchr(name, '.'))) {
609         return -1;
610     }
611     ++ext;
612     /* Try to find a format that uses this extension. */
613     for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i,
614       ++fmtinfo) {
615         /* Do we have a match? */
616         if (!strcmp(ext, fmtinfo->ext)) {
617             return fmtinfo->id;
618         }
619     }
620     return -1;
621 }
622 
623 /******************************************************************************\
624 * Miscellaneous operations.
625 \******************************************************************************/
626 
jas_image_rawsize(jas_image_t * image)627 uint_fast32_t jas_image_rawsize(jas_image_t *image)
628 {
629     uint_fast32_t rawsize;
630     int cmptno;
631     jas_image_cmpt_t *cmpt;
632 
633     rawsize = 0;
634     for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {
635         cmpt = image->cmpts_[cmptno];
636         rawsize += (cmpt->width_ * cmpt->height_ * cmpt->prec_ +
637           7) / 8;
638     }
639     return rawsize;
640 }
641 
jas_image_delcmpt(jas_image_t * image,int cmptno)642 void jas_image_delcmpt(jas_image_t *image, int cmptno)
643 {
644     if (cmptno >= image->numcmpts_) {
645         return;
646     }
647     jas_image_cmpt_destroy(image->cmpts_[cmptno]);
648     if (cmptno < image->numcmpts_) {
649         memmove(&image->cmpts_[cmptno], &image->cmpts_[cmptno + 1],
650           (image->numcmpts_ - 1 - cmptno) * sizeof(jas_image_cmpt_t *));
651     }
652     --image->numcmpts_;
653 
654     jas_image_setbbox(image);
655 }
656 
jas_image_addcmpt(jas_image_t * image,int cmptno,jas_image_cmptparm_t * cmptparm)657 int jas_image_addcmpt(jas_image_t *image, int cmptno,
658   jas_image_cmptparm_t *cmptparm)
659 {
660     jas_image_cmpt_t *newcmpt;
661     if (cmptno < 0)
662         cmptno = image->numcmpts_;
663     assert(cmptno >= 0 && cmptno <= image->numcmpts_);
664     if (image->numcmpts_ >= image->maxcmpts_) {
665         if (jas_image_growcmpts(image, image->maxcmpts_ + 128)) {
666             return -1;
667         }
668     }
669     if (!(newcmpt = jas_image_cmpt_create(cmptparm->tlx,
670       cmptparm->tly, cmptparm->hstep, cmptparm->vstep,
671       cmptparm->width, cmptparm->height, cmptparm->prec,
672       cmptparm->sgnd, 1))) {
673         return -1;
674     }
675     if (cmptno < image->numcmpts_) {
676         memmove(&image->cmpts_[cmptno + 1], &image->cmpts_[cmptno],
677           (image->numcmpts_ - cmptno) * sizeof(jas_image_cmpt_t *));
678     }
679     image->cmpts_[cmptno] = newcmpt;
680     ++image->numcmpts_;
681 
682     jas_image_setbbox(image);
683 
684     return 0;
685 }
686 
jas_image_lookupfmtbyid(int id)687 jas_image_fmtinfo_t *jas_image_lookupfmtbyid(int id)
688 {
689     int i;
690     jas_image_fmtinfo_t *fmtinfo;
691 
692     for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, ++fmtinfo) {
693         if (fmtinfo->id == id) {
694             return fmtinfo;
695         }
696     }
697     return 0;
698 }
699 
jas_image_lookupfmtbyname(const char * name)700 jas_image_fmtinfo_t *jas_image_lookupfmtbyname(const char *name)
701 {
702     int i;
703     jas_image_fmtinfo_t *fmtinfo;
704 
705     for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, ++fmtinfo) {
706         if (!strcmp(fmtinfo->name, name)) {
707             return fmtinfo;
708         }
709     }
710     return 0;
711 }
712 
713 
714 
715 
716 
inttobits(jas_seqent_t v,int prec,bool sgnd)717 static uint_fast32_t inttobits(jas_seqent_t v, int prec, bool sgnd)
718 {
719     uint_fast32_t ret;
720     ret = ((sgnd && v < 0) ? ((1 << prec) + v) : v) & JAS_ONES(prec);
721     return ret;
722 }
723 
bitstoint(uint_fast32_t v,int prec,bool sgnd)724 static jas_seqent_t bitstoint(uint_fast32_t v, int prec, bool sgnd)
725 {
726     jas_seqent_t ret;
727     v &= JAS_ONES(prec);
728     ret = (sgnd && (v & (1 << (prec - 1)))) ? (v - (1 << prec)) : v;
729     return ret;
730 }
731 
jas_image_setbbox(jas_image_t * image)732 static void jas_image_setbbox(jas_image_t *image)
733 {
734     jas_image_cmpt_t *cmpt;
735     int cmptno;
736     int_fast32_t x;
737     int_fast32_t y;
738 
739     if (image->numcmpts_ > 0) {
740         /* Determine the bounding box for all of the components on the
741           reference grid (i.e., the image area) */
742         cmpt = image->cmpts_[0];
743         image->tlx_ = cmpt->tlx_;
744         image->tly_ = cmpt->tly_;
745         image->brx_ = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1) + 1;
746         image->bry_ = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1) + 1;
747         for (cmptno = 1; cmptno < image->numcmpts_; ++cmptno) {
748             cmpt = image->cmpts_[cmptno];
749             if (image->tlx_ > cmpt->tlx_) {
750                 image->tlx_ = cmpt->tlx_;
751             }
752             if (image->tly_ > cmpt->tly_) {
753                 image->tly_ = cmpt->tly_;
754             }
755             x = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1) + 1;
756             if (image->brx_ < x) {
757                 image->brx_ = x;
758             }
759             y = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1) + 1;
760             if (image->bry_ < y) {
761                 image->bry_ = y;
762             }
763         }
764     } else {
765         image->tlx_ = 0;
766         image->tly_ = 0;
767         image->brx_ = 0;
768         image->bry_ = 0;
769     }
770 }
771 
jas_image_growcmpts(jas_image_t * image,int maxcmpts)772 static int jas_image_growcmpts(jas_image_t *image, int maxcmpts)
773 {
774     jas_image_cmpt_t **newcmpts;
775     int cmptno;
776 
777     newcmpts = jas_realloc2(image->cmpts_, maxcmpts, sizeof(jas_image_cmpt_t *));
778     if (!newcmpts) {
779         return -1;
780     }
781     image->cmpts_ = newcmpts;
782     image->maxcmpts_ = maxcmpts;
783     for (cmptno = image->numcmpts_; cmptno < image->maxcmpts_; ++cmptno) {
784         image->cmpts_[cmptno] = 0;
785     }
786     return 0;
787 }
788 
jas_image_copycmpt(jas_image_t * dstimage,int dstcmptno,jas_image_t * srcimage,int srccmptno)789 int jas_image_copycmpt(jas_image_t *dstimage, int dstcmptno, jas_image_t *srcimage,
790   int srccmptno)
791 {
792     jas_image_cmpt_t *newcmpt;
793     if (dstimage->numcmpts_ >= dstimage->maxcmpts_) {
794         if (jas_image_growcmpts(dstimage, dstimage->maxcmpts_ + 128)) {
795             return -1;
796         }
797     }
798     if (!(newcmpt = jas_image_cmpt_copy(srcimage->cmpts_[srccmptno]))) {
799         return -1;
800     }
801     if (dstcmptno < dstimage->numcmpts_) {
802         memmove(&dstimage->cmpts_[dstcmptno + 1], &dstimage->cmpts_[dstcmptno],
803           (dstimage->numcmpts_ - dstcmptno) * sizeof(jas_image_cmpt_t *));
804     }
805     dstimage->cmpts_[dstcmptno] = newcmpt;
806     ++dstimage->numcmpts_;
807 
808     jas_image_setbbox(dstimage);
809     return 0;
810 }
811 
jas_image_dump(jas_image_t * image,FILE * out)812 void jas_image_dump(jas_image_t *image, FILE *out)
813 {
814     long buf[1024];
815     int cmptno;
816     int n;
817     int i;
818     int width;
819     int height;
820     jas_image_cmpt_t *cmpt;
821     for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {
822         cmpt = image->cmpts_[cmptno];
823         fprintf(out, "prec=%d, sgnd=%d, cmpttype=%d\n", cmpt->prec_,
824           cmpt->sgnd_, (int)cmpt->type_);
825         width = jas_image_cmptwidth(image, cmptno);
826         height = jas_image_cmptheight(image, cmptno);
827         n = JAS_MIN(16, width);
828         if (jas_image_readcmpt2(image, cmptno, 0, 0, n, 1, buf)) {
829             abort();
830         }
831         for (i = 0; i < n; ++i) {
832             fprintf(out, " f(%d,%d)=%ld", i, 0, buf[i]);
833         }
834         fprintf(out, "\n");
835         if (jas_image_readcmpt2(image, cmptno, width - n, height - 1, n, 1, buf)) {
836             abort();
837         }
838         for (i = 0; i < n; ++i) {
839             fprintf(out, " f(%d,%d)=%ld", width - n + i, height - 1, buf[i]);
840         }
841         fprintf(out, "\n");
842     }
843 }
844 
jas_image_depalettize(jas_image_t * image,int cmptno,int numlutents,int_fast32_t * lutents,int dtype,int newcmptno)845 int jas_image_depalettize(jas_image_t *image, int cmptno, int numlutents,
846   int_fast32_t *lutents, int dtype, int newcmptno)
847 {
848     jas_image_cmptparm_t cmptparms;
849     int_fast32_t v;
850     int i;
851     int j;
852     jas_image_cmpt_t *cmpt;
853 
854     cmpt = image->cmpts_[cmptno];
855     cmptparms.tlx = cmpt->tlx_;
856     cmptparms.tly = cmpt->tly_;
857     cmptparms.hstep = cmpt->hstep_;
858     cmptparms.vstep = cmpt->vstep_;
859     cmptparms.width = cmpt->width_;
860     cmptparms.height = cmpt->height_;
861     cmptparms.prec = JAS_IMAGE_CDT_GETPREC(dtype);
862     cmptparms.sgnd = JAS_IMAGE_CDT_GETSGND(dtype);
863 
864     if (jas_image_addcmpt(image, newcmptno, &cmptparms)) {
865         return -1;
866     }
867     if (newcmptno <= cmptno) {
868         ++cmptno;
869         cmpt = image->cmpts_[cmptno];
870     }
871 
872     for (j = 0; j < cmpt->height_; ++j) {
873         for (i = 0; i < cmpt->width_; ++i) {
874             v = jas_image_readcmptsample(image, cmptno, i, j);
875             if (v < 0) {
876                 v = 0;
877             } else if (v >= numlutents) {
878                 v = numlutents - 1;
879             }
880             jas_image_writecmptsample(image, newcmptno, i, j,
881               lutents[v]);
882         }
883     }
884     return 0;
885 }
886 
jas_image_readcmptsample(jas_image_t * image,int cmptno,int x,int y)887 int jas_image_readcmptsample(jas_image_t *image, int cmptno, int x, int y)
888 {
889     jas_image_cmpt_t *cmpt;
890     uint_fast32_t v;
891     int k;
892     int c;
893 
894     cmpt = image->cmpts_[cmptno];
895 
896     if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_,
897       SEEK_SET) < 0) {
898         return -1;
899     }
900     v = 0;
901     for (k = cmpt->cps_; k > 0; --k) {
902         if ((c = jas_stream_getc(cmpt->stream_)) == EOF) {
903             return -1;
904         }
905         v = (v << 8) | (c & 0xff);
906     }
907     return bitstoint(v, cmpt->prec_, cmpt->sgnd_);
908 }
909 
jas_image_writecmptsample(jas_image_t * image,int cmptno,int x,int y,int_fast32_t v)910 void jas_image_writecmptsample(jas_image_t *image, int cmptno, int x, int y,
911   int_fast32_t v)
912 {
913     jas_image_cmpt_t *cmpt;
914     uint_fast32_t t;
915     int k;
916     int c;
917 
918     cmpt = image->cmpts_[cmptno];
919 
920     if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_,
921       SEEK_SET) < 0) {
922         return;
923     }
924     t = inttobits(v, cmpt->prec_, cmpt->sgnd_);
925     for (k = cmpt->cps_; k > 0; --k) {
926         c = (t >> (8 * (cmpt->cps_ - 1))) & 0xff;
927         if (jas_stream_putc(cmpt->stream_, (unsigned char) c) == EOF) {
928             return;
929         }
930         t <<= 8;
931     }
932 }
933 
jas_image_getcmptbytype(jas_image_t * image,int ctype)934 int jas_image_getcmptbytype(jas_image_t *image, int ctype)
935 {
936     int cmptno;
937 
938     for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {
939         if (image->cmpts_[cmptno]->type_ == ctype) {
940             return cmptno;
941         }
942     }
943     return -1;
944 }
945 
946 
947 
948 
949 
950 
951 
952 
953 
954 
955 
956 
957 
958 
959 
960 
961 /***********************************************/
962 /***********************************************/
963 /***********************************************/
964 /***********************************************/
965 
jas_image_readcmpt2(jas_image_t * image,int cmptno,jas_image_coord_t x,jas_image_coord_t y,jas_image_coord_t width,jas_image_coord_t height,long * buf)966 int jas_image_readcmpt2(jas_image_t *image, int cmptno, jas_image_coord_t x,
967   jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
968   long *buf)
969 {
970     jas_image_cmpt_t *cmpt;
971     jas_image_coord_t i;
972     jas_image_coord_t j;
973     long v;
974     long *bufptr;
975 
976     if (cmptno < 0 || cmptno >= image->numcmpts_)
977         goto error;
978     cmpt = image->cmpts_[cmptno];
979     if (x < 0 || x >= cmpt->width_ || y < 0 || y >= cmpt->height_ ||
980       width < 0 || height < 0 || x + width > cmpt->width_ ||
981       y + height > cmpt->height_)
982         goto error;
983 
984     bufptr = buf;
985     for (i = 0; i < height; ++i) {
986         if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
987           * cmpt->cps_, SEEK_SET) < 0)
988             goto error;
989         for (j = 0; j < width; ++j) {
990             if (getint(cmpt->stream_, cmpt->sgnd_, cmpt->prec_, &v))
991                 goto error;
992             *bufptr++ = v;
993         }
994     }
995 
996     return 0;
997 error:
998     return -1;
999 }
1000 
jas_image_writecmpt2(jas_image_t * image,int cmptno,jas_image_coord_t x,jas_image_coord_t y,jas_image_coord_t width,jas_image_coord_t height,long * buf)1001 int jas_image_writecmpt2(jas_image_t *image, int cmptno, jas_image_coord_t x,
1002   jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
1003   long *buf)
1004 {
1005     jas_image_cmpt_t *cmpt;
1006     jas_image_coord_t i;
1007     jas_image_coord_t j;
1008     long v;
1009     long *bufptr;
1010 
1011     if (cmptno < 0 || cmptno >= image->numcmpts_)
1012         goto error;
1013     cmpt = image->cmpts_[cmptno];
1014     if (x < 0 || x >= cmpt->width_ || y < 0 || y >= cmpt->height_ ||
1015       width < 0 || height < 0 || x + width > cmpt->width_ ||
1016       y + height > cmpt->height_)
1017         goto error;
1018 
1019     bufptr = buf;
1020     for (i = 0; i < height; ++i) {
1021         if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
1022           * cmpt->cps_, SEEK_SET) < 0)
1023             goto error;
1024         for (j = 0; j < width; ++j) {
1025             v = *bufptr++;
1026             if (putint(cmpt->stream_, cmpt->sgnd_, cmpt->prec_, v))
1027                 goto error;
1028         }
1029     }
1030 
1031     return 0;
1032 error:
1033     return -1;
1034 }
1035 
jas_image_sampcmpt(jas_image_t * image,int cmptno,int newcmptno,jas_image_coord_t ho,jas_image_coord_t vo,jas_image_coord_t hs,jas_image_coord_t vs,int sgnd,int prec)1036 int jas_image_sampcmpt(jas_image_t *image, int cmptno, int newcmptno,
1037   jas_image_coord_t ho, jas_image_coord_t vo, jas_image_coord_t hs,
1038   jas_image_coord_t vs, int sgnd, int prec)
1039 {
1040     jas_image_cmpt_t *oldcmpt;
1041     jas_image_cmpt_t *newcmpt;
1042     int width;
1043     int height;
1044     jas_image_coord_t tlx;
1045     jas_image_coord_t tly;
1046     jas_image_coord_t brx;
1047     jas_image_coord_t bry;
1048     int i;
1049     int j;
1050     jas_image_cmptparm_t cmptparm;
1051     jas_image_coord_t ax;
1052     jas_image_coord_t ay;
1053     jas_image_coord_t bx;
1054     jas_image_coord_t by;
1055     jas_image_coord_t d0;
1056     jas_image_coord_t d1;
1057     jas_image_coord_t d2;
1058     jas_image_coord_t d3;
1059     jas_image_coord_t oldx;
1060     jas_image_coord_t oldy;
1061     jas_image_coord_t x;
1062     jas_image_coord_t y;
1063     long v;
1064     jas_image_coord_t cmptbrx;
1065     jas_image_coord_t cmptbry;
1066 
1067     assert(cmptno >= 0 && cmptno < image->numcmpts_);
1068     oldcmpt = image->cmpts_[cmptno];
1069     assert(oldcmpt->tlx_ == 0 && oldcmpt->tly_ == 0);
1070     jas_image_calcbbox2(image, &tlx, &tly, &brx, &bry);
1071     width = FLOORDIV(brx - ho + hs, hs);
1072     height = FLOORDIV(bry - vo + vs, vs);
1073     cmptparm.tlx = ho;
1074     cmptparm.tly = vo;
1075     cmptparm.hstep = hs;
1076     cmptparm.vstep = vs;
1077     cmptparm.width = width;
1078     cmptparm.height = height;
1079     cmptparm.prec = prec;
1080     cmptparm.sgnd = sgnd;
1081     if (jas_image_addcmpt(image, newcmptno, &cmptparm))
1082         goto error;
1083 cmptbrx = oldcmpt->tlx_ + (oldcmpt->width_ - 1) * oldcmpt->hstep_;
1084 cmptbry = oldcmpt->tly_ + (oldcmpt->height_ - 1) * oldcmpt->vstep_;
1085     newcmpt = image->cmpts_[newcmptno];
1086     jas_stream_rewind(newcmpt->stream_);
1087     for (i = 0; i < height; ++i) {
1088         y = newcmpt->tly_ + newcmpt->vstep_ * i;
1089         for (j = 0; j < width; ++j) {
1090             x = newcmpt->tlx_ + newcmpt->hstep_ * j;
1091             ax = downtomult(x - oldcmpt->tlx_, oldcmpt->hstep_) + oldcmpt->tlx_;
1092             ay = downtomult(y - oldcmpt->tly_, oldcmpt->vstep_) + oldcmpt->tly_;
1093             bx = uptomult(x - oldcmpt->tlx_, oldcmpt->hstep_) + oldcmpt->tlx_;
1094             if (bx > cmptbrx)
1095                 bx = cmptbrx;
1096             by = uptomult(y - oldcmpt->tly_, oldcmpt->vstep_) + oldcmpt->tly_;
1097             if (by > cmptbry)
1098                 by = cmptbry;
1099             d0 = (ax - x) * (ax - x) + (ay - y) * (ay - y);
1100             d1 = (bx - x) * (bx - x) + (ay - y) * (ay - y);
1101             d2 = (bx - x) * (bx - x) + (by - y) * (by - y);
1102             d3 = (ax - x) * (ax - x) + (by - y) * (by - y);
1103             if (d0 <= d1 && d0 <= d2 && d0 <= d3) {
1104                 oldx = (ax - oldcmpt->tlx_) / oldcmpt->hstep_;
1105                 oldy = (ay - oldcmpt->tly_) / oldcmpt->vstep_;
1106             } else if (d1 <= d0 && d1 <= d2 && d1 <= d3) {
1107                 oldx = (bx - oldcmpt->tlx_) / oldcmpt->hstep_;
1108                 oldy = (ay - oldcmpt->tly_) / oldcmpt->vstep_;
1109             } else if (d2 <= d0 && d2 <= d1 && d1 <= d3) {
1110                 oldx = (bx - oldcmpt->tlx_) / oldcmpt->hstep_;
1111                 oldy = (by - oldcmpt->tly_) / oldcmpt->vstep_;
1112             } else {
1113                 oldx = (ax - oldcmpt->tlx_) / oldcmpt->hstep_;
1114                 oldy = (by - oldcmpt->tly_) / oldcmpt->vstep_;
1115             }
1116             assert(oldx >= 0 && oldx < oldcmpt->width_ &&
1117               oldy >= 0 && oldy < oldcmpt->height_);
1118             if (jas_stream_seek(oldcmpt->stream_, oldcmpt->cps_ *
1119               (oldy * oldcmpt->width_ + oldx), SEEK_SET) < 0)
1120                 goto error;
1121             if (getint(oldcmpt->stream_, oldcmpt->sgnd_,
1122               oldcmpt->prec_, &v))
1123                 goto error;
1124             if (newcmpt->prec_ != oldcmpt->prec_ ||
1125               newcmpt->sgnd_ != oldcmpt->sgnd_) {
1126                 v = convert(v, oldcmpt->sgnd_, oldcmpt->prec_,
1127                   newcmpt->sgnd_, newcmpt->prec_);
1128             }
1129             if (putint(newcmpt->stream_, newcmpt->sgnd_,
1130               newcmpt->prec_, v))
1131                 goto error;
1132         }
1133     }
1134     return 0;
1135 error:
1136     return -1;
1137 }
1138 
jas_image_ishomosamp(jas_image_t * image)1139 int jas_image_ishomosamp(jas_image_t *image)
1140 {
1141     jas_image_coord_t hstep;
1142     jas_image_coord_t vstep;
1143     int result;
1144     int i;
1145     hstep = jas_image_cmpthstep(image, 0);
1146     vstep = jas_image_cmptvstep(image, 0);
1147     result = 1;
1148     for (i = 0; i < image->numcmpts_; ++i) {
1149         if (jas_image_cmpthstep(image, i) != hstep ||
1150           jas_image_cmptvstep(image, i) != vstep) {
1151             result = 0;
1152             break;
1153         }
1154     }
1155     return result;
1156 }
1157 
1158 /* Note: This function defines a bounding box differently. */
jas_image_calcbbox2(jas_image_t * image,jas_image_coord_t * tlx,jas_image_coord_t * tly,jas_image_coord_t * brx,jas_image_coord_t * bry)1159 static void jas_image_calcbbox2(jas_image_t *image, jas_image_coord_t *tlx,
1160   jas_image_coord_t *tly, jas_image_coord_t *brx, jas_image_coord_t *bry)
1161 {
1162     jas_image_cmpt_t *cmpt;
1163     jas_image_coord_t tmptlx;
1164     jas_image_coord_t tmptly;
1165     jas_image_coord_t tmpbrx;
1166     jas_image_coord_t tmpbry;
1167     jas_image_coord_t t;
1168     int i;
1169     if (image->numcmpts_ > 0) {
1170         cmpt = image->cmpts_[0];
1171         tmptlx = cmpt->tlx_;
1172         tmptly = cmpt->tly_;
1173         tmpbrx = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1);
1174         tmpbry = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1);
1175         for (i = 0; i < image->numcmpts_; ++i) {
1176             cmpt = image->cmpts_[i];
1177             if (cmpt->tlx_ < tmptlx)
1178                 tmptlx = cmpt->tlx_;
1179             if (cmpt->tly_ < tmptly)
1180                 tmptly = cmpt->tly_;
1181             t = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1);
1182             if (t > tmpbrx)
1183                 tmpbrx = t;
1184             t = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1);
1185             if (t > tmpbry)
1186                 tmpbry = t;
1187         }
1188     } else {
1189         tmptlx = 0;
1190         tmptly = 0;
1191         tmpbrx = -1;
1192         tmpbry = -1;
1193     }
1194     *tlx = tmptlx;
1195     *tly = tmptly;
1196     *brx = tmpbrx;
1197     *bry = tmpbry;
1198 }
1199 
1200 
1201 
getint(jas_stream_t * in,int sgnd,int prec,long * val)1202 static int getint(jas_stream_t *in, int sgnd, int prec, long *val)
1203 {
1204     long v;
1205     int n;
1206     int c;
1207     n = (prec + 7) / 8;
1208     v = 0;
1209     while (--n >= 0) {
1210         if ((c = jas_stream_getc(in)) == EOF)
1211             return -1;
1212         v = (v << 8) | c;
1213     }
1214     v &= ((1 << prec) - 1);
1215     if (sgnd) {
1216         /* XXX - Do something here. */
1217         abort();
1218     } else {
1219         *val = v;
1220     }
1221     return 0;
1222 }
1223 
putint(jas_stream_t * out,int sgnd,int prec,long val)1224 static int putint(jas_stream_t *out, int sgnd, int prec, long val)
1225 {
1226     int n;
1227     int c;
1228     if (sgnd) {
1229         /* XXX - Do something here. */
1230         abort();
1231     }
1232     val &= (1 << prec) - 1;
1233     n = (prec + 7) / 8;
1234     while (--n >= 0) {
1235         c = (val >> (n * 8)) & 0xff;
1236         if (jas_stream_putc(out, c) != c)
1237             return -1;
1238     }
1239     return 0;
1240 }
1241 
convert(long val,int oldsgnd,int oldprec,int newsgnd,int newprec)1242 static long convert(long val, int oldsgnd, int oldprec, int newsgnd,
1243   int newprec)
1244 {
1245     if (newsgnd != oldsgnd) {
1246     }
1247     if (newprec != oldprec) {
1248         if (newprec > oldprec) {
1249             val <<= newprec - oldprec;
1250         } else if (oldprec > newprec) {
1251             val >>= oldprec - newprec;
1252         }
1253     }
1254     return val;
1255 }
1256 
downtomult(long x,long y)1257 static long downtomult(long x, long y)
1258 {
1259     assert(x >= 0);
1260     return (x / y) * y;
1261 }
1262 
uptomult(long x,long y)1263 static long uptomult(long x, long y)
1264 {
1265     assert(x >= 0);
1266     return ((x + y - 1) / y) * y;
1267 }
1268 
jas_image_chclrspc(jas_image_t * image,jas_cmprof_t * outprof,int intent)1269 jas_image_t *jas_image_chclrspc(jas_image_t *image, jas_cmprof_t *outprof,
1270   int intent)
1271 {
1272     jas_image_t *inimage;
1273     int minhstep;
1274     int minvstep;
1275     int i;
1276     int j;
1277     int k;
1278     int n;
1279     int hstep;
1280     int vstep;
1281     int numinauxchans;
1282     int numoutauxchans;
1283     int numinclrchans;
1284     int numoutclrchans;
1285     int prec;
1286     jas_image_t *outimage;
1287     int cmpttype;
1288     int numoutchans;
1289     jas_cmprof_t *inprof;
1290     jas_cmprof_t *tmpprof;
1291     jas_image_cmptparm_t cmptparm;
1292     int width;
1293     int height;
1294     jas_cmxform_t *xform;
1295     jas_cmpixmap_t inpixmap;
1296     jas_cmpixmap_t outpixmap;
1297     jas_cmcmptfmt_t *incmptfmts;
1298     jas_cmcmptfmt_t *outcmptfmts;
1299 
1300 #if 0
1301 jas_eprintf("IMAGE\n");
1302 jas_image_dump(image, stderr);
1303 #endif
1304 
1305     if (!(inimage = jas_image_copy(image)))
1306         goto error;
1307     image = 0;
1308 
1309     if (!jas_image_ishomosamp(inimage)) {
1310         minhstep = jas_image_cmpthstep(inimage, 0);
1311         minvstep = jas_image_cmptvstep(inimage, 0);
1312         for (i = 1; i < jas_image_numcmpts(inimage); ++i) {
1313             hstep = jas_image_cmpthstep(inimage, i);
1314             vstep = jas_image_cmptvstep(inimage, i);
1315             if (hstep < minhstep)
1316                 minhstep = hstep;
1317             if (vstep < minvstep)
1318                 minvstep = vstep;
1319         }
1320         n = jas_image_numcmpts(inimage);
1321         for (i = 0; i < n; ++i) {
1322             cmpttype = jas_image_cmpttype(inimage, i);
1323             if (jas_image_sampcmpt(inimage, i, i + 1, 0, 0, minhstep, minvstep, jas_image_cmptsgnd(inimage, i), jas_image_cmptprec(inimage, i)))
1324                 goto error;
1325             jas_image_setcmpttype(inimage, i + 1, cmpttype);
1326             jas_image_delcmpt(inimage, i);
1327         }
1328     }
1329 
1330     width = jas_image_cmptwidth(inimage, 0);
1331     height = jas_image_cmptheight(inimage, 0);
1332     hstep = jas_image_cmpthstep(inimage, 0);
1333     vstep = jas_image_cmptvstep(inimage, 0);
1334 
1335     inprof = jas_image_cmprof(inimage);
1336     assert(inprof);
1337     numinclrchans = jas_clrspc_numchans(jas_cmprof_clrspc(inprof));
1338     numinauxchans = jas_image_numcmpts(inimage) - numinclrchans;
1339     numoutclrchans = jas_clrspc_numchans(jas_cmprof_clrspc(outprof));
1340     numoutauxchans = 0;
1341     numoutchans = numoutclrchans + numoutauxchans;
1342     prec = 8;
1343 
1344     if (!(outimage = jas_image_create0()))
1345         goto error;
1346 
1347     /* Create a component for each of the colorants. */
1348     for (i = 0; i < numoutclrchans; ++i) {
1349         cmptparm.tlx = 0;
1350         cmptparm.tly = 0;
1351         cmptparm.hstep = hstep;
1352         cmptparm.vstep = vstep;
1353         cmptparm.width = width;
1354         cmptparm.height = height;
1355         cmptparm.prec = prec;
1356         cmptparm.sgnd = 0;
1357         if (jas_image_addcmpt(outimage, -1, &cmptparm))
1358             goto error;
1359         jas_image_setcmpttype(outimage, i, JAS_IMAGE_CT_COLOR(i));
1360     }
1361 #if 0
1362     /* Copy the auxiliary components without modification. */
1363     for (i = 0; i < jas_image_numcmpts(inimage); ++i) {
1364         if (!ISCOLOR(jas_image_cmpttype(inimage, i))) {
1365             jas_image_copycmpt(outimage, -1, inimage, i);
1366 /* XXX - need to specify laydown of component on ref. grid */
1367         }
1368     }
1369 #endif
1370 
1371     if (!(tmpprof = jas_cmprof_copy(outprof)))
1372         goto error;
1373     assert(!jas_image_cmprof(outimage));
1374     jas_image_setcmprof(outimage, tmpprof);
1375     tmpprof = 0;
1376     jas_image_setclrspc(outimage, jas_cmprof_clrspc(outprof));
1377 
1378     if (!(xform = jas_cmxform_create(inprof, outprof, 0, JAS_CMXFORM_OP_FWD, intent, 0)))
1379         goto error;
1380 
1381     inpixmap.numcmpts = numinclrchans;
1382     incmptfmts = malloc(numinclrchans * sizeof(jas_cmcmptfmt_t));
1383     assert(incmptfmts);
1384     inpixmap.cmptfmts = incmptfmts;
1385     for (i = 0; i < numinclrchans; ++i) {
1386         j = jas_image_getcmptbytype(inimage, JAS_IMAGE_CT_COLOR(i));
1387         assert(j >= 0);
1388         if (!(incmptfmts[i].buf = malloc(width * sizeof(long))))
1389             goto error;
1390         incmptfmts[i].prec = jas_image_cmptprec(inimage, j);
1391         incmptfmts[i].sgnd = jas_image_cmptsgnd(inimage, j);
1392         incmptfmts[i].width = width;
1393         incmptfmts[i].height = 1;
1394     }
1395 
1396     outpixmap.numcmpts = numoutclrchans;
1397     outcmptfmts = malloc(numoutclrchans * sizeof(jas_cmcmptfmt_t));
1398     assert(outcmptfmts);
1399     outpixmap.cmptfmts = outcmptfmts;
1400 
1401     for (i = 0; i < numoutclrchans; ++i) {
1402         j = jas_image_getcmptbytype(outimage, JAS_IMAGE_CT_COLOR(i));
1403         assert(j >= 0);
1404         if (!(outcmptfmts[i].buf = malloc(width * sizeof(long))))
1405             goto error;
1406         outcmptfmts[i].prec = jas_image_cmptprec(outimage, j);
1407         outcmptfmts[i].sgnd = jas_image_cmptsgnd(outimage, j);
1408         outcmptfmts[i].width = width;
1409         outcmptfmts[i].height = 1;
1410     }
1411 
1412     for (i = 0; i < height; ++i) {
1413         for (j = 0; j < numinclrchans; ++j) {
1414             k = jas_image_getcmptbytype(inimage, JAS_IMAGE_CT_COLOR(j));
1415             if (jas_image_readcmpt2(inimage, k, 0, i, width, 1, incmptfmts[j].buf))
1416                 goto error;
1417         }
1418         jas_cmxform_apply(xform, &inpixmap, &outpixmap);
1419         for (j = 0; j < numoutclrchans; ++j) {
1420             k = jas_image_getcmptbytype(outimage, JAS_IMAGE_CT_COLOR(j));
1421             if (jas_image_writecmpt2(outimage, k, 0, i, width, 1, outcmptfmts[j].buf))
1422                 goto error;
1423         }
1424     }
1425 
1426     for (i = 0; i < numoutclrchans; ++i)
1427         jas_free(outcmptfmts[i].buf);
1428     jas_free(outcmptfmts);
1429     for (i = 0; i < numinclrchans; ++i)
1430         jas_free(incmptfmts[i].buf);
1431     jas_free(incmptfmts);
1432     jas_cmxform_destroy(xform);
1433     jas_image_destroy(inimage);
1434 
1435 #if 0
1436 jas_eprintf("INIMAGE\n");
1437 jas_image_dump(inimage, stderr);
1438 jas_eprintf("OUTIMAGE\n");
1439 jas_image_dump(outimage, stderr);
1440 #endif
1441     return outimage;
1442 error:
1443     return 0;
1444 }
1445