From 3d67d80d49037916fa70424f04ff969cd41b2410 Mon Sep 17 00:00:00 2001 From: Francois-Olivier Devaux Date: Fri, 16 Jul 2004 14:10:49 +0000 Subject: [PATCH] First upload of MJ2 module --- mj2/frames_to_mj2.c | 823 ++++++++++++ mj2/frames_to_mj2.dsp | 257 ++++ mj2/mj2.c | 2958 +++++++++++++++++++++++++++++++++++++++++ mj2/mj2_convert.c | 260 ++++ mj2/mj2_convert.h | 39 + mj2/mj2_to_frames.c | 138 ++ mj2/mj2_to_frames.dsp | 257 ++++ 7 files changed, 4732 insertions(+) create mode 100644 mj2/frames_to_mj2.c create mode 100644 mj2/frames_to_mj2.dsp create mode 100644 mj2/mj2.c create mode 100644 mj2/mj2_convert.c create mode 100644 mj2/mj2_convert.h create mode 100644 mj2/mj2_to_frames.c create mode 100644 mj2/mj2_to_frames.dsp diff --git a/mj2/frames_to_mj2.c b/mj2/frames_to_mj2.c new file mode 100644 index 00000000..65760d2e --- /dev/null +++ b/mj2/frames_to_mj2.c @@ -0,0 +1,823 @@ +/* +* Copyright (c) 2003-2004, François-Olivier Devaux +* Copyright (c) 2002-2004, 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 +#include +#include +#include +#include +#ifndef DONT_HAVE_GETOPT +#include +#else +#include "compat/getopt.h" +#endif +#include "mj2_convert.h" + +void help_display() +{ + printf("HELP\n----\n\n"); + printf("- the option -help displays the readme.txt file on screen\n\n"); + + + printf("List of parameters for the MJ2 coder :\n"); + printf("\n"); + printf + ("- The markers COD and QCD are writed both of two in the main_header and never appear in the tile_header. The markers in the main header are : SOC SIZ COD QCD COM.\n"); + printf("\n"); + printf + ("- This coder can encode mega image, a test was made on a 24000x24000 pixels color image. You need enough disk space memory (twice the original) to encode the image. (i.e. for a 1.5 Gb image you need a minimum of 3Gb of disk memory)\n"); + printf("\n"); + printf("REMARKS :\n"); + printf("---------\n"); + printf("\n"); + printf + ("* the value of rate enter in the code line is the compression factor !\n"); + printf("exemple :\n"); + printf("\n"); + printf + ("-r 20,10,1 means quality 1 : compress 20x, quality 2 : compress 10x and quality 3 : compress 1x = lossless\n"); + printf("\n"); + printf("By default :\n"); + printf("------------\n"); + printf("\n"); + printf(" * lossless\n"); + printf(" * 1 tile\n"); + printf(" * size of precinct 2^15 x 2^15 (means 1 precinct)\n"); + printf(" * size of code-block 64 x 64\n"); + printf(" * Number of resolution : 6\n"); + printf(" * No SOP marker in the codestream\n"); + printf(" * No EPH marker in the codestream\n"); + printf(" * No sub-sampling in x and y direction\n"); + printf(" * No mode switch activated\n"); + printf(" * progression order : LRCP\n"); + printf(" * No index file\n"); + printf(" * No ROI upshifted\n"); + printf(" * No offset of the origin of the image\n"); + printf(" * No offset of the origin of the tiles\n"); + printf(" * Reversible DWT 5-3\n"); + printf("\n"); + printf("Parameters :\n"); + printf("------------\n"); + printf("\n"); + printf + ("-i : source file (-i source.pnm also *.pgm, *.ppm) required\n"); + printf("\n"); + printf + ("-o : destination file (-o dest.j2k or .jp2) required\n"); + printf("\n"); + printf("-help : Display the help information optional\n "); + printf("\n"); + printf("-r : different rates (-r 20,10,5) optional\n "); + printf("\n"); + printf("-n : Number of resolution (-n 3) optional\n"); + printf("\n"); + printf("-b : size of code block (-b 32,32) optional\n"); + printf("\n"); + printf("-c : size of precinct (-c 128,128) optional\n"); + printf("\n"); + printf("-t : size of tile (-t 512,512) optional\n"); + printf("\n"); + printf + ("-p : progression order (-p LRCP) [LRCP, RLCP, RPCL, PCRL, CPRL] optional\n"); + printf("\n"); + printf + ("-s : subsampling factor (-s 2,2) [-s X,Y] optional\n"); + printf("\n"); + printf + ("-SOP : write SOP marker before each packet optional\n"); + printf("\n"); + printf + ("-EPH : write EPH marker after each header packet optional\n"); + printf("\n"); + printf + ("-M : mode switch (-M 3) [1=BYPASS(LAZY) 2=RESET 4=RESTART(TERMALL) 8=VSC 16=ERTERM(SEGTERM) 32=SEGMARK(SEGSYM)] optional\n"); + printf + (" for several mode switch you have to add the value of each mode you want\n"); + printf + (" ex : RESTART(4) + RESET(2) + SEGMARK(32) = -M 38\n"); + printf("\n"); + printf + ("-x : Create an index file *.Idx (-x index_name.Idx) optional\n"); + printf("\n"); + printf + ("-ROI:c=%%d,U=%%d : quantization indices upshifted for component c=%%d [%%d = 0,1,2]\n"); + printf + (" with a value of U=%%d [0 <= %%d <= 37] (i.e. -ROI:c=0,U=25) optional\n"); + printf("\n"); + printf + ("-d : offset of the origin of the image (-d 150,300) optional\n"); + printf("\n"); + printf + ("-T : offset of the origin of the tiles (-T 100,75) optional\n"); + printf("\n"); + printf("-I : Use the irreversible DWT 9-7 (-I) optional\n"); + printf("\n"); + printf + ("-W : Specify image width, height and the dx and dy subsampling of the Cb and Cr components for YUV files (default 352x288 and 420 Cif format)\n"); + printf("\n"); + printf + ("-F : Specify video frame rate (set to 25 by default)\n"); + printf("\n"); + printf("IMPORTANT :\n"); + printf("-----------\n"); + printf("\n"); + printf("* subsampling bigger than 2 can produce error\n"); + printf("\n"); + printf("The index file respect the structure below :\n"); + printf("---------------------------------------------\n"); + printf("\n"); + printf("Image_height Image_width\n"); + printf("progression order\n"); + printf("Tiles_size_X Tiles_size_Y\n"); + printf("Components_nb\n"); + printf("Layers_nb\n"); + printf("decomposition_levels\n"); + printf("Precincts_size_X Precincts_size_Y\n"); + printf("Main_header_end_position\n"); + printf("Codestream_size\n"); + printf("Tile0 start_pos end_Theader end_pos\n"); + printf("Tile1 '' '' ''\n"); + printf("...\n"); + printf("TileN '' '' ''\n"); + printf("Tpacket_0 Tile layer res. comp. prec. start_pos end_pos\n"); + printf("...\n"); + printf("Tpacket_M '' '' '' '' '' '' ''\n"); +} + +int give_progression(char progression[4]) +{ + if (progression[0] == 'L' && progression[1] == 'R' + && progression[2] == 'C' && progression[3] == 'P') { + return 0; + } else { + if (progression[0] == 'R' && progression[1] == 'L' + && progression[2] == 'C' && progression[3] == 'P') { + return 1; + } else { + if (progression[0] == 'R' && progression[1] == 'P' + && progression[2] == 'C' && progression[3] == 'L') { + return 2; + } else { + if (progression[0] == 'P' && progression[1] == 'C' + && progression[2] == 'R' && progression[3] == 'L') { + return 3; + } else { + if (progression[0] == 'C' && progression[1] == 'P' + && progression[2] == 'R' && progression[3] == 'L') { + return 4; + } else { + return -1; + } + } + } + } + } +} + +double dwt_norms_97[4][10] = { + {1.000, 1.965, 4.177, 8.403, 16.90, 33.84, 67.69, 135.3, 270.6, 540.9}, + {2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0}, + {2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0}, + {2.080, 3.865, 8.307, 17.18, 34.71, 69.59, 139.3, 278.6, 557.2} +}; + +int floorlog2(int a) +{ + int l; + for (l = 0; a > 1; l++) { + a >>= 1; + } + return l; +} + +void encode_stepsize(int stepsize, int numbps, int *expn, int *mant) +{ + int p, n; + p = floorlog2(stepsize) - 13; + n = 11 - floorlog2(stepsize); + *mant = (n < 0 ? stepsize >> -n : stepsize << n) & 0x7ff; + *expn = numbps - p; +} + +void calc_explicit_stepsizes(j2k_tccp_t * tccp, int prec) +{ + int numbands, bandno; + numbands = 3 * tccp->numresolutions - 2; + for (bandno = 0; bandno < numbands; bandno++) { + double stepsize; + + int resno, level, orient, gain; + resno = bandno == 0 ? 0 : (bandno - 1) / 3 + 1; + orient = bandno == 0 ? 0 : (bandno - 1) % 3 + 1; + level = tccp->numresolutions - 1 - resno; + gain = + tccp->qmfbid == 0 ? 0 : (orient == + 0 ? 0 : (orient == 1 + || orient == 2 ? 1 : 2)); + if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) { + stepsize = 1.0; + } else { + double norm = dwt_norms_97[orient][level]; + stepsize = (1 << (gain + 1)) / norm; + } + encode_stepsize((int) floor(stepsize * 8192.0), prec + gain, + &tccp->stepsizes[bandno].expn, + &tccp->stepsizes[bandno].mant); + } +} + +int main(int argc, char **argv) +{ + int NumResolution, numD_min; /* NumResolution : number of resolution */ + int Tile_arg; /* Tile_arg = 0 (not in argument) ou = 1 (in argument) */ + int CSty; /* CSty : coding style */ + int Prog_order; /* progression order (default LRCP) */ + char progression[4]; + int numpocs, numpocs_tile; /* Number of progression order change (POC) default 0 */ + int prcw_init[J2K_MAXRLVLS]; /* Initialisation Precinct width */ + int prch_init[J2K_MAXRLVLS]; /* Initialisation Precinct height */ + //int prcw_init, prch_init; /* Initialisation precincts' size */ + int cblockw_init, cblockh_init; /* Initialisation codeblocks' size */ + int mode, value; /* Mode switch (cblk_style) */ + int subsampling_dx, subsampling_dy; /* subsampling value for dx and dy */ + int ROI_compno, ROI_shift; /* region of interrest */ + int Dim[2]; /* portion of the image coded */ + int TX0, TY0; /* tile off-set */ + mj2_movie_t movie; + j2k_cp_t cp, cp_init; /* cp_init is used to initialise in multiple tiles */ + j2k_tcp_t *tcp, *tcp_init; /* tcp_init is used to initialise in multiple tile */ + j2k_poc_t POC[32]; /* POC : used in case of Progression order change */ + j2k_poc_t *tcp_poc; + j2k_tccp_t *tccp; + int i, tileno, j; + char *infile = 0; + char *outfile = 0; + char *index = 0; + char *s, S1, S2, S3; + int ir = 0; + int res_spec = 0; /* For various precinct sizes specification */ + char sep; + int w; /* Width of YUV file */ + int h; /* Height of YUV file */ + int CbCr_subsampling_dx; /* Sample rate of YUV 4:4:4 4:2:2 or 4:2:0 */ + int CbCr_subsampling_dy; /* Sample rate of YUV 4:4:4 4:2:2 or 4:2:0 */ + int output_image_type = -1; + int frame_rate; /* Video Frame Rate */ + int numcomps; /* In YUV files, numcomps always considered as 3 */ + int prec; /* In YUV files, precision always considered as 8 */ + int x1, y1; + + + /* default value */ + /* ------------- */ + NumResolution = 6; + CSty = 0; + cblockw_init = 64; + cblockh_init = 64; + cp.tw = 1; + cp.th = 1; + cp.index_on = 0; + Prog_order = 0; + numpocs = 0; + mode = 0; + subsampling_dx = 1; + subsampling_dy = 1; + ROI_compno = -1; /* no ROI */ + ROI_shift = 0; + Dim[0] = 0; + Dim[1] = 0; + TX0 = 0; + TY0 = 0; + cp.comment = NULL; + cp.disto_alloc = 0; + cp.fixed_alloc = 0; + cp.fixed_quality = 0; //add fixed_quality + w = 352; // CIF default value + h = 288; // CIF default value + CbCr_subsampling_dx = 2; // CIF default value + CbCr_subsampling_dy = 2; // CIF default value + frame_rate = 25; + + + Tile_arg = 0; + cp_init.tcps = (j2k_tcp_t *) malloc(sizeof(j2k_tcp_t)); /* initialisation if only one tile */ + tcp_init = &cp_init.tcps[0]; + tcp_init->numlayers = 0; + + cp.intermed_file = 0; // Don't store each tile in a file during processing + + while (1) { + int c = getopt(argc, argv, + "i:o:r:q:f:t:n:c:b:x:p:s:d:h:P:S:E:M:R:T:C:I:W:F"); + if (c == -1) + break; + switch (c) { + case 'i': /* IN fill */ + infile = optarg; + s = optarg; + while (*s) { + s++; + } + s--; + S3 = *s; + s--; + S2 = *s; + s--; + S1 = *s; + + if ((S1 == 'y' && S2 == 'u' && S3 == 'v') + || (S1 == 'Y' && S2 == 'U' && S3 == 'V')) { + cp.image_type = 3; + break; + } + fprintf(stderr, + "!! Unrecognized format for infile : %c%c%c [accept only *.yuv] !!\n\n", + S1, S2, S3); + return 1; + break; + /* ----------------------------------------------------- */ + case 'o': /* OUT fill */ + outfile = optarg; + while (*outfile) { + outfile++; + } + outfile--; + S3 = *outfile; + outfile--; + S2 = *outfile; + outfile--; + S1 = *outfile; + + outfile = optarg; + + if ((S1 == 'm' && S2 == 'j' && S3 == '2') + || (S1 == 'M' && S2 == 'J' && S3 == '2')) + cp.JPEG2000_format = 2; + else { + fprintf(stderr, + "Unknown output format image *.%c%c%c [only *.mj2]!! \n", + S1, S2, S3); + return 1; + } + + + + break; + /* ----------------------------------------------------- */ + case 'r': /* rates rates/distorsion */ + s = optarg; + while (sscanf(s, "%d", &tcp_init->rates[tcp_init->numlayers]) + == 1) { + tcp_init->numlayers++; + while (*s && *s != ',') { + s++; + } + if (!*s) + break; + s++; + } + cp.disto_alloc = 1; + cp.matrice = NULL; + break; + /* ----------------------------------------------------- */ + case 'q': /* add fixed_quality */ + s = optarg; + while (sscanf + (s, "%f", &tcp_init->distoratio[tcp_init->numlayers]) == 1) { + tcp_init->numlayers++; + while (*s && *s != ',') { + s++; + } + if (!*s) + break; + s++; + } + cp.fixed_quality = 1; + cp.matrice = NULL; + break; + /* dda */ + /* ----------------------------------------------------- */ + case 'f': /* mod fixed_quality (before : -q) */ + s = optarg; + sscanf(s, "%d", &tcp_init->numlayers); + s++; + if (tcp_init->numlayers > 9) + s++; + cp.matrice = + (int *) malloc(tcp_init->numlayers * NumResolution * 3 * + sizeof(int)); + s = s + 2; + for (i = 0; i < tcp_init->numlayers; i++) { + tcp_init->rates[i] = 1; + sscanf(s, "%d,", &cp.matrice[i * NumResolution * 3]); + s += 2; + if (cp.matrice[i * NumResolution * 3] > 9) + s++; + cp.matrice[i * NumResolution * 3 + 1] = 0; + cp.matrice[i * NumResolution * 3 + 2] = 0; + for (j = 1; j < NumResolution; j++) { + sscanf(s, "%d,%d,%d", + &cp.matrice[i * NumResolution * 3 + j * 3 + 0], + &cp.matrice[i * NumResolution * 3 + j * 3 + 1], + &cp.matrice[i * NumResolution * 3 + j * 3 + 2]); + s += 6; + if (cp.matrice[i * NumResolution * 3 + j * 3] > 9) + s++; + if (cp.matrice[i * NumResolution * 3 + j * 3 + 1] > 9) + s++; + if (cp.matrice[i * NumResolution * 3 + j * 3 + 2] > 9) + s++; + } + if (i < tcp_init->numlayers - 1) + s++; + } + cp.fixed_alloc = 1; + break; + /* ----------------------------------------------------- */ + case 't': /* tiles */ + sscanf(optarg, "%d,%d", &cp.tdx, &cp.tdy); + Tile_arg = 1; + break; + /* ----------------------------------------------------- */ + case 'n': /* resolution */ + sscanf(optarg, "%d", &NumResolution); + break; + /* ----------------------------------------------------- */ + case 'c': /* precinct dimension */ + s = optarg; + do { + sep = 0; + sscanf(s, "[%d,%d]%c", &prcw_init[res_spec], + &prch_init[res_spec], &sep); + CSty |= 0x01; + res_spec++; + s = strpbrk(s, "]") + 2; + } while (sep == ','); + break; + /* ----------------------------------------------------- */ + case 'b': /* code-block dimension */ + sscanf(optarg, "%d,%d", &cblockw_init, &cblockh_init); + if (cblockw_init * cblockh_init > 4096 || cblockw_init > 1024 + || cblockw_init < 4 || cblockh_init > 1024 || cblockh_init < 4) { + fprintf(stderr, + "!! Size of code_block error (option -b) !!\n\nRestriction :\n * width*height<=4096\n * 4<=width,height<= 1024\n\n"); + return 1; + } + break; + /* ----------------------------------------------------- */ + case 'x': /* creation of index file */ + index = optarg; + cp.index_on = 1; + break; + /* ----------------------------------------------------- */ + case 'p': /* progression order */ + s = optarg; + for (i = 0; i < 4; i++) { + progression[i] = *s; + s++; + } + Prog_order = give_progression(progression); + + if (Prog_order == -1) { + fprintf(stderr, + "Unrecognized progression order [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n"); + return 1; + } + break; + /* ----------------------------------------------------- */ + case 's': /* subsampling factor */ + if (sscanf(optarg, "%d,%d", &subsampling_dx, &subsampling_dy) + != 2) { + fprintf(stderr, + "'-s' sub-sampling argument error ! [-s dx,dy]\n"); + return 1; + } + break; + /* ----------------------------------------------------- */ + case 'd': /* coordonnate of the reference grid */ + if (sscanf(optarg, "%d,%d", &Dim[0], &Dim[1]) != 2) { + fprintf(stderr, + "-d 'coordonnate of the reference grid' argument error !! [-d x0,y0]\n"); + return 1; + } + break; + /* ----------------------------------------------------- */ + case 'h': /* Display an help description */ + help_display(); + return 0; + break; + /* ----------------------------------------------------- */ + case 'P': /* POC */ + fprintf(stderr, "/----------------------------------\\\n"); + fprintf(stderr, "| POC option not fully tested !! |\n"); + fprintf(stderr, "\\----------------------------------/\n"); + + s = optarg; + while (sscanf(s, "T%d=%d,%d,%d,%d,%d,%s", &POC[numpocs].tile, + &POC[numpocs].resno0, &POC[numpocs].compno0, + &POC[numpocs].layno1, &POC[numpocs].resno1, + &POC[numpocs].compno1, POC[numpocs].progorder) == 7) { + POC[numpocs].prg = give_progression(POC[numpocs].progorder); + /* POC[numpocs].tile; */ + numpocs++; + while (*s && *s != '/') { + s++; + } + if (!*s) + break; + s++; + } + break; + /* ------------------------------------------------------ */ + case 'S': /* SOP marker */ + CSty |= 0x02; + break; + /* ------------------------------------------------------ */ + case 'E': /* EPH marker */ + CSty |= 0x04; + break; + /* ------------------------------------------------------ */ + case 'M': /* Mode switch pas tous au point !! */ + if (sscanf(optarg, "%d", &value) == 1) { + for (i = 0; i <= 5; i++) { + int cache = value & (1 << i); + if (cache) + mode |= (1 << i); + } + } + break; + /* ------------------------------------------------------ */ + case 'R': /* ROI */ + if (sscanf(optarg, "OI:c=%d,U=%d", &ROI_compno, &ROI_shift) != 2) { + fprintf(stderr, "ROI error !! [-ROI:c='compno',U='shift']\n"); + return 1; + } + break; + /* ------------------------------------------------------ */ + case 'T': /* Tile offset */ + if (sscanf(optarg, "%d,%d", &TX0, &TY0) != 2) { + fprintf(stderr, "-T 'tile offset' argument error !! [-T X0,Y0]"); + return 1; + } + break; + /* ------------------------------------------------------ */ + case 'C': /* Add a comment */ + cp.comment = optarg; + break; + /* ------------------------------------------------------ */ + case 'I': /* reversible or not */ + ir = 1; + break; + /* ------------------------------------------------------ */ + case 'W': /* Width and Height and Cb and Cr subsampling in case of YUV format files */ + if (sscanf + (optarg, "%d,%d,%d,%d", &w, &h, &CbCr_subsampling_dx, + &CbCr_subsampling_dy) != 4) { + fprintf(stderr, "-W argument error"); + return 1; + } + break; + /* ------------------------------------------------------ */ + case 'F': /* Video frame rate */ + if (sscanf(optarg, "%d", &frame_rate) != 1) { + fprintf(stderr, "-f argument error"); + return 1; + } + break; + /* ------------------------------------------------------ */ + default: + return 1; + } + } + + cp.tx0 = TX0; + cp.ty0 = TY0; + + /* Error messages */ + /* -------------- */ + if (!infile || !outfile) { + fprintf(stderr, + "usage: frames_to_mj2 -i yuv-file -o mj2-file (+ options)\n"); + return 1; + } + + if ((cp.disto_alloc || cp.fixed_alloc || cp.fixed_quality) + && (!(cp.disto_alloc ^ cp.fixed_alloc ^ cp.fixed_quality))) { + fprintf(stderr, + "Error: options -r -q and -f can not be used together !!\n"); + return 1; + } // mod fixed_quality + + /* if no rate entered, lossless by default */ + if (tcp_init->numlayers == 0) { + tcp_init->rates[tcp_init->numlayers] = 1; + tcp_init->numlayers++; + cp.disto_alloc = 1; + } + + if (TX0 > Dim[0] || TY0 > Dim[1]) { + fprintf(stderr, + "Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n", + TX0, Dim[0], TY0, Dim[1]); + return 1; + } + + for (i = 0; i < numpocs; i++) { + if (POC[i].prg == -1) { + fprintf(stderr, + "Unrecognized progression order in option -P (POC n %d) [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n", + i + 1); + } + } + + /* to respect profile - 0 */ + /* ---------------------- */ + numD_min = 0; + + x1 = !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w - + 1) * + subsampling_dx + 1; + y1 = !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h - + 1) * + subsampling_dy + 1; + + if (Tile_arg == 1) { + cp.tw = int_ceildiv(x1 - cp.tx0, cp.tdx); + cp.th = int_ceildiv(y1 - cp.ty0, cp.tdy); + } else { + cp.tdx = x1 - cp.tx0; + cp.tdy = y1 - cp.ty0; + } + + + /* Initialization for PPM marker */ + cp.ppm = 0; + cp.ppm_data = NULL; + cp.ppm_previous = 0; + cp.ppm_store = 0; + + numcomps = 3; /* Because YUV files only have 3 components */ + + tcp_init->mct = 0; /* No component transform needed */ + + prec = 8; /* Because in YUV files, components have 8-bit depth */ + + /* Init the mutiple tiles */ + /* ---------------------- */ + cp.tcps = (j2k_tcp_t *) malloc(cp.tw * cp.th * sizeof(j2k_tcp_t)); + + for (tileno = 0; tileno < cp.tw * cp.th; tileno++) { + tcp = &cp.tcps[tileno]; + tcp->numlayers = tcp_init->numlayers; + for (j = 0; j < tcp->numlayers; j++) { + if (cp.fixed_quality) // add fixed_quality + tcp->distoratio[j] = tcp_init->distoratio[j]; + else + tcp->rates[j] = tcp_init->rates[j]; + } + tcp->csty = CSty; + tcp->prg = Prog_order; + tcp->mct = tcp_init->mct; + tcp->ppt = 0; + tcp->ppt_data = NULL; + tcp->ppt_store = 0; + + numpocs_tile = 0; + tcp->POC = 0; + if (numpocs) { + /* intialisation of POC */ + tcp->POC = 1; + for (i = 0; i < numpocs; i++) { + if (tileno == POC[i].tile - 1 || POC[i].tile == -1) { + tcp_poc = &tcp->pocs[numpocs_tile]; + tcp_poc->resno0 = POC[numpocs_tile].resno0; + tcp_poc->compno0 = POC[numpocs_tile].compno0; + tcp_poc->layno1 = POC[numpocs_tile].layno1; + tcp_poc->resno1 = POC[numpocs_tile].resno1; + tcp_poc->compno1 = POC[numpocs_tile].compno1; + tcp_poc->prg = POC[numpocs_tile].prg; + tcp_poc->tile = POC[numpocs_tile].tile; + numpocs_tile++; + } + } + } + tcp->numpocs = numpocs_tile; + tcp->tccps = (j2k_tccp_t *) malloc(numcomps * sizeof(j2k_tccp_t)); + + for (i = 0; i < numcomps; i++) { + tccp = &tcp->tccps[i]; + tccp->csty = CSty & 0x01; /* 0 => one precinct || 1 => custom precinct */ + tccp->numresolutions = NumResolution; + tccp->cblkw = int_floorlog2(cblockw_init); + tccp->cblkh = int_floorlog2(cblockh_init); + tccp->cblksty = mode; + tccp->qmfbid = ir ? 0 : 1; + tccp->qntsty = ir ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT; + tccp->numgbits = 2; + if (i == ROI_compno) + tccp->roishift = ROI_shift; + else + tccp->roishift = 0; + if (CSty & J2K_CCP_CSTY_PRT) { + int p = 0; + for (j = tccp->numresolutions - 1; j >= 0; j--) { + if (p < res_spec) { + if (prcw_init[p] < 1) + tccp->prcw[j] = 1; + else + tccp->prcw[j] = int_floorlog2(prcw_init[p]); + + if (prch_init[p] < 1) + tccp->prch[j] = 1; + else + tccp->prch[j] = int_floorlog2(prch_init[p]); + } else { + int size_prcw, size_prch; + size_prcw = prcw_init[res_spec - 1] >> (p - (res_spec - 1)); + size_prch = prch_init[res_spec - 1] >> (p - (res_spec - 1)); + if (size_prcw < 1) + tccp->prcw[j] = 1; + else + tccp->prcw[j] = int_floorlog2(size_prcw); + if (size_prch < 1) + tccp->prch[j] = 1; + else + tccp->prch[j] = int_floorlog2(size_prch); + } + p++; + /*printf("\nsize precinct pour level %d : %d,%d\n", j, + tccp->prcw[j], tccp->prch[j]); */ + } + } else { + for (j = 0; j < tccp->numresolutions; j++) { + tccp->prcw[j] = 15; + tccp->prch[j] = 15; + } + } + calc_explicit_stepsizes(tccp, prec); + } + } + + movie.tk = (mj2_tk_t *) malloc(sizeof(mj2_tk_t)); + movie.num_vtk = 1; + movie.num_stk = 0; + movie.num_htk = 0; + + movie.tk[0].imagefile = infile; + movie.tk[0].track_type = 0; // Video Track + movie.tk[0].track_ID = 1; + movie.mj2file = outfile; + movie.tk[0].subsampling_dx = subsampling_dx; + movie.tk[0].subsampling_dy = subsampling_dy; + movie.tk[0].Dim[0] = Dim[0]; + movie.tk[0].Dim[1] = Dim[1]; + movie.tk[0].w = w; + movie.tk[0].h = h; + movie.tk[0].CbCr_subsampling_dx = CbCr_subsampling_dx; + movie.tk[0].CbCr_subsampling_dy = CbCr_subsampling_dy; + movie.tk[0].sample_rate = frame_rate; + + if (mj2_init_stdmovie(&movie)) { + fprintf(stderr, "Error with movie initialization"); + return 1; + }; + if (mj2_encode(&movie, &cp, index)) { + fprintf(stderr, "Error encoding movie"); + return 1; + }; + mj2_memory_free(&movie); + + /* Free cp memory */ + free(cp_init.tcps); + if (tcp_init->numlayers > 9) + free(cp.matrice); + for (tileno = 0; tileno < cp.tw * cp.th; tileno++) + free(cp.tcps[tileno].tccps); + free(cp.tcps); + + return 0; +} diff --git a/mj2/frames_to_mj2.dsp b/mj2/frames_to_mj2.dsp new file mode 100644 index 00000000..56c8dfd7 --- /dev/null +++ b/mj2/frames_to_mj2.dsp @@ -0,0 +1,257 @@ +# Microsoft Developer Studio Project File - Name="frames_to_mj2" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=frames_to_mj2 - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "frames_to_mj2.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "frames_to_mj2.mak" CFG="frames_to_mj2 - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "frames_to_mj2 - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "frames_to_mj2 - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "frames_to_mj2 - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /YX /FD /c +# ADD BASE RSC /l 0x80c /d "NDEBUG" +# ADD RSC /l 0x80c /i "../libopenjpeg" /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 + +!ELSEIF "$(CFG)" == "frames_to_mj2 - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "_DEBUG" /D "DONT_HAVE_GETOPT" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c +# ADD BASE RSC /l 0x80c /d "_DEBUG" +# ADD RSC /l 0x80c /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "frames_to_mj2 - Win32 Release" +# Name "frames_to_mj2 - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=..\libopenjpeg\bio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\cio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\dwt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\fix.c +# End Source File +# Begin Source File + +SOURCE=.\frames_to_mj2.c +# End Source File +# Begin Source File + +SOURCE=.\compat\getopt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jpt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mct.c +# End Source File +# Begin Source File + +SOURCE=.\mj2.c +# End Source File +# Begin Source File + +SOURCE=.\mj2_convert.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mqc.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\pi.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\raw.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t1.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tcd.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tgt.c +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=..\libopenjpeg\bio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\cio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\dwt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\fix.h +# End Source File +# Begin Source File + +SOURCE=.\compat\getopt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jpt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mct.h +# End Source File +# Begin Source File + +SOURCE=.\mj2.h +# End Source File +# Begin Source File + +SOURCE=.\mj2_convert.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mqc.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\openjpeg.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\pi.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\raw.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t1.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t2.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tcd.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tgt.h +# End Source File +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# End Group +# End Target +# End Project diff --git a/mj2/mj2.c b/mj2/mj2.c new file mode 100644 index 00000000..9eb2abb3 --- /dev/null +++ b/mj2/mj2.c @@ -0,0 +1,2958 @@ +/* +* Copyright (c) 2003-2004, François-Olivier Devaux +* Copyright (c) 2003-2004, 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 +#include +#include +#include +#include +#include + +#include "mj2.h" +#include "mj2_convert.h" + +#define MJ2_JP 0x6a502020 +#define MJ2_FTYP 0x66747970 +#define MJ2_MJ2 0x6d6a7032 +#define MJ2_MJ2S 0x6d6a3273 +#define MJ2_MDAT 0x6d646174 +#define MJ2_MOOV 0x6d6f6f76 +#define MJ2_MVHD 0x6d766864 +#define MJ2_TRAK 0x7472616b +#define MJ2_TKHD 0x746b6864 +#define MJ2_MDIA 0x6d646961 +#define MJ2_MDHD 0x6d646864 +#define MJ2_MHDR 0x6d686472 +#define MJ2_HDLR 0x68646C72 +#define MJ2_MINF 0x6d696e66 +#define MJ2_VMHD 0x766d6864 +#define MJ2_SMHD 0x736d6864 +#define MJ2_HMHD 0x686d6864 +#define MJ2_DINF 0x64696e66 +#define MJ2_DREF 0x64726566 +#define MJ2_URL 0x75726c20 +#define MJ2_URN 0x75726e20 +#define MJ2_STBL 0x7374626c +#define MJ2_STSD 0x73747364 +#define MJ2_STTS 0x73747473 +#define MJ2_STSC 0x73747363 +#define MJ2_STSZ 0x7374737A +#define MJ2_STCO 0x7374636f +#define MJ2_MOOF 0x6d6f6f66 +#define MJ2_FREE 0x66726565 +#define MJ2_SKIP 0x736b6970 +#define MJ2_JP2C 0x6a703263 +#define MJ2_FIEL 0x6669656c +#define MJ2_JP2P 0x6a703270 +#define MJ2_JP2X 0x6a703278 +#define MJ2_JSUB 0x6a737562 +#define MJ2_ORFO 0x6f72666f +#define MJ2_MVEX 0x6d766578 +#define MJ2_JP2 0x6a703220 +#define MJ2_J2P0 0x4a325030 + +/* +* +* Free movie structure memory +* +*/ +void mj2_memory_free(mj2_movie_t * movie) +{ + int i; + mj2_tk_t *tk; + + if (movie->num_cl != 0) + free(movie->cl); + + for (i = 0; i < movie->num_vtk + movie->num_stk + movie->num_htk; i++) { + tk = &movie->tk[i]; + if (tk->name_size != 0) + free(tk->name); + if (tk->num_url != 0) + free(tk->url); + if (tk->num_urn != 0) + free(tk->urn); + if (tk->num_br != 0) + free(tk->br); + if (tk->num_jp2x != 0) + free(tk->jp2xdata); + if (tk->num_tts != 0) + free(tk->tts); + if (tk->num_chunks != 0) + free(tk->chunk); + if (tk->num_samplestochunk != 0) + free(tk->sampletochunk); + if (tk->num_samples != 0) + free(tk->sample); + } + + free(movie->tk); +} + +/* +* +* Read box headers +* +*/ + +int mj2_read_boxhdr(mj2_box_t * box) +{ + box->init_pos = cio_tell(); + box->length = cio_read(4); + box->type = cio_read(4); + if (box->length == 1) { + if (cio_read(4) != 0) { + fprintf(stderr, "Error: Cannot handle box sizes higher than 2^32\n"); + return 1; + }; + box->length = cio_read(4); + } + return 0; +} + +/* +* +* Initialisation of a Standard Video Track +* with one sample per chunk +*/ + +int mj2_init_stdmovie(mj2_movie_t * movie) +{ + int i; + unsigned int j; + time_t ltime; + movie->brand = MJ2_MJ2; + movie->minversion = 0; + movie->num_cl = 2; + movie->cl = + (unsigned int *) malloc(movie->num_cl * sizeof(unsigned int)); + + movie->cl[0] = MJ2_MJ2; + movie->cl[1] = MJ2_MJ2S; + time(<ime); /* Time since 1/1/70 */ + movie->creation_time = (unsigned int) ltime + 2082844800; /* Seconds between 1/1/04 and 1/1/70 */ + movie->timescale = 1000; + + movie->rate = 1; /* Rate to play presentation (default = 0x00010000) */ + movie->volume = 1; /* Movie volume (default = 0x0100) */ + movie->trans_matrix[0] = 0x00010000; /* Transformation matrix for video */ + movie->trans_matrix[1] = 0; /* Unity is { 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 } */ + movie->trans_matrix[2] = 0; + movie->trans_matrix[3] = 0; + movie->trans_matrix[4] = 0x00010000; + movie->trans_matrix[5] = 0; + movie->trans_matrix[6] = 0; + movie->trans_matrix[7] = 0; + movie->trans_matrix[8] = 0x40000000; + + + + for (i = 0; i < movie->num_htk + movie->num_stk + movie->num_vtk; i++) { + mj2_tk_t *tk = &movie->tk[i]; + if (tk->track_type == 0) { + tk->num_samples = yuv_num_frames(tk); + + if (tk->num_samples == 0) + return 1; + + tk->Dim[0] = 0; + tk->Dim[1] = 0; + + tk->timescale = 1000; /* Timescale = 1 ms */ + + tk->sample = + (mj2_sample_t *) malloc(tk->num_samples * sizeof(mj2_sample_t)); + tk->num_chunks = tk->num_samples; + tk->chunk = + (mj2_chunk_t *) malloc(tk->num_chunks * sizeof(mj2_chunk_t)); + tk->chunk[0].num_samples = 1; + tk->chunk[0].sample_descr_idx = 1; + + tk->same_sample_size = 0; + + tk->num_samplestochunk = 1; /* One sample per chunk */ + tk->sampletochunk = + (mj2_sampletochunk_t *) malloc(tk->num_samplestochunk * + sizeof(mj2_sampletochunk_t)); + tk->sampletochunk[0].first_chunk = 1; + tk->sampletochunk[0].samples_per_chunk = 1; + tk->sampletochunk[0].sample_descr_idx = 1; + + for (j = 0; j < tk->num_samples; j++) + tk->sample[j].sample_delta = tk->timescale / tk->sample_rate; + + tk->num_tts = 1; + tk->tts = (mj2_tts_t *) malloc(tk->num_tts * sizeof(mj2_tts_t)); + tk->tts[0].sample_count = tk->num_samples; + tk->tts[0].sample_delta = tk->timescale / tk->sample_rate; + + tk->horizresolution = 0x00480000; /* Horizontal resolution (typically 72) */ + tk->vertresolution = 0x00480000; /* Vertical resolution (typically 72) */ + tk->compressorname[0] = 0x0f4d6f74; /* Compressor Name[]: Motion JPEG2000 */ + tk->compressorname[1] = 0x696f6e20; + tk->compressorname[2] = 0x4a504547; + tk->compressorname[3] = 0x32303030; + tk->compressorname[4] = 0x00120000; + tk->compressorname[5] = 0; + tk->compressorname[6] = 0x00000042; + tk->compressorname[7] = 0x000000DC; + tk->num_url = 0; /* Number of URL */ + tk->num_urn = 0; /* Number of URN */ + tk->graphicsmode = 0; /* Graphicsmode */ + tk->opcolor[0] = 0; /* OpColor */ + tk->opcolor[1] = 0; /* OpColor */ + tk->opcolor[2] = 0; /* OpColor */ + tk->creation_time = movie->creation_time; /* Seconds between 1/1/04 and 1/1/70 */ + tk->language = 0; /* Language (undefined) */ + tk->layer = 0; + tk->volume = 1; + tk->trans_matrix[0] = 0x00010000; /* Transformation matrix for track */ + tk->trans_matrix[1] = 0; /* Unity is { 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 } */ + tk->trans_matrix[2] = 0; + tk->trans_matrix[3] = 0; + tk->trans_matrix[4] = 0x00010000; + tk->trans_matrix[5] = 0; + tk->trans_matrix[6] = 0; + tk->trans_matrix[7] = 0; + tk->trans_matrix[8] = 0x40000000; + tk->fieldcount = 1; + tk->fieldorder = 0; + tk->or_fieldcount = 1; + tk->or_fieldorder = 0; + tk->num_br = 2; + tk->br = (unsigned int *) malloc(tk->num_br * sizeof(unsigned int)); + tk->br[0] = MJ2_JP2; + tk->br[1] = MJ2_J2P0; + tk->num_jp2x = 0; + tk->hsub = 2; /* 4:2:0 */ + tk->vsub = 2; /* 4:2:0 */ + tk->hoff = 0; + tk->voff = 0; + } + } + return 0; +} + +/* +* Time To Sample box Decompact +* +*/ +void mj2_tts_decompact(mj2_tk_t * tk) +{ + int i, j; + tk->num_samples = 0; + for (i = 0; i < tk->num_tts; i++) { + tk->num_samples += tk->tts[i].sample_count; + } + + tk->sample = + (mj2_sample_t *) malloc(tk->num_samples * sizeof(mj2_sample_t)); + + for (i = 0; i < tk->num_tts; i++) { + for (j = 0; j < tk->tts[i].sample_count; j++) { + tk->sample[j].sample_delta = tk->tts[i].sample_delta; + } + } +} + +/* +* Sample To Chunk box Decompact +* +*/ +void mj2_stsc_decompact(mj2_tk_t * tk) +{ + int j, i; + unsigned int k; + + if (tk->num_samplestochunk == 1) { + tk->num_chunks = + (unsigned int) ceil((double) tk->num_samples / + (double) tk->sampletochunk[0].samples_per_chunk); + tk->chunk = + (mj2_chunk_t *) malloc(tk->num_chunks * sizeof(mj2_chunk_t)); + for (k = 0; k < tk->num_chunks; k++) { + tk->chunk[k].num_samples = tk->sampletochunk[0].samples_per_chunk; + } + + } else { + tk->chunk = + (mj2_chunk_t *) malloc(tk->num_samples * sizeof(mj2_chunk_t)); + tk->num_chunks = 0; + for (i = 0; i < tk->num_samplestochunk - 1; i++) { + for (j = tk->sampletochunk[i].first_chunk - 1; + j < tk->sampletochunk[i + 1].first_chunk - 1; j++) { + tk->chunk[j].num_samples = tk->sampletochunk[i].samples_per_chunk; + tk->num_chunks++; + } + } + tk->num_chunks++; + for (k = tk->sampletochunk[tk->num_samplestochunk].first_chunk - 1; + k < tk->num_chunks; k++) { + tk->chunk[k].num_samples = + tk->sampletochunk[tk->num_samplestochunk].samples_per_chunk; + } + tk->chunk = realloc(tk->chunk, tk->num_chunks * sizeof(mj2_chunk_t)); + } + +} + +/* +* Chunk offset box Decompact +* +*/ +void mj2_stco_decompact(mj2_tk_t * tk) +{ + int j; + unsigned int i; + int k = 0; + int intra_chunk_offset; + + for (i = 0; i < tk->num_chunks; i++) { + intra_chunk_offset = 0; + for (j = 0; j < tk->chunk[i].num_samples; j++) { + tk->sample[k].offset = intra_chunk_offset + tk->chunk[i].offset; + intra_chunk_offset += tk->sample[k].sample_size; + k++; + } + } +} + +/* +* Write the JP box +* +* JP Signature box +* +*/ +void mj2_write_jp() +{ + mj2_box_t box; + box.init_pos = cio_tell(); + cio_skip(4); + + cio_write(MJ2_JP, 4); /* JP */ + cio_write(0x0d0a870a, 4); /* 0x0d0a870a required in a JP box */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); + cio_seek(box.init_pos + box.length); +} + +/* +* Read the JP box +* +* JPEG 2000 signature +* +*/ +int mj2_read_jp() +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_JP != box.type) { /* Check Marker */ + fprintf(stderr, "Error: Expected JP Marker\n"); + return 1; + } + if (0x0d0a870a != cio_read(4)) { /* read the 0x0d0a870a required in a JP box */ + fprintf(stderr, "Error with JP Marker\n"); + return 1; + } + if (cio_tell() - box.init_pos != box.length) { /* Check box length */ + fprintf(stderr, "Error with JP Box size \n"); + return 1; + } + return 0; + +} + +/* +* Write the FTYP box +* +* File type box +* +*/ +void mj2_write_ftyp(mj2_movie_t * movie) +{ + int i; + mj2_box_t box; + box.init_pos = cio_tell(); + cio_skip(4); + + cio_write(MJ2_FTYP, 4); /* FTYP */ + cio_write(movie->brand, 4); /* BR */ + cio_write(movie->minversion, 4); /* MinV */ + + for (i = 0; i < movie->num_cl; i++) + cio_write(movie->cl[i], 4); /* CL */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* Length */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the FTYP box +* +* File type box +* +*/ +int mj2_read_ftyp(mj2_movie_t * movie) +{ + int i; + mj2_box_t box; + + mj2_read_boxhdr(&box); /* Box Size */ + if (MJ2_FTYP != box.type) { + fprintf(stderr, "Error: Expected FTYP Marker\n"); + return 1; + } + + movie->brand = cio_read(4); /* BR */ + movie->minversion = cio_read(4); /* MinV */ + movie->num_cl = (box.length - 16) / 4; + movie->cl = + (unsigned int *) malloc(movie->num_cl * sizeof(unsigned int)); + + for (i = movie->num_cl - 1; i > -1; i--) + movie->cl[i] = cio_read(4); /* CLi */ + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with FTYP Box\n"); + return 1; + } + return 0; +} + +/* +* Write the MDAT box +* +* Media Data box +* +*/ +int mj2_write_mdat(FILE * outfile, mj2_movie_t * movie, j2k_image_t * img, + j2k_cp_t * cp, char *outbuf, char *index) +{ + unsigned char box_len_ptr; + mj2_box_t box; + int len, l, k; + int i, m; + unsigned int j; + int pos_correction = 0; + int tileno; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MDAT, 4); /* MDAT */ + + + for (i = 0; i < movie->num_stk; i++) { + fprintf(stderr, "Unable to write sound tracks\n"); + } + + for (i = 0; i < movie->num_htk; i++) { + fprintf(stderr, "Unable to write hint tracks\n"); + } + + for (i = 0; i < movie->num_vtk; i++) { + j2k_cp_t cp_init; + mj2_tk_t *tk; + + tk = &movie->tk[i]; + + fprintf(stderr, "Video Track number %d\n", i + 1); + + len = cio_tell(); + fwrite(outbuf, 1, len, outfile); + pos_correction = cio_tell() + pos_correction; + free(outbuf); + + /* Copy the first tile coding parameters (tcp) to cp_init */ + + cp_init.tcps = + (j2k_tcp_t *) malloc(cp->tw * cp->th * sizeof(j2k_tcp_t)); + for (tileno = 0; tileno < cp->tw * cp->th; tileno++) { + for (l = 0; l < cp->tcps[tileno].numlayers; l++) { + cp_init.tcps[tileno].rates[l] = cp->tcps[tileno].rates[l]; + //tileno = cp->tcps[tileno].rates[l]; + } + } + + + for (j = 0; j < tk->num_samples; j++) { + outbuf = (char *) malloc(cp->tdx * cp->tdy * cp->th * cp->tw * 2); + cio_init(outbuf, cp->tdx * cp->tdy * cp->th * cp->tw * 2); + + fprintf(stderr, "Frame number %d/%d: \n", j + 1, tk->num_samples); + + + if (!yuvtoimage(tk, img, j)) { + fprintf(stderr, "Error with frame number %d in YUV file\n", j); + return 1; + } + + len = jp2_write_jp2c(img, cp, outbuf, index); + + for (m = 0; m < img->numcomps; m++) { + free(img->comps[m].data); + } + + tk->sample[j].sample_size = len; + + tk->sample[j].offset = pos_correction; + tk->chunk[j].offset = pos_correction; /* There is one sample per chunk */ + + fwrite(outbuf, 1, len, outfile); + + pos_correction = cio_tell() + pos_correction; + + free(outbuf); + + /* Copy the cp_init parameters to cp->tcps */ + + for (tileno = 0; tileno < cp->tw * cp->th; tileno++) { + for (k = 0; k < cp->tcps[tileno].numlayers; k++) { + cp->tcps[tileno].rates[k] = cp_init.tcps[tileno].rates[k]; + } + } + } + } + + box.length = pos_correction - box.init_pos; + + fseek(outfile, box.init_pos, SEEK_SET); + + cio_init(&box_len_ptr, 4); /* Init a cio to write box length variable in a little endian way */ + cio_write(box.length, 4); + + fwrite(&box_len_ptr, 4, 1, outfile); + + fseek(outfile, box.init_pos + box.length, SEEK_SET); + + return 0; +} + +/* +* Read the MDAT box +* +* Media Data box +* +*/ +int mj2_read_mdat(mj2_movie_t * movie, unsigned char *src, char *outfile) +{ + int track_nb; + unsigned int i; + int jp2c_cio_len, jp2c_len, pos_correction = 0; + FILE *f; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_MDAT != box.type) { + fprintf(stderr, "Error: Expected MDAT Marker\n"); + return 1; + } + + pos_correction = cio_tell() - box.init_pos; + + f = fopen(outfile, "w"); /* Erase content of file if it already exists */ + fclose(f); + + for (track_nb = 0; track_nb < movie->next_tk_id - 1; track_nb++) { + if ((movie->tk->imagefile != (char *) 0xcdcdcdcd) + && (movie->tk->imagefile != NULL)) { + fprintf(stderr, "%s", movie->tk->imagefile); + + f = fopen(movie->tk->imagefile, "w"); /* Erase content of file if it already exists */ + fclose(f); + } + } + + + for (track_nb = 0; + track_nb < movie->num_htk + movie->num_stk + movie->num_vtk; + track_nb++) { + mj2_tk_t *tk = &movie->tk[track_nb]; + if (tk->track_type != 0) { + cio_seek(box.init_pos); + cio_skip(box.length); + } else { + fprintf(stderr, "Track %d: Width=%d Height=%d\n", track_nb, + tk->w, tk->h); + fprintf(stderr, "%d Samples\n", tk->num_samples); + if ((movie->tk->imagefile = (char *) 0xcdcdcdcd) + || (movie->tk->imagefile == NULL)) { + tk->imagefile = outfile; + } + for (i = 0; i < tk->num_samples; i++) { + + mj2_sample_t *sample = &tk->sample[i]; + j2k_image_t img; + j2k_cp_t cp; + unsigned char *pos; + + fprintf(stderr, "Frame %d: \n", i); + + cio_init(src + sample->offset, 8); + + jp2c_cio_len = cio_tell(); + jp2c_len = cio_read(4); + + + if (MJ2_JP2C != cio_read(4)) { + fprintf(stderr, "Error: Expected JP2C Marker\n"); + return 1; + } + + pos = src + sample->offset + 8; + + cio_seek(sample->offset + 8); + + if (!j2k_decode(pos, sample->sample_size, &img, &cp)) + return 1; + + if (imagetoyuv(&img, &cp, tk->imagefile)) + return 1; + + if (cio_tell() + 8 != jp2c_len) { + fprintf(stderr, "Error with JP2C Box Size\n"); + return 1; + } + + } + } + } + + cio_seek(box.init_pos); + cio_skip(box.length); /* Go back to box end */ + + return 0; +} + +/* +* Write the STCO box +* +* Chunk Offset Box +* +*/ +void mj2_write_stco(mj2_tk_t * tk) +{ + mj2_box_t box; + unsigned int i; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STCO, 4); /* STCO */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->num_chunks, 4); /* Entry Count */ + + for (i = 0; i < tk->num_chunks; i++) { + cio_write(tk->chunk[i].offset, 4); /* Entry offset */ + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STCO box +* +* Chunk Offset Box +* +*/ +int mj2_read_stco(mj2_tk_t * tk) +{ + unsigned int i; + mj2_box_t box; + + mj2_read_boxhdr(&box); /* Box Size */ + if (MJ2_STCO != box.type) { + fprintf(stderr, "Error: Expected STCO Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in STCO box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in STCO box. Expected flag 0\n"); + return 1; + } + + + if (cio_read(4) != tk->num_chunks) { + fprintf(stderr, + "Error in STCO box: expecting same amount of entry-count as chunks \n"); + } else { + for (i = 0; i < tk->num_chunks; i++) { + tk->chunk[i].offset = cio_read(4); /* Entry offset */ + } + } + + mj2_stco_decompact(tk); + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STCO Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the STSZ box +* +* Sample size box +* +*/ +void mj2_write_stsz(mj2_tk_t * tk) +{ + mj2_box_t box; + unsigned int i; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STSZ, 4); /* STSZ */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + if (tk->same_sample_size == 1) { /* If they all have the same size */ + cio_write(tk->sample[0].sample_size, 4); /* Size */ + + cio_write(1, 4); /* Entry count = 1 */ + } + + else { + cio_write(0, 4); /* Sample Size = 0 becase they all have different sizes */ + + cio_write(tk->num_samples, 4); /* Sample Count */ + + for (i = 0; i < tk->num_samples; i++) { + cio_write(tk->sample[i].sample_size, 4); + } + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STSZ box +* +* Sample size box +* +*/ +int mj2_read_stsz(mj2_tk_t * tk) +{ + int sample_size; + unsigned int i; + mj2_box_t box; + + mj2_read_boxhdr(&box); /* Box Size */ + if (MJ2_STSZ != box.type) { + fprintf(stderr, "Error: Expected STSZ Marker\n"); + return 1; + } + + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in STSZ box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in STSZ box. Expected flag 0\n"); + return 1; + } + + sample_size = cio_read(4); + + if (sample_size != 0) { /* Samples do not have the same size */ + tk->same_sample_size = 0; + for (i = 0; i < tk->num_samples; i++) { + tk->sample[i].sample_size = sample_size; + } + cio_skip(4); /* Sample count = 1 */ + } else { + tk->same_sample_size = 1; + if (tk->num_samples != cio_read(4)) { /* Sample count */ + fprintf(stderr, + "Error in STSZ box. Expected that sample-count is number of samples in track\n"); + return 1; + } + for (i = 0; i < tk->num_samples; i++) { + tk->sample[i].sample_size = cio_read(4); /* Sample Size */ + } + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STSZ Box size\n"); + return 1; + } + } + return 0; + +} + +/* +* Write the STSC box +* +* Sample to Chunk +* +*/ +void mj2_write_stsc(mj2_tk_t * tk) +{ + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STSC, 4); /* STSC */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->num_samplestochunk, 4); /* Entry Count */ + + for (i = 0; i < tk->num_samplestochunk; i++) { + cio_write(tk->sampletochunk[i].first_chunk, 4); /* First Chunk */ + cio_write(tk->sampletochunk[i].samples_per_chunk, 4); /* Samples per chunk */ + cio_write(tk->sampletochunk[i].sample_descr_idx, 4); /* Samples description index */ + } + + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STSC box +* +* Sample to Chunk +* +*/ +int mj2_read_stsc(mj2_tk_t * tk) +{ + int i; + mj2_box_t box; + + mj2_read_boxhdr(&box); /* Box Size */ + if (MJ2_STSC != box.type) { + fprintf(stderr, "Error: Expected STSC Marker\n"); + return 1; + } + + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in STSC box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in STSC box. Expected flag 0\n"); + return 1; + } + + tk->num_samplestochunk = cio_read(4); + + tk->sampletochunk = + (mj2_sampletochunk_t *) malloc(tk->num_samplestochunk * + sizeof(mj2_sampletochunk_t)); + + + for (i = 0; i < tk->num_samplestochunk; i++) { + tk->sampletochunk[i].first_chunk = cio_read(4); + tk->sampletochunk[i].samples_per_chunk = cio_read(4); + tk->sampletochunk[i].sample_descr_idx = cio_read(4); + } + + mj2_stsc_decompact(tk); /* decompact sample to chunk box */ + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STSC Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the STTS box +* +* Time to Sample Box +* +*/ +void mj2_write_stts(mj2_tk_t * tk) +{ + + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STTS, 4); /* STTS */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->num_tts, 4); /* entry_count */ + for (i = 0; i < tk->num_tts; i++) { + cio_write(tk->tts[i].sample_count, 4); /* Sample-count */ + cio_write(tk->tts[i].sample_delta, 4); /* Sample-Delta */ + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STTS box +* +* +* +*/ +int mj2_read_stts(mj2_tk_t * tk) +{ + int i; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_STTS != box.type) { + fprintf(stderr, "Error: Expected STTS Marker\n"); + return 1; + } + + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in STTS box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in STTS box. Expected flag 0\n"); + return 1; + } + + tk->num_tts = cio_read(4); + + tk->tts = (mj2_tts_t *) malloc(tk->num_tts * sizeof(mj2_tts_t)); + + for (i = 0; i < tk->num_tts; i++) { + tk->tts[i].sample_count = cio_read(4); + tk->tts[i].sample_delta = cio_read(4); + } + + mj2_tts_decompact(tk); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STTS Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the FIEL box +* +* Field coding Box +* +*/ +void mj2_write_fiel(mj2_tk_t * tk) +{ + + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_FIEL, 4); /* STTS */ + + cio_write(tk->fieldcount, 1); /* Field count */ + cio_write(tk->fieldorder, 1); /* Field order */ + + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the FIEL box +* +* Field coding Box +* +*/ +int mj2_read_fiel(mj2_tk_t * tk) +{ + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_FIEL != box.type) { + fprintf(stderr, "Error: Expected FIEL Marker\n"); + return 1; + } + + + tk->fieldcount = cio_read(1); + tk->fieldorder = cio_read(1); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with FIEL Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the ORFO box +* +* Original Format Box +* +*/ +void mj2_write_orfo(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_ORFO, 4); + + cio_write(tk->or_fieldcount, 1); /* Original Field count */ + cio_write(tk->or_fieldorder, 1); /* Original Field order */ + + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the ORFO box +* +* Original Format Box +* +*/ +int mj2_read_orfo(mj2_tk_t * tk) +{ + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_ORFO != box.type) { + fprintf(stderr, "Error: Expected ORFO Marker\n"); + return 1; + } + + + tk->or_fieldcount = cio_read(1); + tk->or_fieldorder = cio_read(1); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with ORFO Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the JP2P box +* +* MJP2 Profile Box +* +*/ +void mj2_write_jp2p(mj2_tk_t * tk) +{ + + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_JP2P, 4); + + cio_write(0, 4); /* Version 0, flags =0 */ + + for (i = 0; i < tk->num_br; i++) { + cio_write(tk->br[i], 4); + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the JP2P box +* +* MJP2 Profile Box +* +*/ +int mj2_read_jp2p(mj2_tk_t * tk) +{ + int i; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_JP2P != box.type) { + fprintf(stderr, "Error: Expected JP2P Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in JP2P box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in JP2P box. Expected flag 0\n"); + return 1; + } + + + tk->num_br = (box.length - 12) / 4; + tk->br = (unsigned int *) malloc(tk->num_br * sizeof(unsigned int)); + + for (i = 0; i < tk->num_br; i++) { + tk->br[i] = cio_read(4); + } + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with JP2P Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the JP2X box +* +* MJP2 Prefix Box +* +*/ +void mj2_write_jp2x(mj2_tk_t * tk) +{ + + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_JP2X, 4); + + for (i = 0; i < tk->num_jp2x; i++) { + cio_write(tk->jp2xdata[i], 1); + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the JP2X box +* +* MJP2 Prefix Box +* +*/ +int mj2_read_jp2x(mj2_tk_t * tk) +{ + unsigned int i; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_JP2X != box.type) { + fprintf(stderr, "Error: Expected JP2X Marker\n"); + return 1; + } + + + tk->num_jp2x = (box.length - 8); + tk->jp2xdata = + (unsigned char *) malloc(tk->num_jp2x * sizeof(unsigned char)); + + for (i = 0; i < tk->num_jp2x; i++) { + tk->jp2xdata[i] = cio_read(1); + } + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with JP2X Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the JSUB box +* +* MJP2 Subsampling Box +* +*/ +void mj2_write_jsub(mj2_tk_t * tk) +{ + + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_JSUB, 4); + + cio_write(tk->hsub, 1); + cio_write(tk->vsub, 1); + cio_write(tk->hoff, 1); + cio_write(tk->voff, 1); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the JSUB box +* +* MJP2 Subsampling Box +* +*/ +int mj2_read_jsub(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_JSUB != box.type) { + fprintf(stderr, "Error: Expected JSUB Marker\n"); + return 1; + } + + tk->hsub = cio_read(1); + tk->vsub = cio_read(1); + tk->hoff = cio_read(1);; + tk->voff = cio_read(1); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with JSUB Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the SMJ2 box +* +* Visual Sample Entry Description +* +*/ +void mj2_write_smj2(j2k_image_t * img, mj2_tk_t * tk) +{ + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MJ2, 4); /* MJ2 */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(1, 4); + + cio_write(0, 2); /* Pre-defined */ + + cio_write(0, 2); /* Reserved */ + + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + + cio_write(tk->w, 2); /* Width */ + cio_write(tk->h, 2); /* Height */ + + cio_write(tk->horizresolution, 4); /* Horizontal resolution */ + cio_write(tk->vertresolution, 4); /* Vertical resolution */ + + cio_write(0, 4); /* Reserved */ + + cio_write(1, 2); /* Pre-defined = 1 */ + + cio_write(tk->compressorname[0], 4); /* Compressor Name */ + cio_write(tk->compressorname[1], 4); + cio_write(tk->compressorname[2], 4); + cio_write(tk->compressorname[3], 4); + cio_write(tk->compressorname[4], 4); + cio_write(tk->compressorname[5], 4); + cio_write(tk->compressorname[6], 4); + cio_write(tk->compressorname[7], 4); + + tk->depth = 0; + + for (i = 0; i < img->numcomps; i++) + tk->depth += img->comps[i].bpp; + + cio_write(tk->depth, 2); /* Depth */ + + cio_write(0xffff, 2); /* Pre-defined = -1 */ + + jp2_init_stdjp2(&tk->jp2_struct, img); + + jp2_write_jp2h(&tk->jp2_struct); + + mj2_write_fiel(tk); + + if (tk->num_br != 0) + mj2_write_jp2p(tk); + if (tk->num_jp2x != 0) + mj2_write_jp2x(tk); + + mj2_write_jsub(tk); + mj2_write_orfo(tk); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the SMJ2 box +* +* Visual Sample Entry Description +* +*/ +int mj2_read_smj2(j2k_image_t * img, mj2_tk_t * tk) +{ + mj2_box_t box; + mj2_box_t box2; + int i; + + mj2_read_boxhdr(&box); + + if (MJ2_MJ2 != box.type) { + fprintf(stderr, "Error in SMJ2 box: Expected MJ2 Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in MJP2 box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in MJP2 box. Expected flag 0\n"); + return 1; + } + + cio_skip(4); + + cio_skip(2); /* Pre-defined */ + + cio_skip(2); /* Reserved */ + + cio_skip(4); /* Pre-defined */ + cio_skip(4); /* Pre-defined */ + cio_skip(4); /* Pre-defined */ + + tk->w = cio_read(2); /* Width */ + tk->h = cio_read(2); /* Height */ + + tk->horizresolution = cio_read(4); /* Horizontal resolution */ + tk->vertresolution = cio_read(4); /* Vertical resolution */ + + cio_skip(4); /* Reserved */ + + cio_skip(2); /* Pre-defined = 1 */ + + tk->compressorname[0] = cio_read(4); /* Compressor Name */ + tk->compressorname[1] = cio_read(4); + tk->compressorname[2] = cio_read(4); + tk->compressorname[3] = cio_read(4); + tk->compressorname[4] = cio_read(4); + tk->compressorname[5] = cio_read(4); + tk->compressorname[6] = cio_read(4); + tk->compressorname[7] = cio_read(4); + + tk->depth = cio_read(2); /* Depth */ + + /* Init std value */ + tk->num_jp2x = 0; + tk->fieldcount = 1; + tk->fieldorder = 0; + tk->or_fieldcount = 1; + tk->or_fieldorder = 0; + + cio_skip(2); /* Pre-defined = -1 */ + + if (jp2_read_jp2h(&tk->jp2_struct)) { + fprintf(stderr, "Error with JP2H Box\n"); + return 1; + } + + for (i = 0; cio_tell() - box.init_pos < box.length; i++) { + mj2_read_boxhdr(&box2); + cio_seek(box2.init_pos); + switch (box2.type) { + case MJ2_FIEL: + if (mj2_read_fiel(tk)) + return 1; + break; + + case MJ2_JP2P: + if (mj2_read_jp2p(tk)) + return 1; + break; + + case MJ2_JP2X: + if (mj2_read_jp2x(tk)) + return 1; + break; + + case MJ2_JSUB: + if (mj2_read_jsub(tk)) + return 1; + break; + + case MJ2_ORFO: + if (mj2_read_orfo(tk)) + return 1; + break; + + default: + fprintf(stderr, "Error with MJP2 Box size\n"); + return 1; + break; + + } + } + return 0; +} + + +/* +* Write the STSD box +* +* Sample Description +* +*/ +void mj2_write_stsd(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STSD, 4); /* STSD */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(1, 4); /* entry_count = 1 (considering same JP2 headerboxes) */ + + if (tk->track_type == 0) { + mj2_write_smj2(img, tk); + } else if (tk->track_type == 1) { + // Not implemented + } + if (tk->track_type == 2) { + // Not implemented + } + + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STSD box +* +* Sample Description +* +*/ +int mj2_read_stsd(mj2_tk_t * tk, j2k_image_t * img) +{ + int i; + int entry_count, len_2skip; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + + if (MJ2_STSD != box.type) { + fprintf(stderr, "Error: Expected STSD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in STSD box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in STSD box. Expected flag 0\n"); + return 1; + } + + entry_count = cio_read(4); + + if (tk->track_type == 0) { + for (i = 0; i < entry_count; i++) { + if (mj2_read_smj2(img, tk)) + return 1; + } + } else if (tk->track_type == 1) { + len_2skip = cio_read(4); // Not implemented -> skipping box + cio_skip(len_2skip - 4); + } else if (tk->track_type == 2) { + len_2skip = cio_read(4); // Not implemented -> skipping box + cio_skip(len_2skip - 4); + } + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STSD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the STBL box +* +* Sample table box box +* +*/ +void mj2_write_stbl(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STBL, 4); /* STBL */ + + mj2_write_stsd(tk, img); + mj2_write_stts(tk); + mj2_write_stsc(tk); + mj2_write_stsz(tk); + mj2_write_stco(tk); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STBL box +* +* Sample table box box +* +*/ +int mj2_read_stbl(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_STBL != box.type) { + fprintf(stderr, "Error: Expected STBL Marker\n"); + return 1; + } + + if (mj2_read_stsd(tk, img)) + return 1; + if (mj2_read_stts(tk)) + return 1; + if (mj2_read_stsc(tk)) + return 1; + if (mj2_read_stsz(tk)) + return 1; + if (mj2_read_stco(tk)) + return 1; + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STBL Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the URL box +* +* URL box +* +*/ +void mj2_write_url(mj2_tk_t * tk, int url_num) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_URL, 4); /* URL */ + + if (url_num == 0) + cio_write(1, 4); /* Version = 0, flags = 1 because stored in same file */ + else { + cio_write(0, 4); /* Version = 0, flags = 0 */ + cio_write(tk->url[url_num - 1].location[0], 4); + cio_write(tk->url[url_num - 1].location[1], 4); + cio_write(tk->url[url_num - 1].location[2], 4); + cio_write(tk->url[url_num - 1].location[3], 4); + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the URL box +* +* URL box +* +*/ +int mj2_read_url(mj2_tk_t * tk, int urn_num) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_URL != box.type) { + fprintf(stderr, "Error: Expected URL Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in URL box\n"); + return 1; + } + + if (1 != cio_read(3)) { /* If flags = 1 --> media data in file */ + tk->url[urn_num].location[0] = cio_read(4); + tk->url[urn_num].location[1] = cio_read(4); + tk->url[urn_num].location[2] = cio_read(4); + tk->url[urn_num].location[3] = cio_read(4); + } else { + tk->num_url--; + } + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with URL Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the URN box +* +* URN box +* +*/ +void mj2_write_urn(mj2_tk_t * tk, int urn_num) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_URN, 4); /* URN */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->urn[urn_num].name[0], 4); + cio_write(tk->urn[urn_num].name[1], 4); + cio_write(tk->urn[urn_num].name[2], 4); + cio_write(tk->urn[urn_num].name[3], 4); + cio_write(tk->urn[urn_num].location[0], 4); + cio_write(tk->urn[urn_num].location[1], 4); + cio_write(tk->urn[urn_num].location[2], 4); + cio_write(tk->urn[urn_num].location[3], 4); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the URN box +* +* URN box +* +*/ +int mj2_read_urn(mj2_tk_t * tk, int urn_num) +{ + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_URN != box.type) { + fprintf(stderr, "Error: Expected URN Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in URN box\n"); + return 1; + } + + if (1 != cio_read(3)) { /* If flags = 1 --> media data in file */ + tk->urn[urn_num].name[0] = cio_read(4); + tk->urn[urn_num].name[1] = cio_read(4); + tk->urn[urn_num].name[2] = cio_read(4); + tk->urn[urn_num].name[3] = cio_read(4); + tk->urn[urn_num].location[0] = cio_read(4); + tk->urn[urn_num].location[1] = cio_read(4); + tk->urn[urn_num].location[2] = cio_read(4); + tk->urn[urn_num].location[3] = cio_read(4); + } + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with URN Box size\n"); + return 1; + } + return 0; +} + + +/* +* Write the DREF box +* +* Data reference box +* +*/ +void mj2_write_dref(mj2_tk_t * tk) +{ + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_DREF, 4); /* DREF */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + if (tk->num_url + tk->num_urn == 0) { /* Media data in same file */ + cio_write(1, 4); /* entry_count = 1 */ + mj2_write_url(tk, 0); + } else { + cio_write(tk->num_url + tk->num_urn, 4); /* entry_count */ + + for (i = 0; i < tk->num_url; i++) + mj2_write_url(tk, i + 1); + + for (i = 0; i < tk->num_urn; i++) + mj2_write_urn(tk, i); + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the DREF box +* +* Data reference box +* +*/ +int mj2_read_dref(mj2_tk_t * tk) +{ + + int i; + int entry_count; + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_DREF != box.type) { + fprintf(stderr, "Error: Expected DREF Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in DREF box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in DREF box. Expected flag 0\n"); + return 1; + } + + entry_count = cio_read(4); + tk->num_url = 0; + tk->num_urn = 0; + + for (i = 0; i < entry_count; i++) { + cio_skip(4); + if (cio_read(4) == MJ2_URL) { + cio_skip(-8); + tk->num_url++; + if (mj2_read_url(tk, tk->num_url)) + return 1; + } else if (cio_read(4) == MJ2_URN) { + cio_skip(-8); + tk->num_urn++; + if (mj2_read_urn(tk, tk->num_urn)) + return 1; + } else { + fprintf(stderr, "Error with in DREF box. Expected URN or URL box\n"); + return 1; + } + + } + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with DREF Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the DINF box +* +* Data information box +* +*/ +void mj2_write_dinf(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_DINF, 4); /* DINF */ + + mj2_write_dref(tk); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the DINF box +* +* Data information box +* +*/ +int mj2_read_dinf(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_DINF != box.type) { + fprintf(stderr, "Error: Expected DINF Marker\n"); + return 1; + } + + if (mj2_read_dref(tk)) + return 1; + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with DINF Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the VMHD box +* +* Video Media information box +* +*/ +void mj2_write_vmhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_VMHD, 4); /* VMHD */ + + cio_write(1, 4); /* Version = 0, flags = 1 */ + + cio_write(tk->graphicsmode, 2); + cio_write(tk->opcolor[0], 2); + cio_write(tk->opcolor[1], 2); + cio_write(tk->opcolor[2], 2); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the VMHD box +* +* Video Media information box +* +*/ +int mj2_read_vmhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_VMHD != box.type) { + fprintf(stderr, "Error: Expected VMHD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in VMHD box\n"); + return 1; + } + + if (1 != cio_read(3)) { /* Flags = 1 */ + fprintf(stderr, "Error with flag in VMHD box. Expected flag 0\n"); + return 1; + } + + tk->track_type = 0; + tk->graphicsmode = cio_read(2); + tk->opcolor[0] = cio_read(2); + tk->opcolor[1] = cio_read(2); + tk->opcolor[2] = cio_read(2); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with VMHD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the SMHD box +* +* Sound Media information box +* +*/ +void mj2_write_smhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_SMHD, 4); /* SMHD */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->balance << 8, 2); + + cio_write(0, 2); /* Reserved */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the SMHD box +* +* Sound Media information box +* +*/ +int mj2_read_smhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_SMHD != box.type) { + fprintf(stderr, "Error: Expected SMHD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in VMHD box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in VMHD box. Expected flag 0\n"); + return 1; + } + + tk->track_type = 1; + tk->balance = cio_read(2) >> 8; + + cio_skip(2); /* Reserved */ + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with SMHD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the HMHD box +* +* Hint Media information box +* +*/ +void mj2_write_hmhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_HMHD, 4); /* HMHD */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->maxPDUsize, 2); + cio_write(tk->avgPDUsize, 2); + cio_write(tk->maxbitrate, 4); + cio_write(tk->avgbitrate, 4); + cio_write(tk->slidingavgbitrate, 4); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the HMHD box +* +* Hint Media information box +* +*/ +int mj2_read_hmhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_HMHD != box.type) { + fprintf(stderr, "Error: Expected HMHD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in VMHD box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in VMHD box. Expected flag 0\n"); + return 1; + } + + tk->track_type = 2; + tk->maxPDUsize = cio_read(2); + tk->avgPDUsize = cio_read(2); + tk->maxbitrate = cio_read(4); + tk->avgbitrate = cio_read(4); + tk->slidingavgbitrate = cio_read(4); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with HMHD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the MINF box +* +* Media information box +* +*/ +void mj2_write_minf(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MINF, 4); /* MINF */ + + if (tk->track_type == 0) { + mj2_write_vmhd(tk); + } else if (tk->track_type == 1) { + mj2_write_smhd(tk); + } else if (tk->track_type == 2) { + mj2_write_hmhd(tk); + } + + mj2_write_dinf(tk); + mj2_write_stbl(tk, img); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the MINF box +* +* Media information box +* +*/ +int mj2_read_minf(mj2_tk_t * tk, j2k_image_t * img) +{ + + unsigned int box_type; + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_MINF != box.type) { + fprintf(stderr, "Error: Expected MINF Marker\n"); + return 1; + } + + cio_skip(4); + box_type = cio_read(4); + cio_skip(-8); + + if (box_type == MJ2_VMHD) { + if (mj2_read_vmhd(tk)) + return 1; + } else if (box_type == MJ2_SMHD) { + if (mj2_read_smhd(tk)) + return 1; + } else if (box_type == MJ2_VMHD) { + if (mj2_read_hmhd(tk)) + return 1; + } else { + fprintf(stderr, "Error in MINF box expected vmhd, smhd or hmhd\n"); + return 1; + } + + if (mj2_read_dinf(tk)) + return 1; + + if (mj2_read_stbl(tk, img)) + return 1; + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with MINF Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the HDLR box +* +* Handler reference box +* +*/ +void mj2_write_hdlr(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_HDLR, 4); /* HDLR */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(0, 4); /* Predefine */ + + tk->name = 0; /* The track name is immediately determined by the track type */ + + if (tk->track_type == 0) { + tk->handler_type = 0x76696465; /* Handler type: vide */ + cio_write(tk->handler_type, 4); + + cio_write(0, 4); + cio_write(0, 4); + cio_write(0, 4); /* Reserved */ + + cio_write(0x76696465, 4); + cio_write(0x6F206d65, 4); + cio_write(0x64696120, 4); + cio_write(0x74726163, 4); + cio_write(0x6b00, 2); /* String: video media track */ + } else if (tk->track_type == 1) { + tk->handler_type = 0x736F756E; /* Handler type: soun */ + cio_write(tk->handler_type, 4); + + cio_write(0, 4); + cio_write(0, 4); + cio_write(0, 4); /* Reserved */ + + cio_write(0x536F756E, 4); + cio_write(0x6400, 2); /* String: Sound */ + } else if (tk->track_type == 2) { + tk->handler_type = 0x68696E74; /* Handler type: hint */ + cio_write(tk->handler_type, 4); + + cio_write(0, 4); + cio_write(0, 4); + cio_write(0, 4); /* Reserved */ + + cio_write(0x48696E74, 4); + cio_write(0, 2); /* String: Hint */ + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the HDLR box +* +* Handler reference box +* +*/ +int mj2_read_hdlr(mj2_tk_t * tk) +{ + int i; + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_HDLR != box.type) { + fprintf(stderr, "Error: Expected HDLR Marker\n"); + return 1; + } + + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in VMHD box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in VMHD box. Expected flag 0\n"); + return 1; + } + + cio_skip(4); /* Reserved */ + + tk->handler_type = cio_read(4); + cio_skip(12); /* Reserved */ + + tk->name_size = box.length - 32; + + tk->name = (char *) malloc(tk->name_size * sizeof(char)); + for (i = 0; i < tk->name_size; i++) { + tk->name[i] = cio_read(1); /* Name */ + } + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with HDLR Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the MDHD box +* +* Media Header Box +* +*/ +void mj2_write_mdhd(mj2_tk_t * tk) +{ + mj2_box_t box; + unsigned int i; + time_t ltime; + unsigned int modification_time; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MDHD, 4); /* MDHD */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->creation_time, 4); /* Creation Time */ + + time(<ime); /* Time since 1/1/70 */ + modification_time = ltime + 2082844800; /* Seoonds between 1/1/04 and 1/1/70 */ + + cio_write(modification_time, 4); /* Modification Time */ + + cio_write(tk->timescale, 4); /* Timescale */ + + tk->duration = 0; + + for (i = 0; i < tk->num_samples; i++) + tk->duration += tk->sample[i].sample_delta; + + cio_write(tk->duration, 4); /* Duration */ + + cio_write(tk->language, 2); /* Language */ + + cio_write(0, 2); /* Predefined */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the MDHD box +* +* Media Header Box +* +*/ +int mj2_read_mdhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (!(MJ2_MHDR == box.type || MJ2_MDHD == box.type)) { // Kakadu writes MHDR instead of MDHD + fprintf(stderr, "Error: Expected MDHD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in MDHD box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in MDHD box. Expected flag 0\n"); + return 1; + } + + + tk->creation_time = cio_read(4); /* Creation Time */ + + tk->modification_time = cio_read(4); /* Modification Time */ + + tk->timescale = cio_read(4); /* Timescale */ + + tk->duration = cio_read(4); /* Duration */ + + tk->language = cio_read(2); /* Language */ + + cio_skip(2); /* Predefined */ + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with MDHD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the MDIA box +* +* Media box +* +*/ +void mj2_write_mdia(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MDIA, 4); /* MDIA */ + + mj2_write_mdhd(tk); + mj2_write_hdlr(tk); + mj2_write_minf(tk, img); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the MDIA box +* +* Media box +* +*/ +int mj2_read_mdia(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_MDIA != box.type) { + fprintf(stderr, "Error: Expected MDIA Marker\n"); + return 1; + } + + if (mj2_read_mdhd(tk)) + return 1; + if (mj2_read_hdlr(tk)) + return 1; + if (mj2_read_minf(tk, img)) + return 1; + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with MDIA Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the TKHD box +* +* Track Header box +* +*/ +void mj2_write_tkhd(mj2_tk_t * tk) +{ + mj2_box_t box; + unsigned int i; + time_t ltime; + + box.init_pos = cio_tell(); + cio_skip(4); + + cio_write(MJ2_TKHD, 4); /* TKHD */ + + cio_write(3, 4); /* Version=0, flags=3 */ + + time(<ime); /* Time since 1/1/70 */ + tk->modification_time = ltime + 2082844800; /* Seoonds between 1/1/04 and 1/1/70 */ + + cio_write(tk->creation_time, 4); /* Creation Time */ + + cio_write(tk->modification_time, 4); /* Modification Time */ + + cio_write(tk->track_ID, 4); /* Track ID */ + + cio_write(0, 4); /* Reserved */ + + tk->duration = 0; + + for (i = 0; i < tk->num_samples; i++) + tk->duration += tk->sample[i].sample_delta; + + cio_write(tk->duration, 4); /* Duration */ + + cio_write(0, 4); /* Reserved */ + cio_write(0, 4); /* Reserved */ + + cio_write(tk->layer, 2); /* Layer */ + + cio_write(0, 2); /* Predefined */ + + cio_write(tk->volume << 8, 2); /* Volume */ + + cio_write(0, 2); /* Reserved */ + + cio_write(tk->trans_matrix[0], 4); /* Transformation matrix for track */ + cio_write(tk->trans_matrix[1], 4); + cio_write(tk->trans_matrix[2], 4); + cio_write(tk->trans_matrix[3], 4); + cio_write(tk->trans_matrix[4], 4); + cio_write(tk->trans_matrix[5], 4); + cio_write(tk->trans_matrix[6], 4); + cio_write(tk->trans_matrix[7], 4); + cio_write(tk->trans_matrix[8], 4); + + cio_write(tk->w << 16, 4); /* Video Width */ + + cio_write(tk->h << 16, 4); /* Video Height */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the TKHD box +* +* Track Header box +* +*/ +int mj2_read_tkhd(mj2_tk_t * tk) +{ + int flag; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + + if (MJ2_TKHD != box.type) { + fprintf(stderr, "Error: Expected TKHD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in TKHD box\n"); + return 1; + } + + flag = cio_read(3); + + if (!(flag == 1 || flag == 2 || flag == 3 || flag == 4)) { /* Flags = 1,2,3 or 4 */ + fprintf(stderr, + "Error with flag in TKHD box: Expected flag 1,2,3 or 4\n"); + return 1; + } + + tk->creation_time = cio_read(4); /* Creation Time */ + + tk->modification_time = cio_read(4); /* Modification Time */ + + tk->track_ID = cio_read(4); /* Track ID */ + + cio_skip(4); /* Reserved */ + + tk->duration = cio_read(4); /* Duration */ + + cio_skip(8); /* Reserved */ + + tk->layer = cio_read(2); /* Layer */ + + cio_read(2); /* Predefined */ + + tk->volume = cio_read(2) >> 8; /* Volume */ + + cio_skip(2); /* Reserved */ + + tk->trans_matrix[0] = cio_read(4); /* Transformation matrix for track */ + tk->trans_matrix[1] = cio_read(4); + tk->trans_matrix[2] = cio_read(4); + tk->trans_matrix[3] = cio_read(4); + tk->trans_matrix[4] = cio_read(4); + tk->trans_matrix[5] = cio_read(4); + tk->trans_matrix[6] = cio_read(4); + tk->trans_matrix[7] = cio_read(4); + tk->trans_matrix[8] = cio_read(4); + + tk->w = cio_read(4) >> 16; /* Video Width */ + + tk->h = cio_read(4) >> 16; /* Video Height */ + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with TKHD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the TRAK box +* +* Track box +* +*/ +void mj2_write_trak(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + + cio_write(MJ2_TRAK, 4); /* TRAK */ + + mj2_write_tkhd(tk); + mj2_write_mdia(tk, img); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the TRAK box +* +* Track box +* +*/ +int mj2_read_trak(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_TRAK != box.type) { + fprintf(stderr, "Error: Expected TRAK Marker\n"); + return 1; + } + if (mj2_read_tkhd(tk)) + return 1; + if (mj2_read_mdia(tk, img)) + return 1; + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with TRAK Box\n"); + return 1; + } + return 0; +} + +/* +* Write the MVHD box +* +* Movie header Box +* +*/ +void mj2_write_mvhd(mj2_movie_t * movie) +{ + int i; + mj2_box_t box; + unsigned j; + time_t ltime; + int max_tk_num = 0; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MVHD, 4); /* MVHD */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + time(<ime); /* Time since 1/1/70 */ + movie->modification_time = ltime + 2082844800; /* Seoonds between 1/1/04 and 1/1/70 */ + + cio_write(movie->creation_time, 4); /* Creation Time */ + + cio_write(movie->modification_time, 4); /* Modification Time */ + + cio_write(movie->timescale, 4); /* Timescale */ + + movie->duration = 0; + + for (i = 0; i < (movie->num_stk + movie->num_htk + movie->num_vtk); i++) { + mj2_tk_t *tk = &movie->tk[i]; + + for (j = 0; j < tk->num_samples; j++) { + movie->duration += tk->sample[j].sample_delta; + } + } + + cio_write(movie->duration, 4); + + cio_write(movie->rate << 16, 4); /* Rate to play presentation */ + + cio_write(movie->volume << 8, 2); /* Volume */ + + cio_write(0, 2); /* Reserved */ + cio_write(0, 4); /* Reserved */ + cio_write(0, 4); /* Reserved */ + + cio_write(movie->trans_matrix[0], 4); /* Transformation matrix for video */ + cio_write(movie->trans_matrix[1], 4); + cio_write(movie->trans_matrix[2], 4); + cio_write(movie->trans_matrix[3], 4); + cio_write(movie->trans_matrix[4], 4); + cio_write(movie->trans_matrix[5], 4); + cio_write(movie->trans_matrix[6], 4); + cio_write(movie->trans_matrix[7], 4); + cio_write(movie->trans_matrix[8], 4); + + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + + + for (i = 0; i < movie->num_htk + movie->num_stk + movie->num_vtk; i++) { + if (max_tk_num < movie->tk[i].track_ID) + max_tk_num = movie->tk[i].track_ID; + } + + movie->next_tk_id = max_tk_num + 1; + + cio_write(movie->next_tk_id, 4); /* ID of Next track to be added */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the MVHD box +* +* Movie header Box +* +*/ +int mj2_read_mvhd(mj2_movie_t * movie) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_MVHD != box.type) { + fprintf(stderr, "Error: Expected MVHD Marker\n"); + return 1; + } + + + if (0 != cio_read(4)) { /* Version = 0, flags = 0 */ + fprintf(stderr, "Error: Only Version 0 handled\n"); + } + + movie->creation_time = cio_read(4); /* Creation Time */ + + movie->modification_time = cio_read(4); /* Modification Time */ + + movie->timescale = cio_read(4); /* Timescale */ + + movie->duration = cio_read(4); /* Duration */ + + movie->rate = cio_read(4) >> 16; /* Rate to play presentation */ + + movie->volume = cio_read(2) >> 8; /* Volume */ + + cio_skip(10); /* Reserved */ + + movie->trans_matrix[0] = cio_read(4); /* Transformation matrix for video */ + movie->trans_matrix[1] = cio_read(4); + movie->trans_matrix[2] = cio_read(4); + movie->trans_matrix[3] = cio_read(4); + movie->trans_matrix[4] = cio_read(4); + movie->trans_matrix[5] = cio_read(4); + movie->trans_matrix[6] = cio_read(4); + movie->trans_matrix[7] = cio_read(4); + movie->trans_matrix[8] = cio_read(4); + + cio_skip(24); /* Pre-defined */ + + movie->next_tk_id = cio_read(4); /* ID of Next track to be added */ + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with MVHD Box Size\n"); + return 1; + } + return 0; +} + + +/* +* Write the MOOV box +* +* Movie Box +* +*/ +void mj2_write_moov(mj2_movie_t * movie, j2k_image_t * img) +{ + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MOOV, 4); /* MOOV */ + + mj2_write_mvhd(movie); + + for (i = 0; i < (movie->num_stk + movie->num_htk + movie->num_vtk); i++) { + mj2_write_trak(&movie->tk[i], img); + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); + +} + +/* +* Read the MOOV box +* +* Movie Box +* +*/ +int mj2_read_moov(mj2_movie_t * movie, j2k_image_t * img) +{ + unsigned int i; + mj2_box_t box; + mj2_box_t box2; + + mj2_read_boxhdr(&box); + if (MJ2_MOOV != box.type) { + fprintf(stderr, "Error: Expected MOOV Marker\n"); + return 1; + } + + + + if (mj2_read_mvhd(movie)) + return 1; + + + movie->tk = + (mj2_tk_t *) malloc((movie->next_tk_id - 1) * sizeof(mj2_tk_t)); + + for (i = 0; cio_tell() - box.init_pos < box.length; i++) { + mj2_read_boxhdr(&box2); + if (box2.type == MJ2_TRAK) { + cio_seek(box2.init_pos); + if (mj2_read_trak(&movie->tk[i], img)) + return 1; + + if (movie->tk[i].track_type == 0) { + movie->num_vtk++; + } else if (movie->tk[i].track_type == 1) { + movie->num_stk++; + } else if (movie->tk[i].track_type == 2) { + movie->num_htk++; + } + } else if (box2.type == MJ2_MVEX) { + cio_seek(box2.init_pos); + cio_skip(box2.length); + i--; + } else { + fprintf(stderr, "Error with MOOV Box: Expected TRAK or MVEX box\n"); + return 1; + } + } + return 0; +} + + +int mj2_encode(mj2_movie_t * movie, j2k_cp_t * cp, char *index) +{ + + char *outbuf; + FILE *outfile; + int len; + unsigned int i; + + j2k_image_t img; + + outbuf = (char *) malloc(cp->tdx * cp->tdy * 2); + cio_init(outbuf, cp->tdx * cp->tdy * 2); + + outfile = fopen(movie->mj2file, "wb"); + if (!outfile) { + fprintf(stderr, "failed to open %s for writing\n", movie->mj2file); + return 1; + } + + mj2_write_jp(); + mj2_write_ftyp(movie); + + if (mj2_write_mdat(outfile, movie, &img, cp, outbuf, index)) { + fprintf(stderr, "Error writing tracks\n\n"); + return 1; + } + + outbuf = (char *) malloc(cp->tdx * cp->tdy * 2); + cio_init(outbuf, cp->tdx * cp->tdy * 2); + + mj2_write_moov(movie, &img); + + len = cio_tell(); + fwrite(outbuf, 1, len, outfile); + + fclose(outfile); + + for (i = 0; i < movie->tk[0].jp2_struct.numcomps; i++) { + char tmp; + sprintf(&tmp, "Compo%d", i); + if (remove(&tmp) == -1) { + fprintf(stderr, "failed to kill %s file !\n", &tmp); + } + } + + free(img.comps); + free(outbuf); + + return 0; + +} + +int mj2_decode(unsigned char *src, int len, mj2_movie_t * movie, + j2k_cp_t * cp, char *outfile) +{ + unsigned int MDATbox_pos = 0; + unsigned int MOOVboxend_pos = 0; + mj2_box_t box; + j2k_image_t img; + + cio_init(src, len); + + if (mj2_read_jp()) + return 1; + if (mj2_read_ftyp(movie)) + return 1; + + + for (; cio_numbytesleft() > 0;) { + mj2_read_boxhdr(&box); + switch (box.type) { + case MJ2_MDAT: + cio_seek(box.init_pos); + if (MOOVboxend_pos == 0) { + MDATbox_pos = box.init_pos; + cio_skip(box.length); /* The MDAT box is only read while the MOOV box is decoded */ + } else { + if (mj2_read_mdat(movie, src, outfile)) + return 1; + } + break; + + case MJ2_MOOV: + cio_seek(box.init_pos); + if (mj2_read_moov(movie, &img)) + return 1; + MOOVboxend_pos = cio_tell(); + if (MDATbox_pos != 0) { + cio_seek(MDATbox_pos); /* After MOOV box, read the MDAT box */ + + if (mj2_read_mdat(movie, src, outfile)) + return 1; + + cio_seek(MOOVboxend_pos); + } + break; + + case MJ2_MOOF: + cio_seek(box.init_pos); + cio_skip(box.length); + break; + case MJ2_FREE: + cio_seek(box.init_pos); + cio_skip(box.length); + break; + case MJ2_SKIP: + cio_seek(box.init_pos); + cio_skip(box.length); + break; + default: + fprintf(stderr, "Unknown box\n"); + return 1; + } + } + + return 0; +} diff --git a/mj2/mj2_convert.c b/mj2/mj2_convert.c new file mode 100644 index 00000000..34f1b04f --- /dev/null +++ b/mj2/mj2_convert.c @@ -0,0 +1,260 @@ +/* +* Copyright (c) 2003-2004, François-Olivier Devaux +* Copyright (c) 2003-2004, 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 +#include +#include +#include +#ifndef WIN32 +#include +#endif +#include +#include "mj2.h" + +// -->> -->> -->> -->> + +// YUV IMAGE FORMAT + +//-- <<-- <<-- <<-- */ + + +/* ----------------------- */ +/* */ +/* */ +/* Count the number of frames */ +/* in a YUV file */ +/* */ +/* ----------------------- */ + +int yuv_num_frames(mj2_tk_t * tk) +{ + FILE *f; + int numimages, frame_size; + long end_of_f; + + f = fopen(tk->imagefile, "rb"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading !!\n", tk->imagefile); + return 0; + } + + frame_size = (int) (tk->w * tk->h * (1.0 + (double) 2 / (double) (tk->CbCr_subsampling_dx * tk->CbCr_subsampling_dy))); /* Calculate frame size */ + + fseek(f, 0, SEEK_END); + end_of_f = ftell(f); /* Calculate file size */ + + if (end_of_f < frame_size) { + fprintf(stderr, + "YUV does not contains any frame of %d x %d size\n", tk->w, + tk->h); + return 0; + } + + numimages = end_of_f / frame_size; /* Calculate number of images */ + + return numimages; + fclose(f); +} + +// ----------------------- +// +// +// YUV to IMAGE +// +// ----------------------- + +int yuvtoimage(mj2_tk_t * tk, j2k_image_t * img, int frame_num) +{ + FILE *f; + int i, j; + int offset; + long end_of_f, position; + FILE *Compo; + + + + f = fopen(tk->imagefile, "rb"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading !!\n", tk->imagefile); + return 0; + } + + offset = + (int) ((double) (frame_num * tk->w * tk->h) * + (1.0 + + 1.0 * (double) 2 / (double) (tk->CbCr_subsampling_dx * + tk->CbCr_subsampling_dy))); + fseek(f, 0, SEEK_END); + end_of_f = ftell(f); + fseek(f, sizeof(unsigned char) * offset, SEEK_SET); + position = ftell(f); + if (position >= end_of_f) { + fprintf(stderr, "Cannot reach frame number %d in %s file !!\n", + frame_num, tk->imagefile); + return 0; + } + + img->x0 = tk->Dim[0]; + img->y0 = tk->Dim[1]; + img->x1 = + !tk->Dim[0] ? (tk->w - 1) * tk->subsampling_dx + 1 : tk->Dim[0] + + (tk->w - 1) * tk->subsampling_dx + 1; + img->y1 = + !tk->Dim[1] ? (tk->h - 1) * tk->subsampling_dy + 1 : tk->Dim[1] + + (tk->h - 1) * tk->subsampling_dy + 1; + img->numcomps = 3; + img->color_space = 3; + img->comps = (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t)); + + for (i = 0; i < img->numcomps; i++) { + img->comps[i].data = (int *) malloc(sizeof(int) * tk->w * tk->h); + img->comps[i].prec = 8; + img->comps[i].bpp = 8; + img->comps[i].sgnd = 0; + if (i == 0) { + img->comps[i].dx = tk->subsampling_dx; + img->comps[i].dy = tk->subsampling_dy; + } else { + img->comps[i].dx = tk->subsampling_dx * tk->CbCr_subsampling_dx; + img->comps[i].dy = tk->subsampling_dy * tk->CbCr_subsampling_dy; + } + } + + Compo = fopen("Compo0", "wb"); + if (!Compo) { + fprintf(stderr, "Failed to open Compo0 for writing !\n"); + } + + for (i = 0; i < (tk->w * tk->h / (img->comps[0].dx * img->comps[0].dy)) + && !feof(f); i++) { + unsigned char y; + j = fread(&y, 1, 1, f); + fwrite(&y, 1, 1, Compo); + } + + fclose(Compo); + + Compo = fopen("Compo1", "wb"); + if (!Compo) { + fprintf(stderr, "Failed to open Compo1 for writing !\n"); + } + + + for (i = 0; i < (tk->w * tk->h / (img->comps[1].dx * img->comps[1].dy)) + && !feof(f); i++) { + unsigned char cb; + j = fread(&cb, sizeof(unsigned char), 1, f); + fwrite(&cb, 1, 1, Compo); + } + + fclose(Compo); + + Compo = fopen("Compo2", "wb"); + if (!Compo) { + fprintf(stderr, "Failed to open Compo2 for writing !\n"); + } + + + for (i = 0; i < (tk->w * tk->h / (img->comps[2].dx * img->comps[2].dy)) + && !feof(f); i++) { + unsigned char cr; + j = fread(&cr, sizeof(unsigned char), 1, f); + fwrite(&cr, 1, 1, Compo); + } + + fclose(Compo); + + return 1; +} + + +// ----------------------- +// +// +// IMAGE to YUV +// +// ----------------------- + + +int imagetoyuv(j2k_image_t * img, j2k_cp_t * cp, char *outfile) +{ + FILE *f; + int i; + + if (img->numcomps != 3 || img->comps[0].dx != img->comps[1].dx / 2 + || img->comps[1].dx != img->comps[2].dx) { + fprintf(stderr, "Error with image components sizes\n"); + return 1; + } + + f = fopen(outfile, "a+b"); + if (!f) { + fprintf(stderr, "failed to open %s for writing\n", outfile); + return 1; + } + + + for (i = 0; i < (img->comps[0].w * img->comps[0].h); i++) { + unsigned char y; + y = img->comps[0].data[i]; + fwrite(&y, 1, 1, f); + } + + + if (img->numcomps > 2) { + for (i = 0; i < (img->comps[1].w * img->comps[1].h); i++) { + unsigned char cb; + cb = img->comps[1].data[i]; + fwrite(&cb, 1, 1, f); + } + + + for (i = 0; i < (img->comps[2].w * img->comps[2].h); i++) { + unsigned char cr; + cr = img->comps[2].data[i]; + fwrite(&cr, 1, 1, f); + } + } else if (img->numcomps == 1) { + for (i = 0; i < (img->comps[0].w * img->comps[0].h * 0.25); i++) { + unsigned char cb = 0; + fwrite(&cb, 1, 1, f); + } + + + for (i = 0; i < (img->comps[0].w * img->comps[0].h * 0.25); i++) { + unsigned char cr = 0; + fwrite(&cr, 1, 1, f); + } + } + + + + fclose(f); + return 0; + + +} diff --git a/mj2/mj2_convert.h b/mj2/mj2_convert.h new file mode 100644 index 00000000..f9d64869 --- /dev/null +++ b/mj2/mj2_convert.h @@ -0,0 +1,39 @@ +/* +* Copyright (c) 2003-2004, François-Olivier Devaux +* Copyright (c) 2003-2004, 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 "mj2.h" + +#ifndef __MJ2_CONVERT_H +#define __MJ2_CONVERT_H + +int yuv_num_frames(mj2_tk_t * tk); + +int yuvtoimage(mj2_tk_t * tk, j2k_image_t * img, int frame_num); + +int imagetoyuv(j2k_image_t * img, j2k_cp_t * cp, char *outfile); + +#endif diff --git a/mj2/mj2_to_frames.c b/mj2/mj2_to_frames.c new file mode 100644 index 00000000..f5b222af --- /dev/null +++ b/mj2/mj2_to_frames.c @@ -0,0 +1,138 @@ +/* Copyright (c) 2003-2004, François-Olivier Devaux +* Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium +* All rights reserved. +* +* 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 +#include +#include +#include +#include "mj2.h" +#include "mj2_convert.h" + +int ceildiv(int a, int b) +{ + return (a + b - 1) / b; +} + +int main(int argc, char **argv) +{ + FILE *f; + char *src, *src_name; + char *dest, S1, S2, S3; + int len; + j2k_cp_t cp; + mj2_movie_t mj2_movie; + + + if (argc < 3) { + fprintf(stderr, + "usage: %s j2k-file image-file -reduce n (<- optional)\n", + argv[0]); + return 1; + } + + f = fopen(argv[1], "rb"); + if (!f) { + fprintf(stderr, "failed to open %s for reading\n", argv[1]); + return 1; + } + + dest = argv[2]; + + cp.reduce_on = 0; + cp.reduce_value = 0; + + /* OPTION REDUCE IS ACTIVE */ + if (argc == 5) { + if (strcmp(argv[3], "-reduce")) { + fprintf(stderr, + "usage: options " "-reduce n" + " where n is the factor of reduction [%s]\n", argv[3]); + return 1; + } + cp.reduce_on = 1; + sscanf(argv[4], "%d", &cp.reduce_value); + } + + while (*dest) { + dest++; + } + dest--; + S3 = *dest; + dest--; + S2 = *dest; + dest--; + S1 = *dest; + + if (!((S1 == 'y' && S2 == 'u' && S3 == 'v') + || (S1 == 'Y' && S2 == 'U' && S3 == 'V'))) { + fprintf(stderr, + "!! Unrecognized format for infile : %c%c%c [accept only *.yuv] !!\n\n", + S1, S2, S3); + return 1; + } + + fseek(f, 0, SEEK_END); + len = ftell(f); + fseek(f, 0, SEEK_SET); + src = (char *) malloc(len); + fread(src, 1, len, f); + fclose(f); + + src_name = argv[1]; + while (*src_name) { + src_name++; + } + src_name--; + S3 = *src_name; + src_name--; + S2 = *src_name; + src_name--; + S1 = *src_name; + + /* MJ2 format */ + if ((S1 == 'm' && S2 == 'j' && S3 == '2') + || (S1 == 'M' && S2 == 'J' && S3 == '2')) { + mj2_movie.num_stk = 0; + mj2_movie.num_htk = 0; + mj2_movie.num_vtk = 0; + mj2_movie.mj2file = argv[1]; + if (mj2_decode(src, len, &mj2_movie, &cp, argv[2])) { + fprintf(stderr, "mj2_to_frames: failed to decode image!\n"); + return 1; + } + mj2_memory_free(&mj2_movie); + } else { + fprintf(stderr, + "mj2_to_frames : Unknown format image *.%c%c%c [only *.mj2]!! \n", + S1, S2, S3); + return 1; + } + + free(src); + + return 0; +} diff --git a/mj2/mj2_to_frames.dsp b/mj2/mj2_to_frames.dsp new file mode 100644 index 00000000..eb26052a --- /dev/null +++ b/mj2/mj2_to_frames.dsp @@ -0,0 +1,257 @@ +# Microsoft Developer Studio Project File - Name="mj2_to_frames" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=mj2_to_frames - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "mj2_to_frames.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "mj2_to_frames.mak" CFG="mj2_to_frames - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "mj2_to_frames - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "mj2_to_frames - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "mj2_to_frames - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /YX /FD /c +# ADD BASE RSC /l 0x80c /d "NDEBUG" +# ADD RSC /l 0x80c /i "../libopenjpeg" /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 + +!ELSEIF "$(CFG)" == "mj2_to_frames - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "_DEBUG" /D "DONT_HAVE_GETOPT" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c +# ADD BASE RSC /l 0x80c /d "_DEBUG" +# ADD RSC /l 0x80c /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "mj2_to_frames - Win32 Release" +# Name "mj2_to_frames - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=..\libopenjpeg\bio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\cio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\dwt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\fix.c +# End Source File +# Begin Source File + +SOURCE=.\compat\getopt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jpt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mct.c +# End Source File +# Begin Source File + +SOURCE=.\mj2.c +# End Source File +# Begin Source File + +SOURCE=.\mj2_convert.c +# End Source File +# Begin Source File + +SOURCE=.\mj2_to_frames.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mqc.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\pi.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\raw.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t1.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tcd.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tgt.c +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=..\libopenjpeg\bio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\cio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\dwt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\fix.h +# End Source File +# Begin Source File + +SOURCE=.\compat\getopt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jpt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mct.h +# End Source File +# Begin Source File + +SOURCE=.\mj2.h +# End Source File +# Begin Source File + +SOURCE=.\mj2_convert.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mqc.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\openjpeg.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\pi.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\raw.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t1.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t2.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tcd.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tgt.h +# End Source File +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# End Group +# End Target +# End Project