Rsiz profile name generation to be STD_RSIZ for profiles which are not DCI compliant.Modification in image_to_j2k.c
Renamed convert_progression_order to j2k_convert_progression_order. Modification j2k.c
Calculation of number of tile part in each tile in j2k_calculate_tp. Modification j2k.c
j2k_setup_encoder to set bit rate limitation for digital cinema compliance with quality option. Modification in j2k.c
Equation to check multiple tile precincts. Modification pi.c
array size generation of pi->include in pi_initialise_encode().Modification in pi.c
Modification in pi_create_encode for tile part generation.Modification in pi.c
In tcd_rateallocate a variable stable_threshold which holds the valid threshold value. This is used to avoid error in case of a wrong threshold value in the last iteration. Modification in tcd.c.
! : changed
+ : added
+March 29, 2007
+* [Parvatha] Enable accepting file names with `-´ symbol .Modification getopt.c
+* [Parvatha] Rsiz profile name generation to be STD_RSIZ for profiles which are not DCI compliant.Modification in image_to_j2k.c
+! [Parvatha] renamed convert_progression_order to j2k_convert_progression_order. Modification j2k.c
+* [Parvatha] Calculation of number of tile part in each tile in j2k_calculate_tp. Modification j2k.c
+! [Parvatha] j2k_setup_encoder to set bit rate limitation for digital cinema compliance with quality option. Modification in j2k.c
+* [Parvatha] Equation to check multiple tile precincts. Modification pi.c
+! [Parvatha] array size generation of pi->include in pi_initialise_encode().Modification in pi.c
+* [Parvatha] modification in pi_create_encode for tile part generation.Modification in pi.c
++ [Parvatha] In tcd_rateallocate a variable stable_threshold which holds the valid threshold value. This is used to avoid error in case of a wrong threshold value in the last iteration. Modification in tcd.c.
+
March 28, 2007
* [FOD] Fixed an historical bug in t1.c that leaded to the inclusion of useless 0xFF in the codestream. Thanks to Sylvain, Pascal and Parvatha !
int getopt_long(int argc, char * const argv[], const char *optstring,
-struct option *longopts, int *longindex, int totlen) {
+struct option *longopts, int totlen) {
static int lastidx,lastofs;
char *tmp;
int i,len;
if(strlen(arg)>1){
for (i=0;i<totlen;i=i+len,o++) {
if (!strcmp(o->name,arg)) { /* match */
- if (longindex) *longindex=o-longopts;
- if (o->has_arg>0) {
- optarg=argv[optind+1];
- if(optarg){
- if (strchr(optarg,'-')){ /* Has read next input parameter: No arg for current parameter */
- if (opterr) {
- fprintf(stderr,"%s: option requires an argument\n",arg);
- return (BADCH);
- }
- }
- }
- if (!optarg && o->has_arg==1) { /* no argument there */
+ if (o->has_arg == 0) {
+ if (!(argv[optind+1][0]=='-')){
+ fprintf(stderr,"%s: option does not require an argument. Ignoring %s\n",arg,argv[optind+1]);
+ ++optind;
+ }
+ }else{
+ optarg=argv[optind+1];
+ if(optarg){
+ if (optarg[0] == '-'){ /* Has read next input parameter: No arg for current parameter */
if (opterr) {
- fprintf(stderr,"%s: option requires an argument %c\n",arg, optopt);
+ fprintf(stderr,"%s: option requires an argument\n",arg);
return (BADCH);
}
}
- ++optind;
+ }
+ if (!optarg && o->has_arg==1) { /* no argument there */
+ if (opterr) {
+ fprintf(stderr,"%s: option requires an argument \n",arg);
+ return (BADCH);
+ }
+ }
+ ++optind;
}
++optind;
if (o->flag)
}
optarg=argv[optind+1];
if(optarg){
- if (strchr(optarg,'-')){ /* Has read next input parameter: No arg for current parameter */
+ if (optarg[0] == '-'){ /* Has read next input parameter: No arg for current parameter */
if (opterr) {
fprintf(stderr,"%s: option requires an argument\n",arg);
return (BADCH);
}
++optind;
}else {/*Argument not expected*/
- ++lastofs;
- return optopt;
+ ++lastofs;
+ return optopt;
}
found:
- ++optind;
- return optopt;
+ ++optind;
+ return optopt;
} else { /* not found */
- fprintf(stderr,"Invalid option %s\n",arg);
- ++optind;
- return (BADCH);
+ fprintf(stderr,"Invalid option %s\n",arg);
+ ++optind;
+ return (BADCH);
}//end of not found
}// end of single character
fprintf(stderr,"Invalid option %s\n");
++optind;
return (BADCH);;
- }//end function
+}//end function
extern int getopt(int nargc, char *const *nargv, const char *ostr);
extern int getopt_long(int argc, char * const argv[], const char *optstring,
- const struct option *longopts, int *longindex,int totlen);
+ const struct option *longopts, int totlen);
#endif /* _GETOPT_H_ */
switch (parameters->cp_cinema){
case CINEMA2K_24:
case CINEMA2K_48:
- parameters->cp_rsiz = CINEMA2K;
if(parameters->numresolution > 6){
parameters->numresolution = 6;
}
if (!((image->comps[0].w == 2048) & (image->comps[0].h == 1080))){
- fprintf(stdout,"Image coordinates is not 2K, %d x %d\n",image->comps[0].w,image->comps[0].h);
+ fprintf(stdout,"Image coordinates %d x %d is not 2K compliant.\nDCI 2K compliance requires that atleast one of coordinates match 2048 x 1080\n",image->comps[0].w,image->comps[0].h);
+ parameters->cp_rsiz = STD_RSIZ;
}
break;
case CINEMA4K_24:
- parameters->cp_rsiz = CINEMA4K;
if(parameters->numresolution < 1){
parameters->numresolution = 1;
- }else if(parameters->numresolution > 7){
+ }else if((parameters->numresolution < 7) || (parameters->numresolution > 7)){
parameters->numresolution = 7;
}
if (!((image->comps[0].w == 4096) & (image->comps[0].h == 2160))){
- fprintf(stdout,"Image coordinates is not 4K, %d x %d\n",image->comps[0].w,image->comps[0].h);
+ fprintf(stdout,"Image coordinates %d x %d is not 4K compliant.\nDCI 4K compliance requires that atleast one of coordinates match 4096 x 2160\n",image->comps[0].w,image->comps[0].h);
+ parameters->cp_rsiz = STD_RSIZ;
}
break;
}
case CINEMA2K_48:
for(i=0;i<parameters->tcp_numlayers;i++){
+ temp_rate = 0 ;
if (parameters->tcp_rates[i]== 0){
parameters->tcp_rates[0]= ((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
(CINEMA_48_CS * 8 * image->comps[0].dx * image->comps[0].dy);
}else{
- parameters->tcp_rates[i]=((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
+ temp_rate =((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
(parameters->tcp_rates[i] * 8 * image->comps[0].dx * image->comps[0].dy);
- if (parameters->tcp_rates[i] > CINEMA_48_CS ){
+ if (temp_rate > CINEMA_48_CS ){
parameters->tcp_rates[0]= ((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
(CINEMA_48_CS * 8 * image->comps[0].dx * image->comps[0].dy);
}
}
}
break;
-
-}
-
+ }
parameters->cp_disto_alloc = 1;
}
int parse_cmdline_encoder(int argc, char **argv, opj_cparameters_t *parameters,img_fol_t *img_fol) {
int i, j,totlen;
option_t long_option[]={
- {"cinema2k",REQ_ARG, NULL ,'w'},
- {"cinema4k",NO_ARG, NULL ,'y'},
+ {"cinema2K",REQ_ARG, NULL ,'w'},
+ {"cinema4K",NO_ARG, NULL ,'y'},
{"ImgDir",REQ_ARG, NULL ,'z'},
{"TP",REQ_ARG, NULL ,'v'},
{"SOP",NO_ARG, NULL ,'S'},
img_fol->set_out_format=0;
while (1) {
- int c = getopt_long(argc, argv, optlist,long_option,NULL,totlen);
+ int c = getopt_long(argc, argv, optlist,long_option,totlen);
/* <<UniPG */
if (c == -1)
break;
return 1;
}
fprintf(stdout,"CINEMA 2K compliant codestream\n");
+ parameters->cp_rsiz = CINEMA2K;
}
break;
{
parameters->cp_cinema = CINEMA4K_24;
fprintf(stdout,"CINEMA 4K compliant codestream\n");
+ parameters->cp_rsiz = CINEMA4K;
}
break;
/* check for possible errors */
if (parameters->cp_cinema){
- if(parameters->tcp_numlayers > 0){
+ if(parameters->tcp_numlayers > 1){
+ parameters->cp_rsiz = STD_RSIZ;
fprintf(stdout,"Warning: DC profiles do not allow more than one quality layer. The codestream created will not be compliant with the DC profile\n");
}
}
}
fwrite(cio->buffer, 1, codestream_length, f);
fclose(f);
-
+ fprintf(stderr,"Generated outfile %s\n",parameters.outfile);
/* close and free the byte stream */
opj_cio_close(cio);
totlen=sizeof(long_option);
img_fol->set_out_format = 0;
while (1) {
- int c = getopt_long(argc, argv,optlist,long_option,NULL,totlen);
+ int c = getopt_long(argc, argv,optlist,long_option,totlen);
if (c == -1)
break;
switch (c) {
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
}
else {
- fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
+ fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
}
else {
- fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
+ fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
}
else {
- fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
+ fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
}
else {
- fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
+ fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
}
{PCRL, "PCRL"},
{RLCP, "RLCP"},
{RPCL, "RPCL"},
- {-1, NULL}
+ {-1, ""}
};
-char *convert_progression_order(OPJ_PROG_ORDER prg_order){
+char *j2k_convert_progression_order(OPJ_PROG_ORDER prg_order){
j2k_prog_order_t *po;
for(po = j2k_prog_order_list; po->enum_prog != -1; po++ ){
if(po->enum_prog == prg_order){
}
/* ----------------------------------------------------------------------- */
-int j2k_get_num_tp(opj_cp_t *cp,int pino,int tileno){
+static int j2k_get_num_tp(opj_cp_t *cp,int pino,int tileno){
char *prog;
int i;
int tpnum=1,tpend=0;
opj_tcp_t *tcp = &cp->tcps[tileno];
- prog = convert_progression_order(tcp->prg);
+ prog = j2k_convert_progression_order(tcp->prg);
if(cp->tp_on == 1){
for(i=0;i<4;i++){
}
/** mem allocation for TLM marker*/
-int j2k_generate_tlm(opj_cp_t *cp,int img_numcomp,opj_image_t *image ){
+int j2k_calculate_tp(opj_cp_t *cp,int img_numcomp,opj_image_t *image,opj_j2k_t *j2k ){
int pino,tileno,maxres=0,totnum_tp=0;
+ j2k->cur_totnum_tp = (int *) opj_malloc(cp->tw * cp->th * sizeof(int));
for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
+ int cur_totnum_tp = 0;
opj_tcp_t *tcp = &cp->tcps[tileno];
for(pino = 0; pino <= tcp->numpocs; pino++) {
int tp_num=0;
- opj_pi_iterator_t *pi = (opj_pi_iterator_t *) opj_malloc(sizeof(opj_pi_iterator_t));
- pi = pi_initialise_encode(image, cp, tileno,pino);
+ opj_pi_iterator_t *pi = pi_initialise_encode(image, cp, tileno,pino);
if(!pi) { return -1;}
tp_num = j2k_get_num_tp(cp,pino,tileno);
totnum_tp = totnum_tp + tp_num;
+ cur_totnum_tp = cur_totnum_tp + tp_num;
pi_destroy(pi, cp, tileno);
}
+ j2k->cur_totnum_tp[tileno] = cur_totnum_tp;
}
return totnum_tp;
}
cio_write(cio, j2k->curtileno, 2); /* Isot */
cio_skip(cio, 4); /* Psot (further in j2k_write_sod) */
cio_write(cio, j2k->cur_tp_num , 1); /* TPsot */
- cio_write(cio, j2k->cur_totnum_tp, 1); /* TNsot */
+ cio_write(cio, j2k->cur_totnum_tp[j2k->curtileno], 1); /* TNsot */
len = cio_tell(cio) - lenp;
cio_seek(cio, lenp);
cio_write(cio, len, 2); /* Lsot */
opj_cp_t *cp = j2k->cp;
opj_cio_t *cio = j2k->cio;
+ tcd->tp_num = j2k->tp_num ;
tcd->cur_tp_num = j2k->cur_tp_num;
- tcd->cur_totnum_tp = j2k->cur_totnum_tp;
+ tcd->cur_totnum_tp = j2k->cur_totnum_tp[j2k->curtileno];
cio_write(cio, J2K_MS_SOD, 2);
if (j2k->curtileno == 0) {
opj_tcp_t *tcp = &cp->tcps[tileno];
tcp->numlayers = parameters->tcp_numlayers;
for (j = 0; j < tcp->numlayers; j++) {
- if (cp->fixed_quality) { /* add fixed_quality */
- tcp->distoratio[j] = parameters->tcp_distoratio[j];
- } else {
+ if(cp->cinema){
+ if (cp->fixed_quality) {
+ tcp->distoratio[j] = parameters->tcp_distoratio[j];
+ }
tcp->rates[j] = parameters->tcp_rates[j];
+ }else{
+ if (cp->fixed_quality) { /* add fixed_quality */
+ tcp->distoratio[j] = parameters->tcp_distoratio[j];
+ } else {
+ tcp->rates[j] = parameters->tcp_rates[j];
+ }
}
}
tcp->csty = parameters->csty;
}
/* << INDEX */
+ j2k->totnum_tp = j2k_calculate_tp(cp,image->numcomps,image,j2k);
/* TLM Marker*/
if(cp->cinema){
- j2k->totnum_tp = j2k_generate_tlm(cp,image->numcomps,image);
j2k_write_tlm(j2k);
}
/**** Main Header ENDS here ***/
opj_event_msg(j2k->cinfo, EVT_INFO, "tile number %d / %d\n", tileno + 1, cp->tw * cp->th);
j2k->curtileno = tileno;
+ j2k->cur_tp_num = 0;
/* initialisation before tile encoding */
if (tileno == 0) {
for(pino = 0; pino <= tcp->numpocs; pino++) {
int tot_num_tp;
- opj_pi_iterator_t *pi = NULL;
tcd->cur_pino=pino;
- tcd->pi = pi_initialise_encode(image, cp, tileno,pino);
- pi=tcd->pi;
/*Get number of tile parts*/
tot_num_tp = j2k_get_num_tp(cp,pino,tileno);
tcd->tp_pos = cp->tp_pos;
for(tilepartno = 0; tilepartno < tot_num_tp ; tilepartno++){
- j2k->cur_tp_num = tilepartno;
- j2k->cur_totnum_tp = tot_num_tp;
+ j2k->tp_num = tilepartno;
j2k_write_sot(j2k);
if(j2k->cur_tp_num == 0 && cp->cinema == 0){
}
j2k_write_sod(j2k, tcd);
+ j2k->cur_tp_num ++;
}
- pi_destroy(pi, cp, tileno);
+
}
/* INDEX >> */
if(image_info && image_info->index_on) {
int state;
/** number of the tile curently concern by coding/decoding */
int curtileno;
+ /** Tile part number*/
+ int tp_num;
/** Tilepart number currently coding*/
int cur_tp_num;
/** Total number of tileparts of the current tile*/
- int cur_totnum_tp;
+ int *cur_totnum_tp;
/**
locate the start position of the TLM marker
after encoding the tilepart, a jump (in j2k_write_sod) is done to the TLM marker to store the value of its length.
/**
Converts an enum type progression order to string type
*/
-char *convert_progression_order(OPJ_PROG_ORDER prg_order);
-/**
-Generates the number of tile parts for the current tile
-*/
-int j2k_get_num_tp(opj_cp_t *cp,int pino,int tileno);
+char *j2k_convert_progression_order(OPJ_PROG_ORDER prg_order);
/**
Encode an image into a JPEG-2000 codestream
@param j2k J2K compressor handle
enum definitions
==========================================================
*/
-
+/**
+Rsiz Capabilities
+*/
typedef enum RSIZ_CAPABILITIES {
- STD_RSIZ = 0,
+ STD_RSIZ = 0, /** Standard JPEG2000 profile*/
CINEMA2K = 3, /** Profile name for a 2K image*/
CINEMA4K = 4 /** Profile name for a 4K image*/
} OPJ_RSIZ_CAPABILITIES;
+/**
+Digital cinema operation mode
+*/
typedef enum CINEMA_MODE {
- OFF = 0,
- CINEMA2K_24 = 1,
- CINEMA2K_48 = 2,
- CINEMA4K_24 = 3
+ OFF = 0, /** Not Digital Cinema*/
+ CINEMA2K_24 = 1, /** 2K Digital Cinema at 24 fps*/
+ CINEMA2K_48 = 2, /** 2K Digital Cinema at 48 fps*/
+ CINEMA4K_24 = 3 /** 4K Digital Cinema at 24 fps*/
}OPJ_CINEMA_MODE;
-/** Progression order */
+/**
+Progression order
+*/
typedef enum PROG_ORDER {
PROG_UNKNOWN = -1, /**< place-holder */
LRCP = 0, /**< layer-resolution-component-precinct order */
pi->first = 0;
}
- for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
+ for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1;
pi->resno++) {
for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
}
for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
- for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
+ for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
comp = &pi->comps[pi->compno];
if (pi->resno >= comp->numresolutions) {
try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
rpx = res->pdx + levelno;
rpy = res->pdy + levelno;
- if ((!(pi->x % (comp->dx << rpx) == 0) || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {
- continue;
+ if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpx))))){
+ continue;
}
- if ((!(pi->y % (comp->dy << rpy) == 0) || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {
- continue;
+ if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+ continue;
}
if ((res->pw==0)||(res->pw==0)) continue;
prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
- int_floordivpow2(try0, res->pdy);
pi->precno = prci + prcj * res->pw;
- for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
+ for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
if (!pi->include[index]) {
pi->include[index] = 1;
try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
rpx = res->pdx + levelno;
rpy = res->pdy + levelno;
- if ((!(pi->x % (comp->dx << rpx) == 0) || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {
- continue;
+ if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpx))))){
+ continue;
}
- if ((!(pi->y % (comp->dy << rpy) == 0) || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {
- continue;
+ if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+ continue;
}
if ((res->pw==0)||(res->pw==0)) continue;
prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
- int_floordivpow2(try0, res->pdy);
pi->precno = prci + prcj * res->pw;
- for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
+ for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
if (!pi->include[index]) {
pi->include[index] = 1;
try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
rpx = res->pdx + levelno;
rpy = res->pdy + levelno;
- if ((!(pi->x % (comp->dx << rpx) == 0) || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {
- continue;
+ if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpx))))){
+ continue;
}
- if ((!(pi->y % (comp->dy << rpy) == 0) || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {
- continue;
+ if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+ continue;
}
if ((res->pw==0)||(res->pw==0)) continue;
prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
- int_floordivpow2(try0, res->pdy);
pi->precno = prci + prcj * res->pw;
- for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
+ for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
if (!pi->include[index]) {
pi->include[index] = 1;
pi = (opj_pi_iterator_t *) opj_malloc(array_size);
pi->tp_on = cp->tp_on;
if(!pi) { return NULL;}
-
+ for(pino = 0;pino < tcp->numpocs+1 ; pino ++){
p = tileno % cp->tw;
q = tileno / cp->tw;
}
if (pino == 0) {
- array_size = image->numcomps * maxres * tcp->numlayers * 100 * sizeof(short int);
+ array_size = (tcp->numpocs+1) * tcp->numlayers * pi[pino].step_l * sizeof(short int);
pi[pino].include = (short int *) opj_malloc(array_size);
if(!pi[pino].include) {
pi_destroy(pi, cp, tileno);
tcp->pocs[pino].tyE = pi[pino].ty1;
tcp->pocs[pino].dx = pi[pino].dx;
tcp->pocs[pino].dy = pi[pino].dy;
- return pi;
+ }
+ return pi;
}
int incr_top=1,resetX=0;
opj_tcp_t *tcps =&cp->tcps[tileno];
opj_poc_t *tcp= &tcps->pocs[pino];
- prog = convert_progression_order(tcp->prg);
+ prog = j2k_convert_progression_order(tcp->prg);
pi[pino].first = 1;
pi[pino].poc.prg = tcp->prg;
incr_top=1;
}else{
for(i=tppos;i>=0;i--){
+ switch(prog[i]){
+ case 'C':
+ pi[pino].poc.compno0 = tcp->comp_t-1;
+ pi[pino].poc.compno1 = tcp->comp_t;
+ break;
+ case 'R':
+ pi[pino].poc.resno0 = tcp->res_t-1;
+ pi[pino].poc.resno1 = tcp->res_t;
+ break;
+ case 'L':
+ pi[pino].poc.layno0 = tcp->lay_t-1;
+ pi[pino].poc.layno1 = tcp->lay_t;
+ break;
+ case 'P':
+ switch(tcp->prg){
+ case LRCP:
+ case RLCP:
+ pi[pino].poc.precno0 = tcp->prc_t-1;
+ pi[pino].poc.precno1 = tcp->prc_t;
+ break;
+ default:
+ pi[pino].poc.tx0 = tcp->tx0_t - tcp->dx - (tcp->tx0_t % tcp->dx);
+ pi[pino].poc.tx1 = tcp->tx0_t ;
+ pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
+ pi[pino].poc.ty1 = tcp->ty0_t ;
+ break;
+ }
+ break;
+ }
if(incr_top==1){
switch(prog[i]){
case 'R':
/* ----------------------------------------------------------------------- */
-int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_image_info_t *image_info,opj_pi_iterator_t *tcd_pi,int tpnum, int tppos,int pino, char final_encoding){
+int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_image_info_t *image_info,int tpnum, int tppos,int pino, char final_encoding){
unsigned char *c = dest;
int e = 0;
opj_pi_iterator_t *pi = NULL;
opj_image_t *image = t2->image;
opj_cp_t *cp = t2->cp;
- if(final_encoding == 0){
- pi = pi_initialise_encode(image, cp, tileno,pino);
- }else{
- pi = tcd_pi;
- }
+ pi = pi_initialise_encode(image, cp, tileno,pino);
if(!pi) {
/* TODO: throw an error */
return -999;
/* << INDEX */
}
}
- if(final_encoding == 0){
- pi_destroy(pi, cp, tileno);
- }
+
+ pi_destroy(pi, cp, tileno);
+
if (e == -999) {
return e;
}
@param len the length of the destination buffer
@param image_info structure to create an index file
*/
-int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_image_info_t *image_info,opj_pi_iterator_t *tcd_pi,int tpnum, int tppos,int pino,char final_encoding);
+int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_image_info_t *image_info,int tpnum, int tppos,int pino,char final_encoding);
/**
Decode the packets of a tile from a source buffer
@param t2 T2 handle
/* TODO: remove maxlen */
int maxlen = tcd_tcp->rates[layno] ? int_min(((int) ceil(tcd_tcp->rates[layno])), len) : len;
double goodthresh = 0;
+ double stable_thresh = 0;
int i;
double distotarget; /* fixed_quality */
if (cp->fixed_quality) { /* fixed_quality */
if(cp->cinema){
- l = t2_encode_packets(t2,tcd->tcd_tileno, tcd_tile, layno + 1, dest, maxlen, image_info,tcd->pi,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,0);
+ l = t2_encode_packets(t2,tcd->tcd_tileno, tcd_tile, layno + 1, dest, maxlen, image_info,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,0);
if (l == -999) {
lo = thresh;
continue;
distoachieved = layno == 0 ?
tcd_tile->distolayer[0] : cumdisto[layno - 1] + tcd_tile->distolayer[layno];
if (distoachieved < distotarget) {
- hi=thresh; continue;
+ hi=thresh;
+ stable_thresh = thresh;
+ continue;
}else{
lo=thresh;
}
tcd_tile->distolayer[0] : (cumdisto[layno - 1] + tcd_tile->distolayer[layno]);
if (distoachieved < distotarget) {
hi = thresh;
+ stable_thresh = thresh;
continue;
}
lo = thresh;
}
} else {
- l = t2_encode_packets(t2, tcd->tcd_tileno, tcd_tile, layno + 1, dest, maxlen, image_info,tcd->pi,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,0);
+ l = t2_encode_packets(t2, tcd->tcd_tileno, tcd_tile, layno + 1, dest, maxlen, image_info,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,0);
/* TODO: what to do with l ??? seek / tell ??? */
/* opj_event_msg(tcd->cinfo, EVT_INFO, "rate alloc: len=%d, max=%d\n", l, maxlen); */
if (l == -999) {
continue;
}
hi = thresh;
+ stable_thresh = thresh;
}
-
- success = 1;
- goodthresh = thresh;
}
+ success = 1;
+ goodthresh = stable_thresh;
t2_destroy(t2);
} else {
success = 1;
}
t2 = t2_create(tcd->cinfo, image, cp);
- l = t2_encode_packets(t2,tileno, tile, tcd_tcp->numlayers, dest, len, image_info,tcd->pi,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,1);
+ l = t2_encode_packets(t2,tileno, tile, tcd_tcp->numlayers, dest, len, image_info,tcd->tp_num,tcd->tp_pos,tcd->cur_pino,1);
t2_destroy(t2);
/*---------------CLEAN-------------------*/
- encoding_time = opj_clock() - encoding_time;
- if(tcd->cur_totnum_tp > 1){
- opj_event_msg(tcd->cinfo, EVT_INFO, "- Tile part num %d encoded in %f s\n", tcd->cur_tp_num,encoding_time);
- }else{
- opj_event_msg(tcd->cinfo, EVT_INFO, "- tile encoded in %f s\n", encoding_time);
- }
-
+
if(tcd->cur_tp_num == tcd->cur_totnum_tp - 1){
+ encoding_time = opj_clock() - encoding_time;
+ opj_event_msg(tcd->cinfo, EVT_INFO, "- tile encoded in %f s\n", encoding_time);
+
/* cleaning memory */
for (compno = 0; compno < tile->numcomps; compno++) {
opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
typedef struct opj_tcd {
/** Position of the tilepart flag in Progression order*/
int tp_pos;
+ /** Tile part number*/
+ int tp_num;
/** Current tile part number*/
int cur_tp_num;
/** Total number of tileparts of the current tile*/
opj_tcp_t *tcp;
/** current encoded/decoded tile */
int tcd_tileno;
- /** Packet iterator*/
- opj_pi_iterator_t *pi;
} opj_tcd_t;
/** @name Exported functions */
projects / openjpeg / commitdiff