Browse Source

New -zisofs parameters version_2=, block_size_v2=, max_bpt=, max_bpt_f=

master
Thomas Schmitt 12 months ago
parent
commit
dcb13954bd
  1. 5
      xorriso/base_obj.c
  2. 103
      xorriso/filters.c
  3. 19
      xorriso/iso_tree.c
  4. 13
      xorriso/lib_mgt.c
  5. 2
      xorriso/opts_d_h.c
  6. 81
      xorriso/opts_p_z.c
  7. 54
      xorriso/xorriso.1
  8. 6029
      xorriso/xorriso.info
  9. 54
      xorriso/xorriso.texi
  10. 13
      xorriso/xorriso_private.h
  11. 2
      xorriso/xorriso_timestamp.h

5
xorriso/base_obj.c

@ -195,6 +195,11 @@ int Xorriso_new(struct XorrisO ** xorriso,char *progname, int flag)
m->zlib_level_default= m->zlib_level= 6;
m->zisofs_block_size= m->zisofs_block_size_default= (1 << 15);
m->zisofs_by_magic= 0;
m->zisofs_v2_enabled= 0;
m->zisofs_max_total_blocks= m->zisofs_max_total_blocks_default= 0x2000000;
m->zisofs_max_file_blocks= m->zisofs_max_file_blocks_default= 0x2000000;
m->zisofs_block_size= m->zisofs_block_size_default= (1 << 15);
m->zisofs_v2_block_size= m->zisofs_v2_block_size_default= (1 << 17);
m->do_overwrite= 2;
m->do_reassure= 0;
m->drive_blacklist= NULL;

103
xorriso/filters.c

