| /* |
| * Copyright (c) 2001-2003, David Janssens |
| * Copyright (c) 2002-2003, Yannick Verschueren |
| * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <openjpeg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <math.h> |
| #include <unistd.h> |
| #include <string.h> |
| |
| /* -->> -->> -->> -->> |
| |
| BMP IMAGE FORMAT |
| |
| <<-- <<-- <<-- <<-- */ |
| |
| /* UINT2 defines a two byte word */ |
| typedef unsigned short int UINT2; |
| |
| /* UINT4 defines a four byte word */ |
| typedef unsigned long int UINT4; |
| |
| typedef struct { |
| UINT2 bfType; /* 'BM' for Bitmap (19776) */ |
| UINT4 bfSize; /* Size of the file */ |
| UINT2 bfReserved1; /* Reserved : 0 */ |
| UINT2 bfReserved2; /* Reserved : 0 */ |
| UINT4 bfOffBits; /* Offset */ |
| } BITMAPFILEHEADER_t; |
| |
| typedef struct { |
| UINT4 biSize; /* Size of the structure in bytes */ |
| UINT4 biWidth; /* Width of the image in pixels */ |
| UINT4 biHeight; /* Heigth of the image in pixels */ |
| UINT2 biPlanes; /* 1 */ |
| UINT2 biBitCount; /* Number of color bits by pixels */ |
| UINT4 biCompression; /* Type of encoding 0: none 1: RLE8 2: RLE4 */ |
| UINT4 biSizeImage; /* Size of the image in bytes */ |
| UINT4 biXpelsPerMeter; /* Horizontal (X) resolution in pixels/meter */ |
| UINT4 biYpelsPerMeter; /* Vertical (Y) resolution in pixels/meter */ |
| UINT4 biClrUsed; /* Number of color used in the image (0: ALL) */ |
| UINT4 biClrImportant; /* Number of important color (0: ALL) */ |
| } BITMAPINFOHEADER_t; |
| |
| int bmptoimage(char *filename, j2k_image_t * img, int subsampling_dx, |
| int subsampling_dy, int Dim[2]) |
| { |
| |
| FILE *IN; |
| FILE *Compo0 = NULL, *Compo1 = NULL, *Compo2 = NULL; |
| BITMAPFILEHEADER_t File_h; |
| BITMAPINFOHEADER_t Info_h; |
| unsigned char *RGB; |
| unsigned char *table_R, *table_G, *table_B; |
| int i, w, h; |
| int gray_scale = 1, not_end_file = 1, line = 0, col = 0; |
| unsigned char v, v2; |
| UINT4 W, H; |
| |
| IN = fopen(filename, "rb"); |
| if (!IN) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open %s for reading !!\033[0;39m\n", |
| filename); |
| return 0; |
| } |
| |
| File_h.bfType = getc(IN); |
| File_h.bfType = (getc(IN) << 8) + File_h.bfType; |
| |
| if (File_h.bfType != 19778) { |
| printf("Error, not a BMP file!\n"); |
| return 0; |
| } else { |
| /* FILE HEADER */ |
| /* ------------- */ |
| File_h.bfSize = getc(IN); |
| File_h.bfSize = (getc(IN) << 8) + File_h.bfSize; |
| File_h.bfSize = (getc(IN) << 16) + File_h.bfSize; |
| File_h.bfSize = (getc(IN) << 24) + File_h.bfSize; |
| |
| File_h.bfReserved1 = getc(IN); |
| File_h.bfReserved1 = (getc(IN) << 8) + File_h.bfReserved1; |
| |
| File_h.bfReserved2 = getc(IN); |
| File_h.bfReserved2 = (getc(IN) << 8) + File_h.bfReserved2; |
| |
| File_h.bfOffBits = getc(IN); |
| File_h.bfOffBits = (getc(IN) << 8) + File_h.bfOffBits; |
| File_h.bfOffBits = (getc(IN) << 16) + File_h.bfOffBits; |
| File_h.bfOffBits = (getc(IN) << 24) + File_h.bfOffBits; |
| |
| /* INFO HEADER */ |
| /* ------------- */ |
| |
| Info_h.biSize = getc(IN); |
| Info_h.biSize = (getc(IN) << 8) + Info_h.biSize; |
| Info_h.biSize = (getc(IN) << 16) + Info_h.biSize; |
| Info_h.biSize = (getc(IN) << 24) + Info_h.biSize; |
| |
| Info_h.biWidth = getc(IN); |
| Info_h.biWidth = (getc(IN) << 8) + Info_h.biWidth; |
| Info_h.biWidth = (getc(IN) << 16) + Info_h.biWidth; |
| Info_h.biWidth = (getc(IN) << 24) + Info_h.biWidth; |
| w = Info_h.biWidth; |
| |
| Info_h.biHeight = getc(IN); |
| Info_h.biHeight = (getc(IN) << 8) + Info_h.biHeight; |
| Info_h.biHeight = (getc(IN) << 16) + Info_h.biHeight; |
| Info_h.biHeight = (getc(IN) << 24) + Info_h.biHeight; |
| h = Info_h.biHeight; |
| |
| Info_h.biPlanes = getc(IN); |
| Info_h.biPlanes = (getc(IN) << 8) + Info_h.biPlanes; |
| |
| Info_h.biBitCount = getc(IN); |
| Info_h.biBitCount = (getc(IN) << 8) + Info_h.biBitCount; |
| |
| Info_h.biCompression = getc(IN); |
| Info_h.biCompression = (getc(IN) << 8) + Info_h.biCompression; |
| Info_h.biCompression = (getc(IN) << 16) + Info_h.biCompression; |
| Info_h.biCompression = (getc(IN) << 24) + Info_h.biCompression; |
| |
| Info_h.biSizeImage = getc(IN); |
| Info_h.biSizeImage = (getc(IN) << 8) + Info_h.biSizeImage; |
| Info_h.biSizeImage = (getc(IN) << 16) + Info_h.biSizeImage; |
| Info_h.biSizeImage = (getc(IN) << 24) + Info_h.biSizeImage; |
| |
| Info_h.biXpelsPerMeter = getc(IN); |
| Info_h.biXpelsPerMeter = (getc(IN) << 8) + Info_h.biXpelsPerMeter; |
| Info_h.biXpelsPerMeter = (getc(IN) << 16) + Info_h.biXpelsPerMeter; |
| Info_h.biXpelsPerMeter = (getc(IN) << 24) + Info_h.biXpelsPerMeter; |
| |
| Info_h.biYpelsPerMeter = getc(IN); |
| Info_h.biYpelsPerMeter = (getc(IN) << 8) + Info_h.biYpelsPerMeter; |
| Info_h.biYpelsPerMeter = (getc(IN) << 16) + Info_h.biYpelsPerMeter; |
| Info_h.biYpelsPerMeter = (getc(IN) << 24) + Info_h.biYpelsPerMeter; |
| |
| Info_h.biClrUsed = getc(IN); |
| Info_h.biClrUsed = (getc(IN) << 8) + Info_h.biClrUsed; |
| Info_h.biClrUsed = (getc(IN) << 16) + Info_h.biClrUsed; |
| Info_h.biClrUsed = (getc(IN) << 24) + Info_h.biClrUsed; |
| |
| Info_h.biClrImportant = getc(IN); |
| Info_h.biClrImportant = (getc(IN) << 8) + Info_h.biClrImportant; |
| Info_h.biClrImportant = (getc(IN) << 16) + Info_h.biClrImportant; |
| Info_h.biClrImportant = (getc(IN) << 24) + Info_h.biClrImportant; |
| |
| /* Read the data and store them in the OUT file */ |
| |
| if (Info_h.biBitCount == 24) { |
| img->x0 = Dim[0]; |
| img->y0 = Dim[1]; |
| img->x1 = |
| !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w - |
| 1) * |
| subsampling_dx + 1; |
| img->y1 = |
| !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h - |
| 1) * |
| subsampling_dy + 1; |
| img->numcomps = 3; |
| img->comps = |
| (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t)); |
| for (i = 0; i < img->numcomps; i++) { |
| img->comps[i].prec = 8; |
| img->comps[i].bpp = 8; |
| img->comps[i].sgnd = 0; |
| img->comps[i].dx = subsampling_dx; |
| img->comps[i].dy = subsampling_dy; |
| } |
| Compo0 = fopen("Compo0", "wb"); |
| if (!Compo0) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n"); |
| } |
| Compo1 = fopen("Compo1", "wb"); |
| if (!Compo1) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo1 for writing !\033[0;39m\n"); |
| } |
| Compo2 = fopen("Compo2", "wb"); |
| if (!Compo2) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo2 for writing !\033[0;39m\n"); |
| } |
| |
| /* Place the cursor at the beginning of the image information */ |
| fseek(IN, 0, SEEK_SET); |
| fseek(IN, File_h.bfOffBits, SEEK_SET); |
| |
| W = Info_h.biWidth; |
| H = Info_h.biHeight; |
| if (Info_h.biWidth % 2) |
| W++; |
| |
| RGB = (unsigned char *) malloc(3 * W * H * sizeof(unsigned char)); |
| |
| fread(RGB, sizeof(unsigned char), 3 * W * H, IN); |
| for (i = 0; i < W * H; i++) { |
| unsigned char R, G, B; |
| |
| B = |
| RGB[3 * W * H - ((i * 3) / (3 * W) + 1) * 3 * W + |
| (i * 3) % (W * 3)]; |
| G = |
| RGB[3 * W * H - ((i * 3 + 1) / (3 * W) + 1) * 3 * W + |
| (i * 3 + 1) % (W * 3)]; |
| R = |
| RGB[3 * W * H - ((i * 3 + 2) / (3 * W) + 1) * 3 * W + |
| (i * 3 + 2) % (W * 3)]; |
| if ((i % W < W - 1 && Info_h.biWidth % 2) || !(Info_h.biWidth % 2)) { |
| fprintf(Compo0, "%c", R); |
| fprintf(Compo1, "%c", G); |
| fprintf(Compo2, "%c", B); |
| } |
| } |
| fclose(Compo0); |
| fclose(Compo1); |
| fclose(Compo2); |
| free(RGB); |
| } else if (Info_h.biBitCount == 8 && Info_h.biCompression == 0) { |
| img->x0 = Dim[0]; |
| img->y0 = Dim[1]; |
| img->x1 = |
| !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w - |
| 1) * |
| subsampling_dx + 1; |
| img->y1 = |
| !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h - |
| 1) * |
| subsampling_dy + 1; |
| |
| table_R = (unsigned char *) malloc(256 * sizeof(unsigned char)); |
| table_G = (unsigned char *) malloc(256 * sizeof(unsigned char)); |
| table_B = (unsigned char *) malloc(256 * sizeof(unsigned char)); |
| |
| for (i = 0; i < Info_h.biClrUsed; i++) { |
| table_B[i] = getc(IN); |
| table_G[i] = getc(IN); |
| table_R[i] = getc(IN); |
| getc(IN); |
| if (table_R[i] != table_G[i] && table_R[i] != table_B[i] |
| && table_G[i] != table_B[i]) |
| gray_scale = 0; |
| } |
| |
| /* Place the cursor at the beginning of the image information */ |
| fseek(IN, 0, SEEK_SET); |
| fseek(IN, File_h.bfOffBits, SEEK_SET); |
| |
| W = Info_h.biWidth; |
| H = Info_h.biHeight; |
| if (Info_h.biWidth % 2) |
| W++; |
| |
| RGB = (unsigned char *) malloc(W * H * sizeof(unsigned char)); |
| |
| fread(RGB, sizeof(unsigned char), W * H, IN); |
| if (gray_scale) { |
| img->numcomps = 1; |
| img->comps = |
| (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t)); |
| img->comps[0].prec = 8; |
| img->comps[0].bpp = 8; |
| img->comps[0].sgnd = 0; |
| img->comps[0].dx = subsampling_dx; |
| img->comps[0].dy = subsampling_dy; |
| Compo0 = fopen("Compo0", "wb"); |
| if (!Compo0) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n"); |
| } |
| for (i = 0; i < W * H; i++) { |
| if ((i % W < W - 1 && Info_h.biWidth % 2) |
| || !(Info_h.biWidth % 2)) |
| fprintf(Compo0, "%c", |
| table_R[RGB[W * H - ((i) / (W) + 1) * W + (i) % (W)]]); |
| } |
| fclose(Compo0); |
| } else { |
| img->numcomps = 3; |
| img->comps = |
| (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t)); |
| for (i = 0; i < img->numcomps; i++) { |
| img->comps[i].prec = 8; |
| img->comps[i].bpp = 8; |
| img->comps[i].sgnd = 0; |
| img->comps[i].dx = subsampling_dx; |
| img->comps[i].dy = subsampling_dy; |
| } |
| |
| Compo0 = fopen("Compo0", "wb"); |
| if (!Compo0) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n"); |
| } |
| Compo1 = fopen("Compo1", "wb"); |
| if (!Compo1) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo1 for writing !\033[0;39m\n"); |
| } |
| Compo2 = fopen("Compo2", "wb"); |
| if (!Compo2) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo2 for writing !\033[0;39m\n"); |
| } |
| |
| for (i = 0; i < W * H; i++) { |
| if ((i % W < W - 1 && Info_h.biWidth % 2) |
| || !(Info_h.biWidth % 2)) { |
| fprintf(Compo0, "%c", |
| table_R[RGB[W * H - ((i) / (W) + 1) * W + (i) % (W)]]); |
| fprintf(Compo1, "%c", |
| table_G[RGB[W * H - ((i) / (W) + 1) * W + (i) % (W)]]); |
| fprintf(Compo2, "%c", |
| table_B[RGB[W * H - ((i) / (W) + 1) * W + (i) % (W)]]); |
| } |
| |
| } |
| fclose(Compo0); |
| fclose(Compo1); |
| fclose(Compo2); |
| } |
| free(RGB); |
| |
| } else if (Info_h.biBitCount == 8 && Info_h.biCompression == 1) { |
| img->x0 = Dim[0]; |
| img->y0 = Dim[1]; |
| img->x1 = |
| !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w - |
| 1) * |
| subsampling_dx + 1; |
| img->y1 = |
| !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h - |
| 1) * |
| subsampling_dy + 1; |
| |
| |
| |
| table_R = (unsigned char *) malloc(256 * sizeof(unsigned char)); |
| table_G = (unsigned char *) malloc(256 * sizeof(unsigned char)); |
| table_B = (unsigned char *) malloc(256 * sizeof(unsigned char)); |
| |
| for (i = 0; i < Info_h.biClrUsed; i++) { |
| table_B[i] = getc(IN); |
| table_G[i] = getc(IN); |
| table_R[i] = getc(IN); |
| getc(IN); |
| if (table_R[i] != table_G[i] && table_R[i] != table_B[i] |
| && table_G[i] != table_B[i]) |
| gray_scale = 0; |
| } |
| |
| /* Place the cursor at the beginning of the image information */ |
| fseek(IN, 0, SEEK_SET); |
| fseek(IN, File_h.bfOffBits, SEEK_SET); |
| |
| if (gray_scale) { |
| img->numcomps = 1; |
| img->comps = (j2k_comp_t *) malloc(sizeof(j2k_comp_t)); |
| img->comps[0].prec = 8; |
| img->comps[0].bpp = 8; |
| img->comps[0].sgnd = 0; |
| img->comps[0].dx = subsampling_dx; |
| img->comps[0].dy = subsampling_dy; |
| Compo0 = fopen("Compo0", "wb"); |
| if (!Compo0) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n"); |
| } |
| } else { |
| img->numcomps = 3; |
| img->comps = |
| (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t)); |
| for (i = 0; i < img->numcomps; i++) { |
| img->comps[i].prec = 8; |
| img->comps[i].bpp = 8; |
| img->comps[i].sgnd = 0; |
| img->comps[i].dx = subsampling_dx; |
| img->comps[i].dy = subsampling_dy; |
| } |
| Compo0 = fopen("Compo0", "wb"); |
| if (!Compo0) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n"); |
| } |
| Compo1 = fopen("Compo1", "wb"); |
| if (!Compo1) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo1 for writing !\033[0;39m\n"); |
| } |
| Compo2 = fopen("Compo2", "wb"); |
| if (!Compo2) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo2 for writing !\033[0;39m\n"); |
| } |
| } |
| |
| RGB = |
| (unsigned char *) malloc(Info_h.biWidth * Info_h.biHeight * |
| sizeof(unsigned char)); |
| |
| while (not_end_file) { |
| v = getc(IN); |
| if (v) { |
| v2 = getc(IN); |
| for (i = 0; i < (int) v; i++) { |
| RGB[line * Info_h.biWidth + col] = v2; |
| col++; |
| } |
| } else { |
| v = getc(IN); |
| switch (v) { |
| case 0: |
| col = 0; |
| line++; |
| break; |
| case 1: |
| line++; |
| not_end_file = 0; |
| break; |
| case 2: |
| printf("No Delta supported\n"); |
| return 1; |
| break; |
| default: |
| for (i = 0; i < v; i++) { |
| v2 = getc(IN); |
| RGB[line * Info_h.biWidth + col] = v2; |
| col++; |
| } |
| if (v % 2) |
| v2 = getc(IN); |
| } |
| } |
| } |
| if (gray_scale) { |
| for (line = 0; line < Info_h.biHeight; line++) |
| for (col = 0; col < Info_h.biWidth; col++) |
| fprintf(Compo0, "%c", |
| table_R[(int) |
| RGB[(Info_h.biHeight - line - |
| 1) * Info_h.biWidth + col]]); |
| fclose(Compo0); |
| } else { |
| for (line = 0; line < Info_h.biHeight; line++) |
| for (col = 0; col < Info_h.biWidth; col++) { |
| fprintf(Compo0, "%c", |
| table_R[(int) |
| RGB[(Info_h.biHeight - line - |
| 1) * Info_h.biWidth + col]]); |
| fprintf(Compo1, "%c", |
| table_G[(int) |
| RGB[(Info_h.biHeight - line - |
| 1) * Info_h.biWidth + col]]); |
| fprintf(Compo2, "%c", |
| table_B[(int) |
| RGB[(Info_h.biHeight - line - |
| 1) * Info_h.biWidth + col]]); |
| } |
| fclose(Compo0); |
| fclose(Compo1); |
| fclose(Compo2); |
| } |
| free(RGB); |
| } else |
| printf |
| ("Other system than 24 bits/pixels or 8 bits (no RLE coding) is not yet implemented [%d]\n", |
| Info_h.biBitCount); |
| |
| fclose(IN); |
| return 1; |
| } |
| } |
| |
| /* -->> -->> -->> -->> |
| |
| PGX IMAGE FORMAT |
| |
| <<-- <<-- <<-- <<-- */ |
| |
| |
| unsigned char readuchar(FILE * f) |
| { |
| unsigned char c1; |
| fread(&c1, 1, 1, f); |
| return c1; |
| } |
| |
| unsigned short readushort(FILE * f, int bigendian) |
| { |
| unsigned char c1, c2; |
| fread(&c1, 1, 1, f); |
| fread(&c2, 1, 1, f); |
| if (bigendian) |
| return (c1 << 8) + c2; |
| else |
| return (c2 << 8) + c1; |
| } |
| |
| unsigned int readuint(FILE * f, int bigendian) |
| { |
| unsigned char c1, c2, c3, c4; |
| fread(&c1, 1, 1, f); |
| fread(&c2, 1, 1, f); |
| fread(&c3, 1, 1, f); |
| fread(&c4, 1, 1, f); |
| if (bigendian) |
| return (c1 << 24) + (c2 << 16) + (c3 << 8) + c4; |
| else |
| return (c4 << 24) + (c3 << 16) + (c2 << 8) + c1; |
| } |
| |
| int pgxtoimage(char *filename, j2k_image_t * img, int tdy, |
| int subsampling_dx, int subsampling_dy, int Dim[2], |
| j2k_cp_t cp) |
| { |
| FILE *f; |
| int w, h, prec; |
| int i, compno, bandno; |
| char str[256], endian[16]; |
| char sign; |
| int bigendian; |
| j2k_comp_t *comp; |
| |
| img->numcomps = 1; |
| img->comps = (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t)); |
| for (compno = 0; compno < img->numcomps; compno++) { |
| FILE *src; |
| char tmp[16]; |
| int max = 0; |
| int Y1; |
| comp = &img->comps[compno]; |
| sprintf(str, "%s", filename); |
| f = fopen(str, "rb"); |
| if (!f) { |
| fprintf(stderr, "Failed to open %s for reading !\n", str); |
| return 0; |
| } |
| if (fscanf(f, "PG %s %c %d %d %d", endian, &sign, &prec, &w, &h) == 5) |
| { |
| fgetc(f); |
| if (!strcmp(endian, "ML")) |
| bigendian = 1; |
| else |
| bigendian = 0; |
| if (compno == 0) { |
| img->x0 = Dim[0]; |
| img->y0 = Dim[1]; |
| img->x1 = |
| !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w - |
| 1) * |
| subsampling_dx + 1; |
| img->y1 = |
| !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h - |
| 1) * |
| subsampling_dy + 1; |
| } else { |
| if (w != img->x1 || h != img->y1) |
| return 0; |
| } |
| |
| if (sign == '-') { |
| comp->sgnd = 1; |
| } else { |
| comp->sgnd = 0; |
| } |
| comp->prec = prec; |
| comp->dx = subsampling_dx; |
| comp->dy = subsampling_dy; |
| bandno = 1; |
| |
| Y1 = |
| cp.ty0 + bandno * cp.tdy < |
| img->y1 ? cp.ty0 + bandno * cp.tdy : img->y1; |
| Y1 -= img->y0; |
| |
| sprintf(tmp, "bandtile%d", bandno); /* bandtile file */ |
| src = fopen(tmp, "wb"); |
| if (!src) { |
| fprintf(stderr, "failed to open %s for writing !\n", tmp); |
| } |
| for (i = 0; i < w * h; i++) { |
| int v; |
| if (i == Y1 * w / subsampling_dy && tdy != -1) { /* bandtile is full */ |
| fclose(src); |
| bandno++; |
| sprintf(tmp, "bandtile%d", bandno); |
| src = fopen(tmp, "wb"); |
| if (!src) { |
| fprintf(stderr, "failed to open %s for writing !\n", tmp); |
| } |
| Y1 = |
| cp.ty0 + bandno * cp.tdy < |
| img->y1 ? cp.ty0 + bandno * cp.tdy : img->y1; |
| Y1 -= img->y0; |
| } |
| if (comp->prec <= 8) { |
| if (!comp->sgnd) { |
| v = readuchar(f); |
| } else { |
| v = (char) readuchar(f); |
| } |
| } else if (comp->prec <= 16) { |
| if (!comp->sgnd) { |
| v = readushort(f, bigendian); |
| } else { |
| v = (short) readushort(f, bigendian); |
| } |
| } else { |
| if (!comp->sgnd) { |
| v = readuint(f, bigendian); |
| } else { |
| v = (int) readuint(f, bigendian); |
| } |
| } |
| if (v > max) |
| max = v; |
| fprintf(src, "%d ", v); |
| } |
| } else { |
| return 0; |
| } |
| fclose(f); |
| fclose(src); |
| comp->bpp = int_floorlog2(max) + 1; |
| } |
| return 1; |
| } |
| |
| /* -->> -->> -->> -->> |
| |
| PNM IMAGE FORMAT |
| |
| <<-- <<-- <<-- <<-- */ |
| |
| int pnmtoimage(char *filename, j2k_image_t * img, int subsampling_dx, |
| int subsampling_dy, int Dim[2]) |
| { |
| FILE *f; |
| FILE *Compo0, *Compo1, *Compo2; |
| int w, h; |
| int i; |
| char value; |
| char comment[256]; |
| |
| f = fopen(filename, "rb"); |
| if (!f) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open %s for reading !!\033[0;39m\n", |
| filename); |
| return 0; |
| } |
| |
| if (fgetc(f) != 'P') |
| return 0; |
| value = fgetc(f); |
| |
| if (value == '2') { |
| fgetc(f); |
| if (fgetc(f) == '#') { |
| fseek(f, 0, SEEK_SET); |
| fscanf(f, "P2\n"); |
| fgets(comment, 256, f); |
| fscanf(f, "%d %d\n255", &w, &h); |
| } else { |
| fseek(f, 0, SEEK_SET); |
| fscanf(f, "P2\n%d %d\n255", &w, &h); |
| } |
| |
| fgetc(f); |
| img->x0 = Dim[0]; |
| img->y0 = Dim[1]; |
| img->x1 = |
| !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w - |
| 1) * |
| subsampling_dx + 1; |
| img->y1 = |
| !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h - |
| 1) * |
| subsampling_dy + 1; |
| |
| img->numcomps = 1; |
| img->comps = (j2k_comp_t *) malloc(sizeof(j2k_comp_t)); |
| img->comps[0].prec = 8; |
| img->comps[0].bpp = 8; |
| img->comps[0].sgnd = 0; |
| img->comps[0].dx = subsampling_dx; |
| img->comps[0].dy = subsampling_dy; |
| |
| Compo0 = fopen("Compo0", "wb"); |
| if (!Compo0) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n"); |
| } |
| for (i = 0; i < w * h; i++) { |
| unsigned int l; |
| fscanf(f, "%d", &l); |
| fprintf(Compo0, "%c", l); |
| } |
| fclose(Compo0); |
| } else if (value == '5') { |
| fgetc(f); |
| if (fgetc(f) == '#') { |
| fseek(f, 0, SEEK_SET); |
| fscanf(f, "P5\n"); |
| fgets(comment, 256, f); |
| fscanf(f, "%d %d\n255", &w, &h); |
| } else { |
| fseek(f, 0, SEEK_SET); |
| fscanf(f, "P5\n%d %d\n255", &w, &h); |
| } |
| |
| fgetc(f); |
| img->x0 = Dim[0]; |
| img->y0 = Dim[1]; |
| img->x1 = |
| !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w - |
| 1) * |
| subsampling_dx + 1; |
| img->y1 = |
| !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h - |
| 1) * |
| subsampling_dy + 1; |
| |
| img->numcomps = 1; |
| img->comps = (j2k_comp_t *) malloc(sizeof(j2k_comp_t)); |
| img->comps[0].prec = 8; |
| img->comps[0].bpp = 8; |
| img->comps[0].sgnd = 0; |
| img->comps[0].dx = subsampling_dx; |
| img->comps[0].dy = subsampling_dy; |
| Compo0 = fopen("Compo0", "wb"); |
| if (!Compo0) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n"); |
| } |
| for (i = 0; i < w * h; i++) { |
| unsigned char l; |
| fread(&l, 1, 1, f); |
| fwrite(&l, 1, 1, Compo0); |
| } |
| fclose(Compo0); |
| } else if (value == '3') { |
| fgetc(f); |
| if (fgetc(f) == '#') { |
| fseek(f, 0, SEEK_SET); |
| fscanf(f, "P3\n"); |
| fgets(comment, 256, f); |
| fscanf(f, "%d %d\n255", &w, &h); |
| } else { |
| fseek(f, 0, SEEK_SET); |
| fscanf(f, "P3\n%d %d\n255", &w, &h); |
| } |
| |
| fgetc(f); |
| img->x0 = Dim[0]; |
| img->y0 = Dim[1]; |
| img->x1 = |
| !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w - |
| 1) * |
| subsampling_dx + 1; |
| img->y1 = |
| !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h - |
| 1) * |
| subsampling_dy + 1; |
| img->numcomps = 3; |
| img->comps = (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t)); |
| for (i = 0; i < img->numcomps; i++) { |
| img->comps[i].prec = 8; |
| img->comps[i].bpp = 8; |
| img->comps[i].sgnd = 0; |
| img->comps[i].dx = subsampling_dx; |
| img->comps[i].dy = subsampling_dy; |
| } |
| Compo0 = fopen("Compo0", "wb"); |
| if (!Compo0) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n"); |
| } |
| |
| Compo1 = fopen("Compo1", "wb"); |
| if (!Compo1) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo1 for writing !\033[0;39m\n"); |
| } |
| |
| Compo2 = fopen("Compo2", "wb"); |
| if (!Compo2) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo2 for writing !\033[0;39m\n"); |
| } |
| |
| for (i = 0; i < w * h; i++) { |
| unsigned int r, g, b; |
| fscanf(f, "%d", &r); |
| fscanf(f, "%d", &g); |
| fscanf(f, "%d", &b); |
| fprintf(Compo0, "%c", r); |
| fprintf(Compo1, "%c", g); |
| fprintf(Compo2, "%c", b); |
| } |
| fclose(Compo0); |
| fclose(Compo1); |
| fclose(Compo2); |
| } else if (value == '6') { |
| fgetc(f); |
| if (fgetc(f) == '#') { |
| fseek(f, 0, SEEK_SET); |
| fscanf(f, "P6\n"); |
| fgets(comment, 256, f); |
| fscanf(f, "%d %d\n255", &w, &h); |
| } else { |
| fseek(f, 0, SEEK_SET); |
| fscanf(f, "P6\n%d %d\n255", &w, &h); |
| } |
| |
| fgetc(f); |
| img->x0 = Dim[0]; |
| img->y0 = Dim[1]; |
| img->x1 = |
| !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w - |
| 1) * |
| subsampling_dx + 1; |
| img->y1 = |
| !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h - |
| 1) * |
| subsampling_dy + 1; |
| img->numcomps = 3; |
| img->comps = (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t)); |
| for (i = 0; i < img->numcomps; i++) { |
| img->comps[i].prec = 8; |
| img->comps[i].bpp = 8; |
| img->comps[i].sgnd = 0; |
| img->comps[i].dx = subsampling_dx; |
| img->comps[i].dy = subsampling_dy; |
| } |
| Compo0 = fopen("Compo0", "wb"); |
| if (!Compo0) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n"); |
| } |
| |
| Compo1 = fopen("Compo1", "wb"); |
| if (!Compo1) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo1 for writing !\033[0;39m\n"); |
| } |
| |
| Compo2 = fopen("Compo2", "wb"); |
| if (!Compo2) { |
| fprintf(stderr, |
| "\033[0;33mFailed to open Compo2 for writing !\033[0;39m\n"); |
| } |
| |
| for (i = 0; i < w * h; i++) { |
| unsigned char r, g, b; |
| fread(&r, 1, 1, f); |
| fread(&g, 1, 1, f); |
| fread(&b, 1, 1, f); |
| fwrite(&r, 1, 1, Compo0); |
| fwrite(&g, 1, 1, Compo1); |
| fwrite(&b, 1, 1, Compo2); |
| } |
| fclose(Compo0); |
| fclose(Compo1); |
| fclose(Compo2); |
| } else { |
| return 0; |
| } |
| fclose(f); |
| return 1; |
| } |