← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/openjpeg/libopenjpeg/image.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/openjpeg/libopenjpeg/image.c
 
1
/*
 
2
 * Copyright (c) 2005, Herv� Drolon, FreeImage Team
 
3
 * All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 * 1. Redistributions of source code must retain the above copyright
 
9
 *    notice, this list of conditions and the following disclaimer.
 
10
 * 2. Redistributions in binary form must reproduce the above copyright
 
11
 *    notice, this list of conditions and the following disclaimer in the
 
12
 *    documentation and/or other materials provided with the distribution.
 
13
 *
 
14
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
 
15
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
16
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
17
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 
18
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 
19
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 
20
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 
21
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 
22
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
23
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 
24
 * POSSIBILITY OF SUCH DAMAGE.
 
25
 */
 
26
 
 
27
#include "opj_includes.h"
 
28
 
 
29
opj_image_t* opj_image_create0(void) {
 
30
        opj_image_t *image = (opj_image_t*)opj_calloc(1, sizeof(opj_image_t));
 
31
        return image;
 
32
}
 
33
 
 
34
opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc) {
 
35
        int compno;
 
36
        opj_image_t *image = NULL;
 
37
 
 
38
        image = (opj_image_t*) opj_calloc(1, sizeof(opj_image_t));
 
39
        if(image) {
 
40
                image->color_space = clrspc;
 
41
                image->numcomps = numcmpts;
 
42
                /* allocate memory for the per-component information */
 
43
                image->comps = (opj_image_comp_t*)opj_malloc(image->numcomps * sizeof(opj_image_comp_t));
 
44
                if(!image->comps) {
 
45
                        fprintf(stderr,"Unable to allocate memory for image.\n");
 
46
                        opj_image_destroy(image);
 
47
                        return NULL;
 
48
                }
 
49
                /* create the individual image components */
 
50
                for(compno = 0; compno < numcmpts; compno++) {
 
51
                        opj_image_comp_t *comp = &image->comps[compno];
 
52
                        comp->dx = cmptparms[compno].dx;
 
53
                        comp->dy = cmptparms[compno].dy;
 
54
                        comp->w = cmptparms[compno].w;
 
55
                        comp->h = cmptparms[compno].h;
 
56
                        comp->x0 = cmptparms[compno].x0;
 
57
                        comp->y0 = cmptparms[compno].y0;
 
58
                        comp->prec = cmptparms[compno].prec;
 
59
                        comp->bpp = cmptparms[compno].bpp;
 
60
                        comp->sgnd = cmptparms[compno].sgnd;
 
61
                        comp->data = (int*) opj_calloc(comp->w * comp->h, sizeof(int));
 
62
                        if(!comp->data) {
 
63
                                fprintf(stderr,"Unable to allocate memory for image.\n");
 
64
                                opj_image_destroy(image);
 
65
                                return NULL;
 
66
                        }
 
67
                }
 
68
        }
 
69
 
 
70
        return image;
 
71
}
 
72
 
 
73
void OPJ_CALLCONV opj_image_destroy(opj_image_t *image) {
 
74
        int i;
 
75
        if(image) {
 
76
                if(image->comps) {
 
77
                        /* image components */
 
78
                        for(i = 0; i < image->numcomps; i++) {
 
79
                                opj_image_comp_t *image_comp = &image->comps[i];
 
80
                                if(image_comp->data) {
 
81
                                        opj_free(image_comp->data);
 
82
                                }
 
83
                        }
 
84
                        opj_free(image->comps);
 
85
                }
 
86
                opj_free(image);
 
87
        }
 
88
}
 
89