@ -1,7 +1,7 @@
/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
Copyright 2007-2014 Thomas Schmitt, <scdbackup@gmx.net>
Copyright 2007-2020 Thomas Schmitt, <scdbackup@gmx.net>
Provided under GPL version 2 or later.
@ -659,10 +659,12 @@ int Xorriso_status_extf(struct XorrisO *xorriso, char *filter, FILE *fp,
int Xorriso_set_zisofs_params(struct XorrisO *xorriso, int flag)
{
int ret;
int ret, i;
struct iso_zisofs_ctrl ctrl;
ctrl.version= 0;
memset(&ctrl, 0, sizeof(ctrl));
ctrl.version= 1;
ctrl.compression_level= xorriso->zlib_level;
if(xorriso->zisofs_block_size == (1 << 16))
ctrl.block_size_log2= 16;
@ -670,6 +672,15 @@ int Xorriso_set_zisofs_params(struct XorrisO *xorriso, int flag)
ctrl.block_size_log2= 17;
else
ctrl.block_size_log2= 15;
ctrl.v2_enabled= xorriso->zisofs_v2_enabled;
ctrl.max_total_blocks= xorriso->zisofs_max_total_blocks;
ctrl.max_file_blocks= xorriso->zisofs_max_file_blocks;
ctrl.v2_block_size_log2= 17;
for(i= 15; i <= 17; i++)
if(xorriso->zisofs_v2_block_size == (1 << i))
ctrl.v2_block_size_log2= i;
ret= iso_zisofs_set_params(&ctrl, 0);
Xorriso_process_msg_queues(xorriso,0);
if(ret < 0) {
@ -681,21 +692,48 @@ int Xorriso_set_zisofs_params(struct XorrisO *xorriso, int flag)
}
uint64_t Xorriso_zisofs_current_blocks(struct XorrisO *xorriso, int flag)
{
int ret;
struct iso_zisofs_ctrl ctrl;
memset(&ctrl, 0, sizeof(ctrl));
ctrl.version= 1;
ret = iso_zisofs_get_params(&ctrl, 0);
if(ret != 1)
return(0);
return(ctrl.current_total_blocks);
}
int Xorriso_status_zisofs(struct XorrisO *xorriso, char *filter, FILE *fp,
int flag)
/*
bit0= do only report non-default settings
bit1= do only report to fp
bit0= only report non-default settings
bit1= only report to fp
*/
{
off_t ziso_count= 0, osiz_count= 0;
off_t gzip_count= 0, gunzip_count= 0;
uint64_t used_blocks;
int always= 0;
iso_zisofs_get_refcounts(&ziso_count, &osiz_count, 0);
iso_gzip_get_refcounts(&gzip_count, &gunzip_count, 0);
if(!(flag & 1)) {
always= 1;
} else if(filter != NULL) {
if(filter[0] != 0)
always= 1;
}
#ifdef NIX
if((flag & 1) && xorriso->zlib_level == xorriso->zlib_level_default &&
xorriso->zisofs_block_size == xorriso->zisofs_block_size_default &&
xorriso->zisofs_by_magic == 0 &&
xorriso->zisofs_by_magic == 0 && xorriso->zisofs_v2_enabled == 0 &&
xorriso->zisofs_max_file_blocks ==
xorriso->zisofs_max_file_blocks_default &&
xorriso->zisofs_v2_block_size == xorriso->zisofs_v2_block_size_default &&
ziso_count == 0 && osiz_count == 0 &&
gzip_count == 0 && gunzip_count == 0) {
if(filter == NULL)
@ -703,15 +741,52 @@ int Xorriso_status_zisofs(struct XorrisO *xorriso, char *filter, FILE *fp,
if(filter[0] == 0)
return 2;
}
sprintf(xorriso->result_line,
"-zisofs level=%d:block_size=%dk:by_magic=%s:ziso_used=%.f:osiz_used=%.f",
xorriso->zlib_level, xorriso->zisofs_block_size / 1024,
xorriso->zisofs_by_magic ? "on" : "off",
(double) ziso_count, (double) osiz_count);
sprintf(xorriso->result_line + strlen(xorriso->result_line),
":gzip_used=%.f:gunzip_used=%.f\n",
#endif
if(always || !(
xorriso->zlib_level == xorriso->zlib_level_default &&
xorriso->zisofs_block_size == xorriso->zisofs_block_size_default &&
xorriso->zisofs_by_magic == 0)) {
sprintf(xorriso->result_line,
"-zisofs level=%d:block_size=%dk:by_magic=%s\n",
xorriso->zlib_level, xorriso->zisofs_block_size / 1024,
xorriso->zisofs_by_magic ? "on" : "off");
Xorriso_status_result(xorriso, filter, fp, flag & 2);
}
if(always || !(
xorriso->zisofs_v2_enabled == 0 &&
xorriso->zisofs_v2_block_size == xorriso->zisofs_v2_block_size_default)){
sprintf(xorriso->result_line,
"-zisofs version_2=%s:block_size_v2=%dk\n",
xorriso->zisofs_v2_enabled ? xorriso->zisofs_v2_enabled == 1 ?
"as_needed" : "on" : "off",
xorriso->zisofs_v2_block_size / 1024);
Xorriso_status_result(xorriso, filter, fp, flag & 2);
}
used_blocks= Xorriso_zisofs_current_blocks(xorriso, 0);
if(always || !(
xorriso->zisofs_max_total_blocks ==
xorriso->zisofs_max_total_blocks_default &&
xorriso->zisofs_max_file_blocks ==
xorriso->zisofs_max_file_blocks_default &&
used_blocks == 0)) {
sprintf(xorriso->result_line,
"-zisofs max_bpt=%.f:bpt_used=%.f:max_bpt_f=%.f\n",
(double) xorriso->zisofs_max_total_blocks * 8.0,
(double) used_blocks * 8.0,
(double) xorriso->zisofs_max_file_blocks * 8.0);
Xorriso_status_result(xorriso, filter, fp, flag & 2);
}
if(always || !(
ziso_count == 0 && osiz_count == 0 &&
gzip_count == 0 && gunzip_count == 0)) {
sprintf(xorriso->result_line,
"-zisofs ziso_used=%.f:osiz_used=%.f:gzip_used=%.f:gunzip_used=%.f\n",
(double) ziso_count, (double) osiz_count,
(double) gzip_count, (double) gunzip_count);
Xorriso_status_result(xorriso, filter, fp, flag&2);
Xorriso_status_result(xorriso, filter, fp, flag & 2);
}
return(1);
}

19
xorriso/iso_tree.c

@ -1296,7 +1296,8 @@ ex:
int Xorriso_stream_type(struct XorrisO *xorriso, IsoNode *node,
IsoStream *stream, char type_text[], int flag)
{
int ret, lba;
int ret, lba, stream_type, block_size_log2;
uint8_t zisofs_algo[2], algo_num;
char text[5];
strncpy(text, stream->class->type, 4);
@ -1307,10 +1308,16 @@ int Xorriso_stream_type(struct XorrisO *xorriso, IsoNode *node,
strcpy(type_text, "image");
else
strcpy(type_text, "disk");
} else if(strcmp(text, "ziso") == 0) {
strcpy(type_text, "--zisofs");
} else if(strcmp(text, "osiz") == 0) {
strcpy(type_text, "--zisofs-decode");
} else if(strcmp(text, "ziso") == 0 || strcmp(text, "osiz") == 0) {
if(strcmp(text, "ziso") == 0)
strcpy(type_text, "--zisofs");
else
strcpy(type_text, "--zisofs-decode");
ret= iso_stream_get_zisofs_par(stream, &stream_type, zisofs_algo, &algo_num,
&block_size_log2, 0);
if(ret == 1)
sprintf(type_text + strlen(type_text), ":%c%c:%d",
zisofs_algo[0], zisofs_algo[1], 1 << block_size_log2);
} else if(strcmp(text, "gzip") == 0) {
strcpy(type_text, "--gzip");
} else if(strcmp(text, "pizg") == 0) {
@ -2392,7 +2399,7 @@ int Xorriso_show_stream(struct XorrisO *xorriso, void *in_node,
IsoFile *file;
IsoStream *stream= NULL, *input_stream;
IsoExternalFilterCommand *cmd;
char type_text[16], *source_path= NULL;
char type_text[80], *source_path= NULL;
unsigned int fs_id;
dev_t dev_id;
ino_t ino_id;

13
xorriso/lib_mgt.c

@ -1,7 +1,7 @@
/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
Copyright 2007-2019 Thomas Schmitt, <scdbackup@gmx.net>
Copyright 2007-2020 Thomas Schmitt, <scdbackup@gmx.net>
Provided under GPL version 2 or later.
@ -120,7 +120,7 @@ int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag)
{
int ret, major, minor, micro;
char *queue_sev, *print_sev, reason[1024];
struct iso_zisofs_ctrl zisofs_ctrl= {0, 6, 15};
struct iso_zisofs_ctrl zisofs_ctrl;
/* First an ugly compile time check for header version compatibility.
@ -213,12 +213,21 @@ LIBISOBURN_MISCONFIGURATION_ = 0;
if(ret <= 0)
return(ret);
memset(&zisofs_ctrl, 0, sizeof(zisofs_ctrl));
zisofs_ctrl.version = 1;
ret = iso_zisofs_get_params(&zisofs_ctrl, 0);
if (ret == 1) {
xorriso->zisofs_block_size= xorriso->zisofs_block_size_default=
(1 << zisofs_ctrl.block_size_log2);
xorriso->zlib_level= xorriso->zlib_level_default=
zisofs_ctrl.compression_level;
xorriso->zisofs_v2_enabled= zisofs_ctrl.v2_enabled;
xorriso->zisofs_max_total_blocks=
xorriso->zisofs_max_total_blocks_default= zisofs_ctrl.max_total_blocks;
xorriso->zisofs_max_file_blocks=
xorriso->zisofs_max_file_blocks_default= zisofs_ctrl.max_file_blocks;
xorriso->zisofs_v2_block_size= xorriso->zisofs_v2_block_size_default=
1 << zisofs_ctrl.v2_block_size_log2;
}
iso_node_xinfo_make_clonable(Xorriso__mark_update_xinfo,

2
xorriso/opts_d_h.c

@ -2186,6 +2186,8 @@ int Xorriso_option_help(struct XorrisO *xorriso, int flag)
" -zisofs option[:options]",
" Set global zisofs parameters:",
" level=0|...|9 , block_size=32k|64k|128k , by_magic=on|off",
" version_2=off|as_needed|on , block_size_v2=32k|...|1024k",
" max_bpt=1k...128g , max_bpt_f=1k...128g",
"",
"Write-to-media commands:",
" -rollback Discard the manipulated ISO image and reload it.",

81
xorriso/opts_p_z.c

@ -2245,15 +2245,34 @@ int Xorriso_option_xattr(struct XorrisO *xorriso, char *mode, int flag)
}
static int parse_zisofs_param(char *cpt, int key_l, int l, double *num)
{
char text[16];
*num= 0.0;
if(l <= key_l || l >= key_l + 16)
return(0);
strncpy(text, cpt + key_l, l - key_l);
text[l - key_l]= 0;
*num= Scanf_io_size(text, 0);
return(1);
}
/* Option -zisofs */
int Xorriso_option_zisofs(struct XorrisO *xorriso, char *mode, int flag)
{
int was_level, was_blocksize, ret, l;
int was_level, was_blocksize, was_v2_enabled, was_blocksize_v2;
uint64_t was_max_total_blocks, was_max_file_blocks;
int ret, l, i;
double num;
char *cpt, *npt, text[16];
was_level= xorriso->zlib_level;
was_blocksize= xorriso->zisofs_block_size;
was_v2_enabled= xorriso->zisofs_v2_enabled;
was_max_total_blocks= xorriso->zisofs_max_total_blocks;
was_max_file_blocks= xorriso->zisofs_max_file_blocks;
was_blocksize_v2= xorriso->zisofs_v2_block_size;
npt= cpt= mode;
for(cpt= mode; npt!=NULL; cpt= npt+1) {
npt= strchr(cpt,':');
@ -2277,7 +2296,8 @@ int Xorriso_option_zisofs(struct XorrisO *xorriso, char *mode, int flag)
} else if(strncmp(cpt, "ziso_used=", 10) == 0 ||
strncmp(cpt, "osiz_used=", 10) == 0 ||
strncmp(cpt, "gzip_used=", 10) == 0 ||
strncmp(cpt, "gunzip_used=", 12) == 0) {
strncmp(cpt, "gunzip_used=", 12) == 0 ||
strncmp(cpt, "bpt_used=", 9) == 0) {
/* (ignored info from -status) */;
} else if(strncmp(cpt, "block_size=", 11)==0) {
@ -2294,16 +2314,67 @@ int Xorriso_option_zisofs(struct XorrisO *xorriso, char *mode, int flag)
}
xorriso->zisofs_block_size= num;
} else if(strncmp(cpt, "by_magic=", 8)==0) {
} else if(strncmp(cpt, "by_magic=", 9)==0) {
if(strncmp(cpt + 9, "on", l - 9) == 0)
xorriso->zisofs_by_magic= 1;
else
xorriso->zisofs_by_magic= 0;
} else if(strncmp(cpt, "version_2=", 10) == 0) {
if(strncmp(cpt + 10, "off", l - 10) == 0) {
xorriso->zisofs_v2_enabled= 0;
} else if(strncmp(cpt + 10, "as_needed", l - 11) == 0) {
xorriso->zisofs_v2_enabled= 1;
} else if(strncmp(cpt + 10, "on", l - 11) == 0) {
xorriso->zisofs_v2_enabled= 2;
} else {
sprintf(xorriso->info_text,
"-zisofs: Unrecognized version_2 mode (allowed: on, off, as_needed)");
goto sorry_ex;
}
} else if(strncmp(cpt, "max_bpt=", 8) == 0) {
parse_zisofs_param(cpt, 8, l, &num);
if(num < 1024.0 || num > 128.0 * 1024.0 * 1024.0 * 1024.0) {
sprintf(xorriso->info_text,
"-zisofs: Unsupported block pointer pool size (allowed: 1k to 128g)");
goto sorry_ex;
}
xorriso->zisofs_max_total_blocks= num / 8.0;
if(xorriso->zisofs_max_total_blocks < xorriso->zisofs_max_file_blocks)
xorriso->zisofs_max_file_blocks= xorriso->zisofs_max_total_blocks;
} else if(strncmp(cpt, "max_bpt_f=", 10) == 0) {
parse_zisofs_param(cpt, 10, l, &num);
if(num < 1024.0 || num > 128.0 * 1024.0 * 1024.0 * 1024.0) {
sprintf(xorriso->info_text,
"-zisofs: Unsupported block pointer list size (allowed: 1k to 128g)");
goto sorry_ex;
}
xorriso->zisofs_max_file_blocks= num / 8.0;
if(xorriso->zisofs_max_file_blocks > xorriso->zisofs_max_total_blocks)
xorriso->zisofs_max_total_blocks= xorriso->zisofs_max_file_blocks;
} else if(strncmp(cpt, "block_size_v2=", 14) == 0) {
parse_zisofs_param(cpt, 14, l, &num);
for(i= 15 ; i <= 20; i++)
if(num == (1 << i))
break;
if(i > 20) {
sprintf(xorriso->info_text,
"-zisofs: Unsupported block size (allowed 32k, 64k, 128k, ... 1024k)");
goto sorry_ex;
}
xorriso->zisofs_v2_block_size= num;
} else if(strncmp(cpt, "default", l)==0) {
xorriso->zlib_level= xorriso->zlib_level_default;
xorriso->zisofs_block_size= xorriso->zisofs_block_size_default;
xorriso->zisofs_by_magic= 0;
xorriso->zisofs_v2_enabled= 0;
xorriso->zisofs_max_total_blocks= xorriso->zisofs_max_total_blocks_default;
xorriso->zisofs_max_file_blocks= xorriso->zisofs_max_file_blocks_default;
xorriso->zisofs_v2_block_size= xorriso->zisofs_v2_block_size_default;
} else {
unknown_mode:;
@ -2315,6 +2386,10 @@ sorry_ex:
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
xorriso->zlib_level= was_level;
xorriso->zisofs_block_size= was_blocksize;
xorriso->zisofs_v2_enabled= was_v2_enabled;
xorriso->zisofs_max_total_blocks= was_max_total_blocks;
xorriso->zisofs_max_file_blocks= was_max_file_blocks;
xorriso->zisofs_v2_block_size= was_blocksize_v2;
return(0);
}
}

54
xorriso/xorriso.1

@ -9,7 +9,7 @@
.\" First parameter, NAME, should be all caps
.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
.\" other parameters are allowed: see man(7), man(1)
.TH XORRISO 1 "Version 1.5.3, Sep 30, 2020"
.TH XORRISO 1 "Version 1.5.3, Oct 14, 2020"
.\" Please adjust this date whenever revising the manpage.
.\"
.\" Some roff macros, for reference:
@ -3092,21 +3092,59 @@ User id to be used for all files when the new ISO tree gets written to media.
\fB\-gid\fR gid
Group id to be used for all files when the new ISO tree gets written to media.
.TP
\fB\-zisofs\fR option[:options]
\fB\-zisofs\fR parameter[:parameters]
Set global parameters for zisofs compression. This data format is recognized
and transparently uncompressed by some Linux kernels. It is to be applied
via command \-set_filter with built\-in filter "\-\-zisofs".
.br
Note: This command is only permitted while no \-\-zisofs filters are applied to
any files.
.br
Parameters are:
.br
"level="[0\-9] zlib compression: 0=none, 1=fast,..., 9=slow
.br
"block_size="32k|64k|128k size of compression blocks
"block_size="32k|64k|128k sets the size of version 1 compression blocks.
.br
"by_magic=on" enables an expensive test at image generation time which checks
files from disk whether they already are zisofs compressed, e.g. by program
mkzftree.
.br
"default" same as "level=6:block_size=32k:by_magic=off"
"version_2="off|as_needed|on enables the use of experimental version zisofs2
which can encode files of size 4 GiB or larger. The Linux kernel (as of 5.9)
does not yet know this format and will complain like
.br
isofs: Unknown ZF compression algorithm: PZ
.br
The files will then appear in their compressed form with zisofs2 header,
block pointer list, and compressed data.
.br
zisofs2 is recognized by xorriso in files from loaded images and gets equipped
with \-\-zisofs\-decode filters, unless restrictions on the number of
block pointers prevent this.
.br
Mode "off" restricts compression to files smaller than 4 GiB uncompressed size.
Mode "as_needed" uses zisofs2 for larger files. Mode "on" uses zisofs2 for all
zisofs compressed files.
.br
"block_size_v2="32k|64k|128k|256k|512k|1m sets the size of compression blocks
for zisofs2.
.br
"max_bpt="1k|...|128g sets the limit for the overall allocated block pointer
memory. Block pointers occupy virtual memory while a file gets uncompressed
and while a file, which shall be compressed, waits for ISO filesystem creation.
.br
One pointer occupies 8 bytes of memory and governs block_size or block_size_v2
uncompressed bytes.
I.e. with block size 128k, 1m of block pointer memory suffices for 16g of
uncompressed file size.
.br
"max_bpt_f="1k|...|128g sets the limit for the memory size of the block
pointer list of a single file. max_bpt_f is never larger than max_bpt.
If either is set to violate this rule, the other gets set to the same value.
.br
"default" same as "level=6:block_size=32k:by_magic=off:
version_2=off:block_size_v2=128k:max_bpt=256m:max_bpt_f=256m".
.TP
\fB\-speed\fR code|number[k|m|c|d|b]
Set the burn speed. Default is "max" (or "0") = maximum speed as announced
@ -4624,6 +4662,14 @@ Frequently used types are:
cout:'disk_path offset count' for \-cut_out files.
.br
extf:'filter_name' for external filters.
.br
\-\-zisofs:algorithm:block_size for zisofs compression filters.
.br
\-\-zisofs\-decode:algorithm:block_size for zisofs uncompression filters.
.br
\-\-gzip for internal gzip compression filters.
.br
\-\-gunzip for internal gzip uncompression filters.
.br
Example:
.br

6029
xorriso/xorriso.info

File diff suppressed because it is too large

54
xorriso/xorriso.texi

@ -50,7 +50,7 @@
@c man .\" First parameter, NAME, should be all caps
@c man .\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
@c man .\" other parameters are allowed: see man(7), man(1)
@c man .TH XORRISO 1 "Version 1.5.3, Sep 30, 2020"
@c man .TH XORRISO 1 "Version 1.5.3, Oct 14, 2020"
@c man .\" Please adjust this date whenever revising the manpage.
@c man .\"
@c man .\" Some roff macros, for reference:
@ -3603,23 +3603,61 @@ User id to be used for all files when the new ISO tree gets written to media.
@cindex Group, global in ISO image, -gid
Group id to be used for all files when the new ISO tree gets written to media.
@c man .TP
@item -zisofs option[:options]
@item -zisofs parameter[:parameters]
@kindex -zisofs controls zisofs production
@cindex Filter, zisofs parameters, -zisofs
Set global parameters for zisofs compression. This data format is recognized
and transparently uncompressed by some Linux kernels. It is to be applied
via command -set_filter with built-in filter "@minus{}@minus{}zisofs".
@*
Note: This command is only permitted while no --zisofs filters are applied to
any files.
@*
Parameters are:
@*
"level="[0-9] zlib compression: 0=none, 1=fast,..., 9=slow
@*
"block_size="32k|64k|128k size of compression blocks
"block_size="32k|64k|128k sets the size of version 1 compression blocks.
@*
"by_magic=on" enables an expensive test at image generation time which checks
files from disk whether they already are zisofs compressed, e.g. by program
mkzftree.
@*
"default" same as "level=6:block_size=32k:by_magic=off"
"version_2="off|as_needed|on enables the use of experimental version zisofs2
which can encode files of size 4 GiB or larger. The Linux kernel (as of 5.9)
does not yet know this format and will complain like
@*
isofs: Unknown ZF compression algorithm: PZ
@*
The files will then appear in their compressed form with zisofs2 header,
block pointer list, and compressed data.
@*
zisofs2 is recognized by xorriso in files from loaded images and gets equipped
with --zisofs-decode filters, unless restrictions on the number of
block pointers prevent this.
@*
Mode "off" restricts compression to files smaller than 4 GiB uncompressed size.
Mode "as_needed" uses zisofs2 for larger files. Mode "on" uses zisofs2 for all
zisofs compressed files.
@*
"block_size_v2="32k|64k|128k|256k|512k|1m sets the size of compression blocks
for zisofs2.
@*
"max_bpt="1k|...|128g sets the limit for the overall allocated block pointer
memory. Block pointers occupy virtual memory while a file gets uncompressed
and while a file, which shall be compressed, waits for ISO filesystem creation.
@*
One pointer occupies 8 bytes of memory and governs block_size or block_size_v2
uncompressed bytes.
I.e. with block size 128k, 1m of block pointer memory suffices for 16g of
uncompressed file size.
@*
"max_bpt_f="1k|...|128g sets the limit for the memory size of the block
pointer list of a single file. max_bpt_f is never larger than max_bpt.
If either is set to violate this rule, the other gets set to the same value.
@*
"default" same as "level=6:block_size=32k:by_magic=off:
version_2=off:block_size_v2=128k:max_bpt=256m:max_bpt_f=256m".
@c man .TP
@item -speed code|number[k|m|c|d|b]
@kindex -speed set write speed
@ -5333,6 +5371,14 @@ Frequently used types are:
cout:'disk_path offset count' for -cut_out files.
@*
extf:'filter_name' for external filters.
@*
--zisofs:algorithm:block_size for zisofs compression filters.
@*
--zisofs-decode:algorithm:block_size for zisofs uncompression filters.
@*
--gzip for internal gzip compression filters.
@*
--gunzip for internal gzip uncompression filters.
@*
Example:
@*

13
xorriso/xorriso_private.h

@ -2,7 +2,7 @@
/* Command line oriented batch and dialog tool which creates, loads,
manipulates and burns ISO 9660 filesystem images.
Copyright 2007-2019 Thomas Schmitt, <scdbackup@gmx.net>
Copyright 2007-2020 Thomas Schmitt, <scdbackup@gmx.net>
Provided under GPL version 2 or later.
@ -212,8 +212,8 @@ struct XorrisO { /* the global context of xorriso */
mode_t global_dir_mode;
mode_t global_file_mode;
int do_tao; /* 1= Use TAO resp. Incremental
-1= Use SAO resp. DAO
int do_tao; /* 1= Use TAO or Incremental
-1= Use SAO or DAO
0= let libburn choose */
struct Xorriso_lsT *filters;
@ -224,6 +224,13 @@ struct XorrisO { /* the global context of xorriso */
int zisofs_block_size;
int zisofs_block_size_default;
int zisofs_by_magic;
int zisofs_v2_enabled; /* 0=no, 1=as_needed, 2=force */
uint64_t zisofs_max_total_blocks;
uint64_t zisofs_max_total_blocks_default;
uint64_t zisofs_max_file_blocks;
uint64_t zisofs_max_file_blocks_default;
int zisofs_v2_block_size;
int zisofs_v2_block_size_default;
int do_overwrite; /* 0=off, 1=on, 2=nondir */
int do_reassure; /* 0=off, 1=on, 2=tree */

2
xorriso/xorriso_timestamp.h

@ -1 +1 @@
#define Xorriso_timestamP "2020.10.14.182119"
#define Xorriso_timestamP "2020.10.14.205904"

Loading…
Cancel
Save