int test_print_size ( int argc, char ** argv )
{
#if 1
u64 i = 0;
printf("%21llu |%s|%s| |%s|\t|%s|\n", i,
wd_print_size_1000(0,0,i,true),
wd_print_size_1024(0,0,i,true),
wd_print_size_1000(0,0,i,false),
wd_print_size_1024(0,0,i,false) );
for ( i = 1; i; i <<= 5 )
{
printf("%21llu |%s|%s| |%s|\t|%s|\n", i,
wd_print_size_1000(0,0,i,true),
wd_print_size_1024(0,0,i,true),
wd_print_size_1000(0,0,i,false),
wd_print_size_1024(0,0,i,false) );
}
u64 prev = 0;
for ( i = 1; i > prev; i *= 10 )
{
prev = i;
printf("%21llu |%s|%s| |%s|\t|%s|\n", i,
wd_print_size_1000(0,0,i,true),
wd_print_size_1024(0,0,i,true),
wd_print_size_1000(0,0,i,false),
wd_print_size_1024(0,0,i,false) );
}
i = ~(u64)0;
printf("%21llu |%s|%s| |%s|\t|%s|\n", i,
wd_print_size_1000(0,0,i,true),
wd_print_size_1024(0,0,i,true),
wd_print_size_1000(0,0,i,false),
wd_print_size_1024(0,0,i,false) );
#else
u64 size = 1000000000;
wd_size_mode_t mode;
for ( mode = 0; mode < WD_SIZE_N_MODES; mode++ )
printf("|%s|\t|%s|\t|%s|\t|%s|\t|%s|\t|%s|\n",
wd_get_size_unit(mode,"?"),
wd_print_size(0,0,size,true,mode|WD_SIZE_F_NO_UNIT),
wd_print_size(0,0,size,true,mode|WD_SIZE_F_1000),
wd_print_size(0,0,size,true,mode),
wd_print_size(0,0,size,false,mode|WD_SIZE_F_1000),
wd_print_size(0,0,size,false,mode) );
#endif
return 0;
}
static void print_val( ccp title, u64 val, ccp comment )
{
ccp t1000 = wd_print_size_1000(0,0,val,true);
ccp t1024 = wd_print_size_1024(0,0,val,true);
if (strcmp(t1000,t1024))
printf(" %-13s%16llx = %12lld = %s = %s%s\n",
title, val, val, t1024, t1000, comment ? comment : "" );
else
printf(" %-13s%16llx = %12lld%s\n",
title, val, val, comment ? comment : "" );
}
enumError cmd_test_options()
{
printf("Options (hex=dec):\n");
printf(" test: %16d\n",testmode);
printf(" verbose: %16d\n",verbose);
printf(" width: %16d\n",opt_width);
#if IS_WWT
print_val( "size:", opt_size, 0);
print_val( "hd sec-size:", opt_hss, 0);
print_val( "wb sec-size:", opt_wss, 0);
print_val( "repair-mode:", repair_mode, 0);
#elif defined(TEST)
u64 opt_size = 0;
#endif
snprintf(iobuf,sizeof(iobuf)," = %s",oft_info[output_file_type].name);
print_val( "output-mode:", output_file_type, iobuf );
SetupOptionsWDF();
if ( opt_wdf_version || opt_wdf_align || opt_wdf_min_holesize )
{
if ( use_wdf_version != opt_wdf_version )
snprintf(iobuf,sizeof(iobuf)," => use v%d",use_wdf_version);
else
*iobuf = 0;
print_val( "wdf-version:", opt_wdf_version, iobuf );
if ( use_wdf_align != opt_wdf_align )
snprintf(iobuf,sizeof(iobuf)," => use %x (%s)",
use_wdf_align, wd_print_size_1024(0,0,use_wdf_align,false) );
else
*iobuf = 0;
print_val( "align-wdf:", opt_wdf_align, iobuf );
print_val( "minhole-wdf", opt_wdf_min_holesize, 0 );
}
print_val( "chunk-mode:", opt_chunk_mode, 0 );
print_val( "chunk-size:", opt_chunk_size, force_chunk_size ? " FORCE!" : "" );
print_val( "max-chunks:", opt_max_chunks, 0 );
#ifdef TEST
{
u64 filesize[] = { 100ull*MiB, 1ull*GiB, 10ull*GiB, opt_size, 0 };
u64 *fs_ptr = filesize;
for (;;)
{
u32 n_blocks;
u32 block_size = CalcBlockSizeCISO(&n_blocks,*fs_ptr);
printf(" CISO block size %12llx = %12lld -> %5u * %8x/hex == %12llx/hex\n",
*fs_ptr, *fs_ptr, n_blocks, block_size,
(u64)block_size * n_blocks );
if (!*++fs_ptr)
break;
}
}
#endif
printf(" auto-split: %16x = %12d\n",opt_auto_split,opt_auto_split);
printf(" split: %16x = %12d\n",opt_split,opt_split);
print_val( "split-size:", opt_split_size, 0 );
printf(" compression: %16x = %12d = %s (level=%d)\n",
opt_compr_method, opt_compr_method,
wd_get_compression_name(opt_compr_method,"?"), opt_compr_level );
printf(" level: %16x = %12d\n",opt_compr_level,opt_compr_level);
print_val( " chunk-size:", opt_compr_chunk_size, 0 );
print_val( "mem:", opt_mem, 0 );
GetMemLimit();
print_val( "mem limit:", opt_mem, 0 );
printf(" escape-char: %16x = %12d\n",escape_char,escape_char);
printf(" print-time: %16x = %12d\n",opt_print_time,opt_print_time);
printf(" sort-mode: %16x = %12d\n",sort_mode,sort_mode);
printf(" show-mode: %16x = %12d\n",opt_show_mode,opt_show_mode);
printf(" unit: %16x = %12d, unit=%s\n",
opt_unit, opt_unit, wd_get_size_unit(opt_unit,"?") );
printf(" limit: %16x = %12d\n",opt_limit,opt_limit);
#if IS_WIT
printf(" file-limit: %16x = %12d\n",opt_file_limit,opt_file_limit);
printf(" block-size: %16x = %12d\n",opt_block_size,opt_block_size);
#endif
printf(" gcz-block: %16x = %12d\n",opt_gcz_block_size,opt_gcz_block_size);
printf(" rdepth: %16x = %12d\n",opt_recurse_depth,opt_recurse_depth);
printf(" enc: %16x = %12d\n",encoding,encoding);
printf(" region: %16x = %12d\n",opt_region,opt_region);
printf(" prealloc: %16x = %12d\n",prealloc_mode,prealloc_mode);
if (opt_ios_valid)
{
const u32 hi = opt_ios >> 32;
const u32 lo = (u32)opt_ios;
if ( hi == 1 && lo < 0x100 )
printf(" ios: %08x-%08x = IOS %u\n", hi, lo, lo );
else
printf(" ios: %08x-%08x\n", hi, lo );
}
printf(" modify: %16x = %12d\n",opt_modify,opt_modify);
if (modify_name)
printf(" modify name: '%s'\n",modify_name);
if (modify_id)
printf(" modify id: '%s'\n",modify_id);
if (modify_disc_id)
printf(" modify disc id: '%s'\n",modify_disc_id);
if (modify_boot_id)
printf(" modify boot id: '%s'\n",modify_boot_id);
if (modify_ticket_id)
printf(" modify ticket id: '%s'\n",modify_ticket_id);
if (modify_tmd_id)
printf(" modify tmd id: '%s'\n",modify_tmd_id);
if (modify_wbfs_id)
printf(" modify wbfs id: '%s'\n",modify_wbfs_id);
if ( opt_http || opt_domain )
{
printf(" http: %s\n", opt_http ? "enabled" : "disabled" );
printf(" domain: '%s'\n",opt_domain);
}
#if IS_WWT
char buf_set_time[20];
if (opt_set_time)
{
struct tm * tm = localtime(&opt_set_time);
strftime(buf_set_time,sizeof(buf_set_time),"%F %T",tm);
}
else
strcpy(buf_set_time,"NULL");
printf(" set-time: %16llx = %12lld = %s\n",
(u64)opt_set_time, (u64)opt_set_time,buf_set_time );
#endif
printf(" trim: %16x = %12u\n",opt_trim,opt_trim);
print_val( "align #1:", opt_align1, 0 );
print_val( "align #2:", opt_align2, 0 );
print_val( "align #3:", opt_align3, 0 );
print_val( "align-part:", opt_align_part, 0 );
print_val( "disc-size:", opt_disc_size, 0 );
printf(" partition selector:\n");
wd_print_select(stdout,6,&part_selector);
return ERR_OK;
}
enumError cmd_compr()
{
const bool have_param = n_param > 0;
if (!n_param)
{
int i;
for ( i = 0; i < WD_COMPR__N; i++ )
AddParam(wd_get_compression_name(i,0),false);
if (long_count)
{
AddParam(" DEFAULT",false);
AddParam(" FAST",false);
AddParam(" GOOD",false);
AddParam(" BEST",false);
AddParam(" MEM",false);
char buf[2] = {0,0};
for ( i = '0'; i <= '9'; i++ )
{
buf[0] = i;
AddParam(buf,true);
}
}
}
int err_count = 0;
if (print_sections)
{
if (!have_param)
{
printf( "\n[compression-modes]\n"
"n-methods=%u\n", WD_COMPR__N );
print_default_compr("default");
print_default_compr("fast");
print_default_compr("good");
print_default_compr("best");
print_default_compr("mem");
}
int index = 0;
ParamList_t * param;
for ( param = first_param; param; param = param->next, index++ )
{
int level;
u32 csize;
wd_compression_t compr = ScanCompression(param->arg,true,&level,&csize);
printf( "\n[compression-mode-%u]\n"
"input=%s\n"
"num=%d\n"
"name=%s\n",
index, param->arg,
compr, wd_get_compression_name(compr,"-") );
if ( compr == (wd_compression_t)-1 )
err_count++;
else
{
CalcDefaultSettingsWIA(&compr,&level,&csize);
if ( level > 0 )
printf("level=%u\n",level);
if ( csize > 0 )
printf("chunk-factor=%u\nchunk-size=%u\n",
csize/WIA_BASE_CHUNK_SIZE, csize );
#ifdef NO_BZIP2
if ( compr == WD_COMPR_BZIP2 )
fputs("not-supported=1\n",stdout);
#endif
}
}
putchar('\n');
}
else if (long_count)
{
const bool print_header = !OptionUsed[OPT_NO_HEADER];
if (print_header)
printf( "\n"
" mode memory usage\n"
" %s reading writing input mode\n"
"---------------------------------------------\n",
OptionUsed[OPT_NUMERIC] ? "num " : "name" );
const int mode = OptionUsed[OPT_NUMERIC] ? 1 : 2;
ParamList_t * param;
for ( param = first_param; param; param = param->next )
{
int level;
u32 csize;
wd_compression_t compr = ScanCompression(param->arg,true,&level,&csize);
if ( verbose > 0 )
{
wd_compression_t compr2 = compr;
CalcDefaultSettingsWIA(&compr2,&level,&csize);
}
if ( compr == (wd_compression_t)-1 )
{
err_count++;
printf(" - - - %s\n",param->arg);
}
else
{
u32 read_size = CalcMemoryUsageWIA(compr,level,csize,false);
u32 write_size = CalcMemoryUsageWIA(compr,level,csize,true);
printf(" %-11s %s %s %.30s\n",
wd_print_compression(0,0,compr,level,csize,mode),
wd_print_size_1024(0,0,read_size,true),
wd_print_size_1024(0,0,write_size,true),
param->arg );
}
}
if (print_header)
putchar('\n');
}
else
{
const int mode = OptionUsed[OPT_NUMERIC] ? 1 : 2;
ParamList_t * param;
for ( param = first_param; param; param = param->next )
{
int level;
u32 csize;
wd_compression_t compr = ScanCompression(param->arg,true,&level,&csize);
if ( verbose > 0 )
{
wd_compression_t compr2 = compr;
CalcDefaultSettingsWIA(&compr2,&level,&csize);
}
#ifdef NO_BZIP2
if ( !have_param && compr == WD_COMPR_BZIP2 )
continue; // ignore it
#endif
if ( compr == (wd_compression_t)-1 )
err_count++;
printf("%s\n",wd_print_compression(0,0,compr,level,csize,mode));
}
}
return err_count ? ERR_WARNING : ERR_OK;
}
