int main(int argc, char **argv)
{
int len;
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 */
j2k_image_t img;
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;
char *outbuf, *out;
FILE *f;
/* 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 = "Created by OpenJPEG version 0.9";
cp.disto_alloc = 0;
cp.fixed_alloc = 0;
cp.fixed_quality = 0; //add fixed_quality
/* img.PPT=0; */
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;
jpwl_cp_init(&jpwl_cp);
cp.intermed_file=0;
use_index=0;
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 == 'p' && S2 == 'g' && S3 == 'x')
|| (S1 == 'P' && S2 == 'G' && S3 == 'X')) {
cp.image_type = 0;
break;
}
if ((S1 == 'p' && S2 == 'n' && S3 == 'm')
|| (S1 == 'P' && S2 == 'N' && S3 == 'M')
|| (S1 == 'p' && S2 == 'g' && S3 == 'm') || (S1 == 'P'
&& S2 == 'G'
&& S3 == 'M')
|| (S1 == 'P' && S2 == 'P' && S3 == 'M') || (S1 == 'p'
&& S2 == 'p'
&& S3 == 'm')) {
cp.image_type = 1;
break;
}
if ((S1 == 'b' && S2 == 'm' && S3 == 'p')
|| (S1 == 'B' && S2 == 'M' && S3 == 'P')) {
cp.image_type = 2;
break;
}
fprintf(stderr,
"!! Unrecognized format for infile : %c%c%c [accept only *.pnm, *.pgm, *.ppm, *.pgx or *.bmp] !!\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 == 'j' && S2 == '2' && S3 == 'k') || (S1 == 'J' && S2 == '2' && S3 == 'K'))
cp.JPEG2000_format=0;
else if ((S1 == 'j' && S2 == 'p' && S3 == '2') || (S1 == 'J' && S2 == 'P' && S3 == '2'))
cp.JPEG2000_format=1;
else {
fprintf(stderr,"Unknown output format image *.%c%c%c [only *.j2k, *.jp2]!! \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;
use_index = 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': /* version 0.2 enables only EPC on main header and epb in fixed way*/
jpwl_cp.JPWL_on = 1;
break;
/* ------------------------------------------------------ */
case 'F': /* use intermed files*/
cp.intermed_file=1;
break;
/* ------------------------------------------------------ */
default:
return 1;
}
}
cp.tx0 = TX0;
cp.ty0 = TY0;
// inserici i parametri jpwl
if(jpwl_cp.JPWL_on)
get_jpwl_cp(& cp);
/* Error messages */
/* -------------- */
if (!infile || !outfile) {
fprintf(stderr,
"usage: image_to_j2k -i image-file -o j2k/jp2-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);
}
}
switch (cp.image_type) {
case 0:
if (Tile_arg) {
if (!pgxtoimage
(infile, &img, cp.tdy, subsampling_dx, subsampling_dy, Dim,
cp)) {
fprintf(stderr, "not a pgx file\n");
return 1;
}
} else {
if (!pgxtoimage
(infile, &img, -1, subsampling_dx, subsampling_dy, Dim, cp)) {
fprintf(stderr, " not a pgx file\n");
return 1;
}
}
break;
case 1:
if (!pnmtoimage(infile, &img, subsampling_dx, subsampling_dy, Dim)) {
fprintf(stderr, " not a pnm file\n");
return 1;
}
break;
case 2:
if (!bmptoimage(infile, &img, subsampling_dx, subsampling_dy, Dim)) {
fprintf(stderr, " not a bmp file\n");
return 1;
}
break;
}
/* to respect profile - 0 */
/* ---------------------- */
numD_min = 0;
/* while (int_ceildiv(img.x1,(1<<numD_min))-int_ceildiv(img.x0,(1<<numD_min))>120 || int_ceildiv(img.y1,(1<<numD_min))-int_ceildiv(img.y0,(1<<numD_min))>160) numD_min++;
if ((numD_min+1)>NumResolution)
{
fprintf(stderr,"\n********************************************************************************\n\n");
fprintf(stderr, "In view to respect Profile-0, the number of resolution used is %d in place of %d\n\n",numD_min+1,NumResolution);
fprintf(stderr, "********************************************************************************\n\n");
NumResolution=numD_min+1;
} */
if (Tile_arg == 1) {
cp.tw = int_ceildiv(img.x1 - cp.tx0, cp.tdx);
cp.th = int_ceildiv(img.y1 - cp.ty0, cp.tdy);
} else {
cp.tdx = img.x1 - cp.tx0;
cp.tdy = img.y1 - cp.ty0;
}
/* Initialization for PPM marker */
cp.ppm = 0;
cp.ppm_data = NULL;
cp.ppm_previous = 0;
cp.ppm_store = 0;
/* 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 = img.numcomps == 3 ? 1 : 0;
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(img.numcomps * sizeof(j2k_tccp_t));
for (i = 0; i < img.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, img.comps[i].prec);
}
int main(int argc, char **argv)
{
mj2_cparameters_t mj2_parameters; /* MJ2 compression parameters */
opj_cparameters_t *j2k_parameters; /* J2K compression parameters */
opj_event_mgr_t event_mgr; /* event manager */
opj_cio_t *cio;
int value;
opj_mj2_t *movie;
opj_image_t *img;
int i, j;
char *s, S1, S2, S3;
unsigned char *buf;
int x1, y1, len;
long mdat_initpos, offset;
FILE *mj2file;
int sampleno;
opj_cinfo_t* cinfo;
opj_bool bSuccess;
int numframes;
int prec = 8;/* DEFAULT */
double total_time = 0;
memset(&mj2_parameters, 0, sizeof(mj2_cparameters_t));
/* default value */
/* ------------- */
mj2_parameters.w = 352; /* CIF default value*/
mj2_parameters.h = 288; /* CIF default value*/
mj2_parameters.CbCr_subsampling_dx = 2; /* CIF default value*/
mj2_parameters.CbCr_subsampling_dy = 2; /* CIF default value*/
mj2_parameters.frame_rate = 25;
mj2_parameters.prec = 8; /* DEFAULT */
mj2_parameters.enumcs = ENUMCS_SYCC; /* FIXME: ENUMCS_YUV420 */
mj2_parameters.meth = 1; /* enumerated color space */
/*
configure the event callbacks (not required)
setting of each callback is optionnal
*/
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
event_mgr.error_handler = error_callback;
event_mgr.warning_handler = warning_callback;
event_mgr.info_handler = NULL;
/* set J2K encoding parameters to default values */
opj_set_default_encoder_parameters(&mj2_parameters.j2k_parameters);
j2k_parameters = &mj2_parameters.j2k_parameters;
/* Create comment for codestream */
if(j2k_parameters->cp_comment == NULL) {
const char comment[] = "Created by OpenJPEG version ";
const size_t clen = strlen(comment);
const char *version = opj_version();
j2k_parameters->cp_comment = (char*)malloc(clen+strlen(version)+1);
sprintf(j2k_parameters->cp_comment,"%s%s", comment, version);
}
while (1) {
int c = opj_getopt(argc, argv,
"i:o:r:q:f:t:n:c:b:p:s:d:P:S:E:M:R:T:C:I:W:F:D:h");
if (c == -1)
break;
switch (c) {
case 'i': /* IN fill */
{
char *infile = opj_optarg;
s = opj_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')) {
mj2_parameters.decod_format = YUV_DFMT;
}
else {
fprintf(stderr,
"!! Unrecognized format for infile : %c%c%c [accept only *.yuv] !!\n\n",
S1, S2, S3);
return 1;
}
strncpy(mj2_parameters.infile, infile, sizeof(mj2_parameters.infile)-1);
}
break;
/* ----------------------------------------------------- */
case 'o': /* OUT fill */
{
char *outfile = opj_optarg;
while (*outfile) {
outfile++;
}
outfile--;
S3 = *outfile;
outfile--;
S2 = *outfile;
outfile--;
S1 = *outfile;
outfile = opj_optarg;
if ((S1 == 'm' && S2 == 'j' && S3 == '2')
|| (S1 == 'M' && S2 == 'J' && S3 == '2'))
mj2_parameters.cod_format = MJ2_CFMT;
else {
fprintf(stderr,
"Unknown output format image *.%c%c%c [only *.mj2]!! \n",
S1, S2, S3);
return 1;
}
strncpy(mj2_parameters.outfile, outfile, sizeof(mj2_parameters.outfile)-1);
}
break;
/* ----------------------------------------------------- */
case 'r': /* rates rates/distorsion */
{
float rate;
s = opj_optarg;
while (sscanf(s, "%f", &rate) == 1) {
j2k_parameters->tcp_rates[j2k_parameters->tcp_numlayers] = rate * 2;
j2k_parameters->tcp_numlayers++;
while (*s && *s != ',') {
s++;
}
if (!*s)
break;
s++;
}
j2k_parameters->cp_disto_alloc = 1;
}
break;
/* ----------------------------------------------------- */
case 'q': /* add fixed_quality */
s = opj_optarg;
while (sscanf(s, "%f", &j2k_parameters->tcp_distoratio[j2k_parameters->tcp_numlayers]) == 1) {
j2k_parameters->tcp_numlayers++;
while (*s && *s != ',') {
s++;
}
if (!*s)
break;
s++;
}
j2k_parameters->cp_fixed_quality = 1;
break;
/* dda */
/* ----------------------------------------------------- */
case 'f': /* mod fixed_quality (before : -q) */
{
int *row = NULL, *col = NULL;
int numlayers = 0, numresolution = 0, matrix_width = 0;
s = opj_optarg;
sscanf(s, "%d", &numlayers);
s++;
if (numlayers > 9)
s++;
j2k_parameters->tcp_numlayers = numlayers;
numresolution = j2k_parameters->numresolution;
matrix_width = numresolution * 3;
j2k_parameters->cp_matrice = (int *) malloc(numlayers * matrix_width * sizeof(int));
s = s + 2;
for (i = 0; i < numlayers; i++) {
row = &j2k_parameters->cp_matrice[i * matrix_width];
col = row;
j2k_parameters->tcp_rates[i] = 1;
sscanf(s, "%d,", &col[0]);
s += 2;
if (col[0] > 9)
s++;
col[1] = 0;
col[2] = 0;
for (j = 1; j < numresolution; j++) {
col += 3;
sscanf(s, "%d,%d,%d", &col[0], &col[1], &col[2]);
s += 6;
if (col[0] > 9)
s++;
if (col[1] > 9)
s++;
if (col[2] > 9)
s++;
}
if (i < numlayers - 1)
s++;
}
j2k_parameters->cp_fixed_alloc = 1;
}
break;
/* ----------------------------------------------------- */
case 't': /* tiles */
sscanf(opj_optarg, "%d,%d", &j2k_parameters->cp_tdx, &j2k_parameters->cp_tdy);
j2k_parameters->tile_size_on = OPJ_TRUE;
break;
/* ----------------------------------------------------- */
case 'n': /* resolution */
sscanf(opj_optarg, "%d", &j2k_parameters->numresolution);
break;
/* ----------------------------------------------------- */
case 'c': /* precinct dimension */
{
char sep;
int res_spec = 0;
char *s = opj_optarg;
do {
sep = 0;
sscanf(s, "[%d,%d]%c", &j2k_parameters->prcw_init[res_spec],
&j2k_parameters->prch_init[res_spec], &sep);
j2k_parameters->csty |= 0x01;
res_spec++;
s = strpbrk(s, "]") + 2;
}
while (sep == ',');
j2k_parameters->res_spec = res_spec;
}
break;
/* ----------------------------------------------------- */
case 'b': /* code-block dimension */
{
int cblockw_init = 0, cblockh_init = 0;
sscanf(opj_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;
}
j2k_parameters->cblockw_init = cblockw_init;
j2k_parameters->cblockh_init = cblockh_init;
}
break;
/* ----------------------------------------------------- */
case 'p': /* progression order */
{
char progression[5];
strncpy(progression, opj_optarg, 5);
j2k_parameters->prog_order = give_progression(progression);
if (j2k_parameters->prog_order == -1) {
fprintf(stderr, "Unrecognized progression order "
"[LRCP, RLCP, RPCL, PCRL, CPRL] !!\n");
return 1;
}
}
break;
/* ----------------------------------------------------- */
case 's': /* subsampling factor */
{
if (sscanf(opj_optarg, "%d,%d", &j2k_parameters->subsampling_dx,
&j2k_parameters->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(opj_optarg, "%d,%d", &j2k_parameters->image_offset_x0,
&j2k_parameters->image_offset_y0) != 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 */
{
int numpocs = 0; /* number of progression order change (POC) default 0 */
opj_poc_t *POC = NULL; /* POC : used in case of Progression order change */
char *s = opj_optarg;
POC = j2k_parameters->POC;
while (sscanf(s, "T%d=%d,%d,%d,%d,%d,%4s", &POC[numpocs].tile,
&POC[numpocs].resno0, &POC[numpocs].compno0,
&POC[numpocs].layno1, &POC[numpocs].resno1,
&POC[numpocs].compno1, POC[numpocs].progorder) == 7) {
POC[numpocs].prg1 = give_progression(POC[numpocs].progorder);
numpocs++;
while (*s && *s != '/') {
s++;
}
if (!*s) {
break;
}
s++;
}
j2k_parameters->numpocs = numpocs;
}
break;
/* ------------------------------------------------------ */
case 'S': /* SOP marker */
j2k_parameters->csty |= 0x02;
break;
/* ------------------------------------------------------ */
case 'E': /* EPH marker */
j2k_parameters->csty |= 0x04;
break;
/* ------------------------------------------------------ */
case 'M': /* Mode switch pas tous au point !! */
if (sscanf(opj_optarg, "%d", &value) == 1) {
for (i = 0; i <= 5; i++) {
int cache = value & (1 << i);
if (cache)
j2k_parameters->mode |= (1 << i);
}
}
break;
/* ------------------------------------------------------ */
case 'R': /* ROI */
{
if (sscanf(opj_optarg, "OI:c=%d,U=%d", &j2k_parameters->roi_compno,
&j2k_parameters->roi_shift) != 2) {
fprintf(stderr, "ROI error !! [-ROI:c='compno',U='shift']\n");
return 1;
}
}
break;
/* ------------------------------------------------------ */
case 'T': /* Tile offset */
{
if (sscanf(opj_optarg, "%d,%d", &j2k_parameters->cp_tx0, &j2k_parameters->cp_ty0) != 2) {
fprintf(stderr, "-T 'tile offset' argument error !! [-T X0,Y0]");
return 1;
}
}
break;
/* ------------------------------------------------------ */
case 'C': /* Add a comment */
{
j2k_parameters->cp_comment = (char*)malloc(strlen(opj_optarg) + 1);
if(j2k_parameters->cp_comment) {
strcpy(j2k_parameters->cp_comment, opj_optarg);
}
}
break;
/* ------------------------------------------------------ */
case 'I': /* reversible or not */
{
j2k_parameters->irreversible = 1;
}
break;
/* ------------------------------------------------------ */
case 'W': /* Width and Height and Cb and Cr subsampling in case of YUV format files */
if (sscanf
(opj_optarg, "%d,%d,%d,%d", &mj2_parameters.w, &mj2_parameters.h, &mj2_parameters.CbCr_subsampling_dx,
&mj2_parameters.CbCr_subsampling_dy) != 4) {
fprintf(stderr, "-W argument error");
return 1;
}
break;
/* ------------------------------------------------------ */
case 'F': /* Video frame rate */
if (sscanf(opj_optarg, "%d", &mj2_parameters.frame_rate) != 1) {
fprintf(stderr, "-F argument error");
return 1;
}
break;
/* ------------------------------------------------------ */
case 'D': /* Depth: the precision */
if(sscanf(opj_optarg, "%d", &prec) != 1) prec = 0;
break;
default:
return 1;
}
}
/* Error messages */
/* -------------- */
if (!mj2_parameters.cod_format || !mj2_parameters.decod_format) {
fprintf(stderr,
"Usage: %s -i yuv-file -o mj2-file (+ options)\n",argv[0]);
return 1;
}
if(prec < 1 || prec > 16)
{
fprintf(stderr, "Error: Depth %d must be in the range 8 .. 16\n",prec);
return 1;
}
if ((j2k_parameters->cp_disto_alloc || j2k_parameters->cp_fixed_alloc || j2k_parameters->cp_fixed_quality)
&& (!(j2k_parameters->cp_disto_alloc ^ j2k_parameters->cp_fixed_alloc ^ j2k_parameters->cp_fixed_quality))) {
fprintf(stderr, "Error: options -r -q and -f cannot be used together !!\n");
return 1;
} /* mod fixed_quality */
/* if no rate entered, lossless by default */
if (j2k_parameters->tcp_numlayers == 0) {
j2k_parameters->tcp_rates[0] = 0; /* MOD antonin : losslessbug */
j2k_parameters->tcp_numlayers++;
j2k_parameters->cp_disto_alloc = 1;
}
if((j2k_parameters->cp_tx0 > j2k_parameters->image_offset_x0) || (j2k_parameters->cp_ty0 > j2k_parameters->image_offset_y0)) {
fprintf(stderr,
"Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n",
j2k_parameters->cp_tx0, j2k_parameters->image_offset_x0, j2k_parameters->cp_ty0, j2k_parameters->image_offset_y0);
return 1;
}
for (i = 0; i < j2k_parameters->numpocs; i++) {
if (j2k_parameters->POC[i].prg == -1) {
fprintf(stderr,
"Unrecognized progression order in option -P (POC n %d) [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n",
i + 1);
}
}
if (j2k_parameters->cp_tdx > mj2_parameters.Dim[0] || j2k_parameters->cp_tdy > mj2_parameters.Dim[1]) {
fprintf(stderr,
"Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n",
j2k_parameters->cp_tdx, mj2_parameters.Dim[0], j2k_parameters->cp_tdy, mj2_parameters.Dim[1]);
return 1;
}
/* to respect profile - 0 */
/* ---------------------- */
x1 = !mj2_parameters.Dim[0] ? (mj2_parameters.w - 1) * j2k_parameters->subsampling_dx
+ 1 : mj2_parameters.Dim[0] + (mj2_parameters.w - 1) * j2k_parameters->subsampling_dx + 1;
y1 = !mj2_parameters.Dim[1] ? (mj2_parameters.h - 1) * j2k_parameters->subsampling_dy
+ 1 : mj2_parameters.Dim[1] + (mj2_parameters.h - 1) * j2k_parameters->subsampling_dy + 1;
mj2_parameters.numcomps = 3; /* YUV files only have 3 components */
mj2_parameters.prec = prec;
j2k_parameters->tcp_mct = 0;
mj2file = fopen(mj2_parameters.outfile, "wb");
if (!mj2file) {
fprintf(stderr, "failed to open %s for writing\n", argv[2]);
return 1;
}
/* get a MJ2 decompressor handle */
cinfo = mj2_create_compress();
movie = (opj_mj2_t*)cinfo->mj2_handle;
/* catch events using our callbacks and give a local context */
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
/* setup encoder parameters */
mj2_setup_encoder(movie, &mj2_parameters);
movie->tk[0].num_samples =
yuv_num_frames(&movie->tk[0],mj2_parameters.infile);
if (movie->tk[0].num_samples == 0) {
return 1;
}
/* One sample per chunk*/
movie->tk[0].chunk = (mj2_chunk_t*)
malloc(movie->tk[0].num_samples * sizeof(mj2_chunk_t));
movie->tk[0].sample = (mj2_sample_t*)
malloc(movie->tk[0].num_samples * sizeof(mj2_sample_t));
if (mj2_init_stdmovie(movie)) {
fprintf(stderr, "Error with movie initialization");
return 1;
}
/* Writing JP, FTYP and MDAT boxes */
/* Assuming that the JP and FTYP boxes won't be longer than 300 bytes:*/
buf = (unsigned char*)
malloc (300 * sizeof(unsigned char));
cio = opj_cio_open((opj_common_ptr)movie->cinfo, buf, 300);
mj2_write_jp(cio);
mj2_write_ftyp(movie, cio);
mdat_initpos = cio_tell(cio);
cio_skip(cio, 4);
cio_write(cio, MJ2_MDAT, 4);
fwrite(buf,cio_tell(cio),1,mj2file);
offset = cio_tell(cio);
opj_cio_close(cio);
free(buf);
for(i = 0; i < movie->num_stk + movie->num_htk + movie->num_vtk; i++)
{
if(movie->tk[i].track_type != 0)
{
fprintf(stderr, "Unable to write sound or hint tracks\n");
}
else
{
mj2_tk_t *tk;
int buflen = 0;
tk = &movie->tk[i];
tk->num_chunks = tk->num_samples;
numframes = tk->num_samples;
tk->depth = prec;
fprintf(stderr, "Video Track number %d\n", i);
img = mj2_image_create(tk, j2k_parameters);
buflen = 2 * (tk->w * tk->h * 8);
buf = (unsigned char *) malloc(buflen*sizeof(unsigned char));
for(sampleno = 0; sampleno < numframes; sampleno++)
{
double init_time = opj_clock();
double elapsed_time;
if(yuvtoimage(tk, img, sampleno, j2k_parameters,
mj2_parameters.infile))
{
fprintf(stderr, "Error with frame number %d in YUV file\n", sampleno);
return 1;
}
/* setup the encoder parameters using the current image and user parameters */
opj_setup_encoder(cinfo, j2k_parameters, img);
cio = opj_cio_open((opj_common_ptr)movie->cinfo, buf, buflen);
cio_skip(cio, 4);
cio_write(cio, JP2_JP2C, 4); /* JP2C*/
/* encode the image */
bSuccess = opj_encode(cinfo, cio, img, NULL);
if (!bSuccess) {
opj_cio_close(cio);
fprintf(stderr, "failed to encode image\n");
return 1;
}
len = cio_tell(cio) - 8;
cio_seek(cio, 0);
cio_write(cio, len+8,4);
opj_cio_close(cio);
tk->sample[sampleno].sample_size = len+8;
tk->sample[sampleno].offset = offset;
tk->chunk[sampleno].offset = offset; /* There is one sample per chunk */
fwrite(buf, 1, len+8, mj2file);
offset += len+8;
elapsed_time = opj_clock()-init_time;
fprintf(stderr, "Frame number %d/%d encoded in %.2f mseconds\n",
sampleno + 1, numframes, elapsed_time*1000);
total_time += elapsed_time;
} /* for(sampleno */
free(buf);
opj_image_destroy(img);
}
}/* for(i */
fseek(mj2file, mdat_initpos, SEEK_SET);
buf = (unsigned char*) malloc(4*sizeof(unsigned char));
/* Init a cio to write box length variable in a little endian way */
cio = opj_cio_open(NULL, buf, 4);
cio_write(cio, offset - mdat_initpos, 4);
fwrite(buf, 4, 1, mj2file);
fseek(mj2file,0,SEEK_END);
free(buf);
/* Writing MOOV box */
buf = (unsigned char*)
malloc ((TEMP_BUF+numframes*20) * sizeof(unsigned char));
cio = opj_cio_open(movie->cinfo, buf, (TEMP_BUF+numframes*20));
mj2_write_moov(movie, cio);
fwrite(buf,cio_tell(cio),1,mj2file);
free(buf);
fprintf(stdout,"Total encoding time: %.2f s for %d frames (%.1f fps)\n",
total_time, numframes, (float)numframes/total_time);
/* Ending program */
fclose(mj2file);
/* free remaining compression structures */
mj2_destroy_compress(movie);
free(cinfo);
if(j2k_parameters->cp_comment) free(j2k_parameters->cp_comment);
if(j2k_parameters->cp_matrice) free(j2k_parameters->cp_matrice);
opj_cio_close(cio);
return 0;
}
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, l, j;
char *infile = 0;
char *outfile = 0;
char *index = 0;
char *s, S1, S2, S3;
char *buf;
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 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, len, jp2c_initpos, m, k, pos;
long mdat_initpos, offset;
FILE *mj2file, *yuvfile;
unsigned int sampleno;
j2k_image_t img;
/* 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.decod_format = YUV_DFMT;
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.cod_format = MJ2_CFMT;
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,
"Correct usage: mj2_encoder -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] = 0; //MOD antonin : losslessbug
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);
}
/**
* Command line parser. Takes command line parameters, parses them and encodes an
* opj_cparameters_t object with the specified compression parameters. Extracted, with
* minor modifications, from image_to_j2k.c. Uses most of the command line prefixes from
* image_to_j2k.c in OpenJPEG. Also defines additional command line parameters detailed
* below.
*
* @param argc Number of command line arguments.
* @param argv Command line arguments.
* @param parameters Compression parameters structure. Assumed to have been populated
* with default values by the time this function is called. This function will configure
* parameters based on the command line options specified.
* @param transform Reference to the transform to be performed on the raw data. This will
* be updated if a transform is specified on the command line using the parameter A.
* @param writeUncompressed Reference to boolean specifying if a lossless version of image
* should be written. This will be set to true if the LL parameter is present on the command
* line.
* @param startFrame First frame of data cube to read. Ignored for 2D images. Will only be
* modified if the x parameter is present. If only x is specified (and not y), the single x
* value will be interpreted as a single frame to read.
* @param endFrame Last frame of data cube to read. Ignored for 2D images. Will only be
* modified if the y parameter is present.
* @param benchmarkQualityParameters Reference to quality_benchmark_info structure specifying what,
* if any quality benchmark tests to be performed. Assumed to be initialised to 'no benchmarks'
* before this function is called. If the QB command line option is present, all benchmarks will
* be performed. This will override any other quality parameters. In the absence of this parameter,
* individual benchmarks may be turned on by specifying QB_FID for fidelity, QB_PSNR for peak signal
* to noise ratio, QB_MAD for maximum absolute distortion, QB_MSE for mean square error, QB_RMSE for
* root mean square error, QB_MAE for mean absolute error, QB_SE for squared error, QB_AE for absolute
* error and QB_SI for sum of uncompressed squared image intensities. QB_RES specifies if a residual
* image should be written.
* @param performCompressionBenchmarking Reference to boolean specifying if compression benchmarking
* should be performed on the images being compressed. This will be set to true if the CB parameter
* is present on the command line.
* @param firstStoke First stoke of data volume to read. Ignored for 2D or 3D images. Will only be
* modified if the S1 parameter is present. If only S1 is specified (and not S2), the single S1
* value will be interpreted as a single stoke to read.
* @param lastStoke Last stoke of data volume to read. Ignored for 2D or 3D images. Will only be
* modified if the S2 parameter is present.
* @param noiseDB Reference to a double specifying the PSNR of the image after (Gaussian noise) has been added.
* Will not be changed unless the -noise command line parameter is present.
* If the definition of noise is removed from f2j.h, this parameter will disappear.
* @param noiseSet Reference to a boolean specifying if the noiseDB parameter has been set by the user. Assumed
* to have been initialised to false. Will be set to true if the -noise command line parameter is present.
* If the definition of noise is removed from f2j.h, this parameter will disappear.
* @param seed Seed for the random number generator used to generate the noise specified by noiseDB. Will be
* ignored if the -noise command line parameter is not present. If -noise is present but no seed is specified
* the RNG will be seeded with the system clock time. Will be altered if the -seed command line parameter is
* present. If the definition of noise is removed from f2j.h, this parameter will disappear.
* @param seedSet Boolean specifying whether or not the -seed parameter is present.
* If the definition of noise is removed from f2j.h, this parameter will disappear.
* @param noisePct Reference to a double specifying the percentage (of the difference between the minimum
* and maximum raw FITS values) standard deviation of Gaussian noise (with mean 0.0) to be added to raw
* FITS values (before transforming them into pixel intensities). If the definition of noise is removed
* from f2j.h, this parameter will disappear. Will not be changed unless the -noise_pct command line
* parameter is present.
* @param writeNoiseField Boolean specifying whether or not the -noise_field parameter is present, which determines
* whether or not the noise field should be written to a file. Assumed to be initialised to false before this
* function is called and will not be changed if -noise_field and -noise are not present. If the definition of noise is
* removed from f2j.h, this parameter will disappear.
*
* @return 0 if parsing was successful, 1 otherwise.
*/
int parse_cmdline_encoder(int argc, char **argv, opj_cparameters_t *parameters, transform *transform, bool *writeUncompressed,
long *startFrame, long *endFrame, quality_benchmark_info *benchmarkQualityParameters, bool *performCompressionBenchmarking,
long *firstStoke, long *lastStoke
#ifdef noise
, double *noiseDB, bool *noiseSet, unsigned long *seed, bool *seedSet, double *noisePct, bool *writeNoiseField
#endif
) {
int i,j,totlen,c;
opj_option_t long_option[]={
{"ImgDir",REQ_ARG, NULL ,'z'},
{"TP",REQ_ARG, NULL ,'u'},
{"SOP",NO_ARG, NULL ,'S'},
{"EPH",NO_ARG, NULL ,'E'},
{"OutFor",REQ_ARG, NULL ,'O'},
{"POC",REQ_ARG, NULL ,'P'},
{"ROI",REQ_ARG, NULL ,'R'},
{"jpip",NO_ARG, NULL, 'J'},
{"S1",REQ_ARG, NULL ,'a'},
{"S2",REQ_ARG, NULL ,'e'},
{"QB",NO_ARG, NULL, 'K'},
{"QB_NI",NO_ARG, NULL, 'N'},
{"QB_FID",NO_ARG, NULL, 'B'},
{"QB_PSNR",NO_ARG, NULL, 'D'},
{"QB_MAD",NO_ARG, NULL, 'G'},
{"QB_MSE",NO_ARG, NULL, 'H'},
{"QB_RMSE",NO_ARG, NULL, 'L'},
{"QB_MAE",NO_ARG, NULL, 'U'},
{"QB_SE",NO_ARG, NULL, 'V'},
{"QB_AE",NO_ARG, NULL, 'Y'},
{"QB_SI",NO_ARG, NULL, 'X'},
{"QB_RES",NO_ARG, NULL, 'Z'},
{"suffix",REQ_ARG, NULL, 'O'},
{"CB",NO_ARG,NULL,'g'},
{"LL",NO_ARG, NULL,'l'}
#ifdef noise
,{"noise",REQ_ARG, NULL, '1'},
{"noise_pct",REQ_ARG, NULL, '2'},
{"seed",REQ_ARG, NULL, '3'},
{"noise_field",NO_ARG, NULL, '4'}
#endif
};
/* parse the command line */
const char optlist[] = "Z:B:D:G:H:L:U:V:Y:X:N:i:o:r:q:n:b:c:t:l:p:s:SEM:R:d:T:If:P:C:F:A:m:x:y:u:K:J:a:e"
#ifdef USE_JPWL
"W:"
#endif /* USE_JPWL */
#ifdef noise
"1:2:3:4:"
#endif
"h";
totlen=sizeof(long_option);
// Use JP2 if no output format is specified.
parameters->cod_format = CODEC_JP2;
do {
c = opj_getopt_long(argc, argv, optlist,long_option,totlen);
if (c == -1)
break;
switch (c) {
/* Not in OpenJPEG version - should a lossless version be written? */
case 'l':
{
*writeUncompressed = true;
}
break;
#ifdef noise
/* Gaussian noise standard deviation to add to image. */
case '1':
{
*noiseDB = atof(opj_optarg);
*noiseSet = true;
}
break;
/* Gaussian noise (percentage) to add to raw FITS values. */
case '2':
{
*noisePct = atof(opj_optarg);
}
break;
/* Random number seed to generate Gaussian noise to add to image. */
case '3':
{
*seed = strtoul(opj_optarg,NULL,10);
// Check conversion was successful.
if (errno != EINVAL) {
*seedSet = true;
}
}
break;
/* Should the noise field be written to a file? */
case '4':
{
*writeNoiseField = true;
}
break;
#endif
/* Suffix to be appended to the end of written filenames. */
case 'O':
{
char *suffix = opj_optarg;
// Copy string.
strcpy(parameters->outfile,suffix);
}
break;
/* Should all quality benchmark tests be performed? */
case 'K':
{
// Main benchmarks
benchmarkQualityParameters->fidelity = true;
benchmarkQualityParameters->maximumAbsoluteDistortion = true;
benchmarkQualityParameters->meanAbsoluteError = true;
benchmarkQualityParameters->meanSquaredError = true;
benchmarkQualityParameters->peakSignalToNoiseRatio = true;
benchmarkQualityParameters->rootMeanSquaredError = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
// Intermediate values
benchmarkQualityParameters->squaredError = true;
benchmarkQualityParameters->absoluteError = true;
benchmarkQualityParameters->squaredIntensitySum = true;
}
break;
/* Should all quality benchmark tests be performed - but no intermediate results shown?
* This is the same as the above case, but without the intermediate values printed.
*/
case 'N':
{
benchmarkQualityParameters->fidelity = true;
benchmarkQualityParameters->maximumAbsoluteDistortion = true;
benchmarkQualityParameters->meanAbsoluteError = true;
benchmarkQualityParameters->meanSquaredError = true;
benchmarkQualityParameters->peakSignalToNoiseRatio = true;
benchmarkQualityParameters->rootMeanSquaredError = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
}
break;
/* Fidelity benchmarking? */
case 'B':
{
benchmarkQualityParameters->fidelity = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
}
break;
/* PSNR benchmarking? */
case 'D':
{
benchmarkQualityParameters->peakSignalToNoiseRatio = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
}
break;
/* Maximum absolute distortion? */
case 'G':
{
benchmarkQualityParameters->maximumAbsoluteDistortion = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
}
break;
/* Mean squared error? */
case 'H':
{
benchmarkQualityParameters->meanSquaredError = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
}
break;
/* Root mean squared error? */
case 'L':
{
benchmarkQualityParameters->rootMeanSquaredError = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
}
break;
/* Mean absolute error? */
case 'U':
{
benchmarkQualityParameters->meanAbsoluteError = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
}
break;
/* Squared error? */
case 'V':
{
benchmarkQualityParameters->squaredError = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
}
break;
/* Absolute error? */
case 'Y':
{
benchmarkQualityParameters->absoluteError = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
}
break;
/* Squared uncompressed image intensity sum? */
case 'X':
{
benchmarkQualityParameters->squaredIntensitySum = true;
benchmarkQualityParameters->performQualityBenchmarking = true;
}
break;
/* Should a residual image be written? */
case 'Z':
{
benchmarkQualityParameters->writeResidual = true;
}
break;
/* Should compression benchmarking be performed? */
case 'g':
{
*performCompressionBenchmarking = true;
}
break;
/* What is the first stoke of the data volume to read? */
case 'a':
{
*firstStoke = strtol(opj_optarg,NULL,10);
}
break;
/*What is the last stoke of the data volume to read? */
case 'e':
{
*lastStoke = strtol(opj_optarg,NULL,10);
}
break;
/* What is the first frame of the data cube to read? */
case 'x':
{
*startFrame = strtol(opj_optarg,NULL,10);
}
break;
/* What is the last frame of the data cube to read? */
case 'y':
{
*endFrame = strtol(opj_optarg,NULL,10);
}
break;
/* What transform should be performed on the raw FITS data? */
case 'A':
{
// This should be synced with the possibilities in f2j.h.
char *transformString = opj_optarg;
if (strcasecmp(transformString,"LOG") == 0) {
*transform = LOG;
}
else if (strcasecmp(transformString,"NEGATIVE_LOG") == 0) {
*transform = NEGATIVE_LOG;
}
else if (strcasecmp(transformString,"LINEAR") == 0) {
*transform = LINEAR;
}
else if (strcasecmp(transformString,"NEGATIVE_LINEAR") == 0) {
*transform = NEGATIVE_LINEAR;
}
else if (strcasecmp(transformString,"RAW") == 0) {
*transform = RAW;
}
else if (strcasecmp(transformString,"NEGATIVE_RAW") == 0) {
*transform = NEGATIVE_RAW;
}
else if (strcasecmp(transformString,"SQRT") == 0) {
*transform = SQRT;
}
else if (strcasecmp(transformString,"NEGATIVE_SQRT") == 0) {
*transform = NEGATIVE_SQRT;
}
else if (strcasecmp(transformString,"SQUARED") == 0) {
*transform = SQUARED;
}
else if (strcasecmp(transformString,"NEGATIVE_SQUARED") == 0) {
*transform = NEGATIVE_SQUARED;
}
else if (strcasecmp(transformString,"POWER") == 0) {
*transform = POWER;
}
else if (strcasecmp(transformString,"NEGATIVE_POWER") == 0) {
*transform = NEGATIVE_POWER;
}
else {
fprintf(stderr,"Unknown transform specified: %s. Using default instead.\n",opj_optarg);
}
}
break;
/* Largely as in OpenJPEG below */
case 'i': /* input file */
{
char *infile = opj_optarg;
strncpy(parameters->infile, infile, sizeof(parameters->infile)-1);
}
break;
/* ----------------------------------------------------- */
case 'o': /* output format - either J2K or JP2 - differs from image_to_j2k.c */
{
char *outfile = opj_optarg;
if (strcasecmp(outfile,"JP2") == 0) {
parameters->cod_format = CODEC_JP2;
}
else if (strcasecmp(outfile,"J2K") == 0) {
parameters->cod_format = CODEC_J2K;
}
else {
// Use JP2 if format is not specified.
parameters->cod_format = CODEC_JP2;
}
}
break;
/* ----------------------------------------------------- */
case 'r': /* rates rates/distorsion */
{
char *s = opj_optarg;
parameters->tcp_numlayers = 0;
while (sscanf(s, "%f", ¶meters->tcp_rates[parameters->tcp_numlayers]) == 1) {
parameters->tcp_numlayers++;
while (*s && *s != ',') {
s++;
}
if (!*s)
break;
s++;
}
parameters->cp_disto_alloc = 1;
}
break;
/* ----------------------------------------------------- */
case 'q': /* add fixed_quality */
{
char *s = opj_optarg;
while (sscanf(s, "%f", ¶meters->tcp_distoratio[parameters->tcp_numlayers]) == 1) {
parameters->tcp_numlayers++;
while (*s && *s != ',') {
s++;
}
if (!*s)
break;
s++;
}
parameters->cp_fixed_quality = 1;
}
break;
/* dda */
/* ----------------------------------------------------- */
case 'f': /* mod fixed_quality (before : -q) */
{
int *row = NULL, *col = NULL;
int numlayers = 0, numresolution = 0, matrix_width = 0;
char *s = opj_optarg;
sscanf(s, "%d", &numlayers);
s++;
if (numlayers > 9)
s++;
parameters->tcp_numlayers = numlayers;
numresolution = parameters->numresolution;
matrix_width = numresolution * 3;
parameters->cp_matrice = (int *) malloc(numlayers * matrix_width * sizeof(int));
s = s + 2;
for (i = 0; i < numlayers; i++) {
row = ¶meters->cp_matrice[i * matrix_width];
col = row;
parameters->tcp_rates[i] = 1;
sscanf(s, "%d,", &col[0]);
s += 2;
if (col[0] > 9)
s++;
col[1] = 0;
col[2] = 0;
for (j = 1; j < numresolution; j++) {
col += 3;
sscanf(s, "%d,%d,%d", &col[0], &col[1], &col[2]);
s += 6;
if (col[0] > 9)
s++;
if (col[1] > 9)
s++;
if (col[2] > 9)
s++;
}
if (i < numlayers - 1)
s++;
}
parameters->cp_fixed_alloc = 1;
}
break;
/* ----------------------------------------------------- */
case 't': /* tiles */
{
sscanf(opj_optarg, "%d,%d", ¶meters->cp_tdx, ¶meters->cp_tdy);
parameters->tile_size_on = OPJ_TRUE;
}
break;
/* ----------------------------------------------------- */
case 'n': /* resolution */
{
sscanf(opj_optarg, "%d", ¶meters->numresolution);
}
break;
/* ----------------------------------------------------- */
case 'c': /* precinct dimension */
{
char sep;
int res_spec = 0;
char *s = opj_optarg;
do {
sep = 0;
sscanf(s, "[%d,%d]%c", ¶meters->prcw_init[res_spec],
¶meters->prch_init[res_spec], &sep);
parameters->csty |= 0x01;
res_spec++;
s = strpbrk(s, "]") + 2;
}
while (sep == ',');
parameters->res_spec = res_spec;
}
break;
/* ----------------------------------------------------- */
case 'b': /* code-block dimension */
{
int cblockw_init = 0, cblockh_init = 0;
sscanf(opj_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;
}
parameters->cblockw_init = cblockw_init;
parameters->cblockh_init = cblockh_init;
}
break;
/* ----------------------------------------------------- */
case 'p': /* progression order */
{
char progression[4];
strncpy(progression, opj_optarg, 4);
parameters->prog_order = give_progression(progression);
if (parameters->prog_order == -1) {
fprintf(stderr, "Unrecognized progression order "
"[LRCP, RLCP, RPCL, PCRL, CPRL] !!\n");
return 1;
}
}
break;
/* ----------------------------------------------------- */
case 's': /* subsampling factor */
{
if (sscanf(opj_optarg, "%d,%d", ¶meters->subsampling_dx,
¶meters->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(opj_optarg, "%d,%d", ¶meters->image_offset_x0,
¶meters->image_offset_y0) != 2) {
fprintf(stderr, "-d 'coordonnate of the reference grid' argument "
"error !! [-d x0,y0]\n");
return 1;
}
}
break;
/* ----------------------------------------------------- */
case 'h': /* display an help description */
displayHelp();
return 1;
/* ----------------------------------------------------- */
case 'P': /* POC */
{
int numpocs = 0; /* number of progression order change (POC) default 0 */
opj_poc_t *POC = NULL; /* POC : used in case of Progression order change */
char *s = opj_optarg;
POC = parameters->POC;
while (sscanf(s, "T%d=%d,%d,%d,%d,%d,%4s", &POC[numpocs].tile,
&POC[numpocs].resno0, &POC[numpocs].compno0,
&POC[numpocs].layno1, &POC[numpocs].resno1,
&POC[numpocs].compno1, POC[numpocs].progorder) == 7) {
POC[numpocs].prg1 = give_progression(POC[numpocs].progorder);
numpocs++;
while (*s && *s != '/') {
s++;
}
if (!*s) {
break;
}
s++;
}
parameters->numpocs = numpocs;
}
break;
/* ------------------------------------------------------ */
case 'S': /* SOP marker */
{
parameters->csty |= 0x02;
}
break;
/* ------------------------------------------------------ */
case 'E': /* EPH marker */
{
parameters->csty |= 0x04;
}
break;
/* ------------------------------------------------------ */
case 'M': /* Mode switch pas tous au point !! */
{
int value = 0;
if (sscanf(opj_optarg, "%d", &value) == 1) {
for (i = 0; i <= 5; i++) {
int cache = value & (1 << i);
if (cache)
parameters->mode |= (1 << i);
}
}
}
break;
/* ------------------------------------------------------ */
case 'R': /* ROI */
{
if (sscanf(opj_optarg, "c=%d,U=%d", ¶meters->roi_compno,
¶meters->roi_shift) != 2) {
fprintf(stderr, "ROI error !! [-ROI c='compno',U='shift']\n");
return 1;
}
}
break;
/* ------------------------------------------------------ */
case 'T': /* Tile offset */
{
if (sscanf(opj_optarg, "%d,%d", ¶meters->cp_tx0, ¶meters->cp_ty0) != 2) {
fprintf(stderr, "-T 'tile offset' argument error !! [-T X0,Y0]");
return 1;
}
}
break;
/* ------------------------------------------------------ */
case 'C': /* add a comment */
{
parameters->cp_comment = (char*)malloc(strlen(opj_optarg) + 1);
if(parameters->cp_comment) {
strcpy(parameters->cp_comment, opj_optarg);
}
}
break;
/* ------------------------------------------------------ */
case 'I': /* reversible or not */
{
parameters->irreversible = 1;
}
break;
/* ------------------------------------------------------ */
case 'u': /* Tile part generation*/
{
parameters->tp_flag = opj_optarg[0];
parameters->tp_on = 1;
}
break;
/* ------------------------------------------------------ */
// Removed Cinema 2K & 4K - not needed.
/* UniPG>> */
#ifdef USE_JPWL
/* ------------------------------------------------------ */
case 'W': /* JPWL capabilities switched on */
{
char *token = NULL;
int hprot, pprot, sens, addr, size, range;
/* we need to enable indexing */
if (!indexfilename || !*indexfilename) {
strncpy(indexfilename, JPWL_PRIVATEINDEX_NAME, OPJ_PATH_LEN);
}
/* search for different protection methods */
/* break the option in comma points and parse the result */
token = strtok(opj_optarg, ",");
while(token != NULL) {
/* search header error protection method */
if (*token == 'h') {
static int tile = 0, tilespec = 0, lasttileno = 0;
hprot = 1; /* predefined method */
if(sscanf(token, "h=%d", &hprot) == 1) {
/* Main header, specified */
if (!((hprot == 0) || (hprot == 1) || (hprot == 16) || (hprot == 32) ||
((hprot >= 37) && (hprot <= 128)))) {
fprintf(stderr, "ERROR -> invalid main header protection method h = %d\n", hprot);
return 1;
}
parameters->jpwl_hprot_MH = hprot;
} else if(sscanf(token, "h%d=%d", &tile, &hprot) == 2) {
/* Tile part header, specified */
if (!((hprot == 0) || (hprot == 1) || (hprot == 16) || (hprot == 32) ||
((hprot >= 37) && (hprot <= 128)))) {
fprintf(stderr, "ERROR -> invalid tile part header protection method h = %d\n", hprot);
return 1;
}
if (tile < 0) {
fprintf(stderr, "ERROR -> invalid tile part number on protection method t = %d\n", tile);
return 1;
}
if (tilespec < JPWL_MAX_NO_TILESPECS) {
parameters->jpwl_hprot_TPH_tileno[tilespec] = lasttileno = tile;
parameters->jpwl_hprot_TPH[tilespec++] = hprot;
}
} else if(sscanf(token, "h%d", &tile) == 1) {
/* Tile part header, unspecified */
if (tile < 0) {
fprintf(stderr, "ERROR -> invalid tile part number on protection method t = %d\n", tile);
return 1;
}
if (tilespec < JPWL_MAX_NO_TILESPECS) {
parameters->jpwl_hprot_TPH_tileno[tilespec] = lasttileno = tile;
parameters->jpwl_hprot_TPH[tilespec++] = hprot;
}
} else if (!strcmp(token, "h")) {
/* Main header, unspecified */
parameters->jpwl_hprot_MH = hprot;
} else {
fprintf(stderr, "ERROR -> invalid protection method selection = %s\n", token);
return 1;
};
}
/* search packet error protection method */
if (*token == 'p') {
static int pack = 0, tile = 0, packspec = 0;
pprot = 1; /* predefined method */
if (sscanf(token, "p=%d", &pprot) == 1) {
/* Method for all tiles and all packets */
if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
((pprot >= 37) && (pprot <= 128)))) {
fprintf(stderr, "ERROR -> invalid default packet protection method p = %d\n", pprot);
return 1;
}
parameters->jpwl_pprot_tileno[0] = 0;
parameters->jpwl_pprot_packno[0] = 0;
parameters->jpwl_pprot[0] = pprot;
} else if (sscanf(token, "p%d=%d", &tile, &pprot) == 2) {
/* method specified from that tile on */
if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
((pprot >= 37) && (pprot <= 128)))) {
fprintf(stderr, "ERROR -> invalid packet protection method p = %d\n", pprot);
return 1;
}
if (tile < 0) {
fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
return 1;
}
if (packspec < JPWL_MAX_NO_PACKSPECS) {
parameters->jpwl_pprot_tileno[packspec] = tile;
parameters->jpwl_pprot_packno[packspec] = 0;
parameters->jpwl_pprot[packspec++] = pprot;
}
} else if (sscanf(token, "p%d:%d=%d", &tile, &pack, &pprot) == 3) {
/* method fully specified from that tile and that packet on */
if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
((pprot >= 37) && (pprot <= 128)))) {
fprintf(stderr, "ERROR -> invalid packet protection method p = %d\n", pprot);
return 1;
}
if (tile < 0) {
fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
return 1;
}
if (pack < 0) {
fprintf(stderr, "ERROR -> invalid packet number on protection method p = %d\n", pack);
return 1;
}
if (packspec < JPWL_MAX_NO_PACKSPECS) {
parameters->jpwl_pprot_tileno[packspec] = tile;
parameters->jpwl_pprot_packno[packspec] = pack;
parameters->jpwl_pprot[packspec++] = pprot;
}
} else if (sscanf(token, "p%d:%d", &tile, &pack) == 2) {
/* default method from that tile and that packet on */
if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
((pprot >= 37) && (pprot <= 128)))) {
fprintf(stderr, "ERROR -> invalid packet protection method p = %d\n", pprot);
return 1;
}
if (tile < 0) {
fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
return 1;
}
if (pack < 0) {
fprintf(stderr, "ERROR -> invalid packet number on protection method p = %d\n", pack);
return 1;
}
if (packspec < JPWL_MAX_NO_PACKSPECS) {
parameters->jpwl_pprot_tileno[packspec] = tile;
parameters->jpwl_pprot_packno[packspec] = pack;
parameters->jpwl_pprot[packspec++] = pprot;
}
} else if (sscanf(token, "p%d", &tile) == 1) {
/* default from a tile on */
if (tile < 0) {
fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
return 1;
}
if (packspec < JPWL_MAX_NO_PACKSPECS) {
parameters->jpwl_pprot_tileno[packspec] = tile;
parameters->jpwl_pprot_packno[packspec] = 0;
parameters->jpwl_pprot[packspec++] = pprot;
}
} else if (!strcmp(token, "p")) {
/* all default */
parameters->jpwl_pprot_tileno[0] = 0;
parameters->jpwl_pprot_packno[0] = 0;
parameters->jpwl_pprot[0] = pprot;
} else {
fprintf(stderr, "ERROR -> invalid protection method selection = %s\n", token);
return 1;
};
}
/* search sensitivity method */
if (*token == 's') {
static int tile = 0, tilespec = 0, lasttileno = 0;
sens = 0; /* predefined: relative error */
if(sscanf(token, "s=%d", &sens) == 1) {
/* Main header, specified */
if ((sens < -1) || (sens > 7)) {
fprintf(stderr, "ERROR -> invalid main header sensitivity method s = %d\n", sens);
return 1;
}
parameters->jpwl_sens_MH = sens;
} else if(sscanf(token, "s%d=%d", &tile, &sens) == 2) {
/* Tile part header, specified */
if ((sens < -1) || (sens > 7)) {
fprintf(stderr, "ERROR -> invalid tile part header sensitivity method s = %d\n", sens);
return 1;
}
if (tile < 0) {
fprintf(stderr, "ERROR -> invalid tile part number on sensitivity method t = %d\n", tile);
return 1;
}
if (tilespec < JPWL_MAX_NO_TILESPECS) {
parameters->jpwl_sens_TPH_tileno[tilespec] = lasttileno = tile;
parameters->jpwl_sens_TPH[tilespec++] = sens;
}
} else if(sscanf(token, "s%d", &tile) == 1) {
/* Tile part header, unspecified */
if (tile < 0) {
fprintf(stderr, "ERROR -> invalid tile part number on sensitivity method t = %d\n", tile);
return 1;
}
if (tilespec < JPWL_MAX_NO_TILESPECS) {
parameters->jpwl_sens_TPH_tileno[tilespec] = lasttileno = tile;
parameters->jpwl_sens_TPH[tilespec++] = hprot;
}
} else if (!strcmp(token, "s")) {
/* Main header, unspecified */
parameters->jpwl_sens_MH = sens;
} else {
fprintf(stderr, "ERROR -> invalid sensitivity method selection = %s\n", token);
return 1;
};
parameters->jpwl_sens_size = 2; /* 2 bytes for default size */
}
/* search addressing size */
if (*token == 'a') {
addr = 0; /* predefined: auto */
if(sscanf(token, "a=%d", &addr) == 1) {
/* Specified */
if ((addr != 0) && (addr != 2) && (addr != 4)) {
fprintf(stderr, "ERROR -> invalid addressing size a = %d\n", addr);
return 1;
}
parameters->jpwl_sens_addr = addr;
} else if (!strcmp(token, "a")) {
/* default */
parameters->jpwl_sens_addr = addr; /* auto for default size */
} else {
fprintf(stderr, "ERROR -> invalid addressing selection = %s\n", token);
return 1;
};
}
/* search sensitivity size */
if (*token == 'z') {
size = 1; /* predefined: 1 byte */
if(sscanf(token, "z=%d", &size) == 1) {
/* Specified */
if ((size != 0) && (size != 1) && (size != 2)) {
fprintf(stderr, "ERROR -> invalid sensitivity size z = %d\n", size);
return 1;
}
parameters->jpwl_sens_size = size;
} else if (!strcmp(token, "a")) {
/* default */
parameters->jpwl_sens_size = size; /* 1 for default size */
} else {
fprintf(stderr, "ERROR -> invalid size selection = %s\n", token);
return 1;
};
}
/* search range method */
if (*token == 'g') {
range = 0; /* predefined: 0 (packet) */
if(sscanf(token, "g=%d", &range) == 1) {
/* Specified */
if ((range < 0) || (range > 3)) {
fprintf(stderr, "ERROR -> invalid sensitivity range method g = %d\n", range);
return 1;
}
parameters->jpwl_sens_range = range;
} else if (!strcmp(token, "g")) {
/* default */
parameters->jpwl_sens_range = range;
} else {
fprintf(stderr, "ERROR -> invalid range selection = %s\n", token);
return 1;
};
}
/* next token or bust */
token = strtok(NULL, ",");
};
/* some info */
fprintf(stdout, "Info: JPWL capabilities enabled\n");
parameters->jpwl_epc_on = OPJ_TRUE;
}
break;
#endif /* USE_JPWL */
/* <<UniPG */
/* ------------------------------------------------------ */
case 'J': /* jpip on */
{
parameters->jpip_on = OPJ_TRUE;
// Switch to CODEC_JP2
if (parameters->cod_format == CODEC_J2K) {
parameters->cod_format = CODEC_JP2;
fprintf(stderr,"J2K output not possible with JPIP. Switching to JP2.\n");
}
}
break;
/* ------------------------------------------------------ */
default:
fprintf(stderr, "ERROR -> Command line not valid\n");
return 1;
}
} while (c != -1);
/* check for possible errors */
if((parameters->infile[0] == 0)) {
fprintf(stderr, "No input file specified - Example: %s -i image.fits\n",argv[0]);
fprintf(stderr, " Try: %s -h\n",argv[0]);
return 1;
}
if ((parameters->cp_disto_alloc || parameters->cp_fixed_alloc || parameters->cp_fixed_quality)
&& (!(parameters->cp_disto_alloc ^ parameters->cp_fixed_alloc ^ parameters->cp_fixed_quality))) {
fprintf(stderr, "Error: options -r -q and -f cannot be used together !!\n");
return 1;
} /* mod fixed_quality */
/* if no rate entered, lossless by default */
if (parameters->tcp_numlayers == 0) {
parameters->tcp_rates[0] = 0; /* MOD antonin : losslessbug */
parameters->tcp_numlayers++;
parameters->cp_disto_alloc = 1;
}
if((parameters->cp_tx0 > parameters->image_offset_x0) || (parameters->cp_ty0 > parameters->image_offset_y0)) {
fprintf(stderr,
"Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n",
parameters->cp_tx0, parameters->image_offset_x0, parameters->cp_ty0, parameters->image_offset_y0);
return 1;
}
for (i = 0; i < parameters->numpocs; i++) {
if (parameters->POC[i].prg == -1) {
fprintf(stderr,
"Unrecognized progression order in option -P (POC n %d) [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n",
i + 1);
}
}
/*
* Compression benchmarking is only accurate if all planes of a data cube are read. Display a message
* informing the user of this if they specify a custom starting plane.
*/
if (*performCompressionBenchmarking && (*startFrame != -1 || *firstStoke != -1) ) {
fprintf(stderr,"Compression benchmarking results are only accurate if all planes and stokes of a data cube\n");
fprintf(stderr,"or data volume are converted. Beware of this when interpreting results.\n");
}
#ifdef noise
/*
* Note if a seed was set but not a noise value.
*/
if (*seedSet && !*noiseSet) {
fprintf(stderr,"A random number seed was set but not a target PSNR for noise addition.\n");
fprintf(stderr,"The seed will therefore be ignored.\n");
}
/*
* Note if we were asked to write a noise field but not actually asked to add any noise.
*/
if (*writeNoiseField && !*noiseSet) {
fprintf(stderr,"Will not write noise field as no noise will be added to image.\n");
*writeNoiseField = false;
}
#endif
return 0;
}
