diff --git a/xorriso/xorriso.1 b/xorriso/xorriso.1 index d55daf0f..c302188f 100644 --- a/xorriso/xorriso.1 +++ b/xorriso/xorriso.1 @@ -1260,24 +1260,27 @@ comparable actions in said programs. \fB\-as\fR personality option [options] -- .br Performs its variable length option list as sparse emulation of the program -depicted by personality. +depicted by the personality word. .br Personality "\fBcdrecord\fR" accepts the options listed with: .br -as cdrecord -help -- .br -Among them: dev=, speed=, blank=, fs=, -eject, -atip, padsize=, -one track source file path or "-" for standard input as track source. +Among them: -v, dev=, speed=, blank=, fs=, -eject, -atip, padsize=, +track source file path or "-" for standard input as track source. .br It ignores most other options of cdrecord and cdrskin but refuses on --audio, -scanbus and on blank modes unknown to xorriso. +-audio, -scanbus, -multi, -msinfo, --grow_overwriteable_iso, +and on blanking modes unknown to xorriso. .br The scope is for now a single data track to be written to blank or overwriteable media. If possible the media will get closed afterwards. +dev= must be given as xorriso device address. Adresses like 0,0,0 or ATA:1,1,0 +are not supported. .br -Personality "\fBcdrskin\fR" is an alias for "cdrecord". +A much more elaborate libburn based cdrecord emulator is the program cdrskin. .br -Personality "\fBwodim\fR" is an alias for "cdrecord". +Personalites "\fBwodim\fR" and "\fBcdrskin\fR" are aliases for "cdrecord". .TP .B Scripting, dialog and program control features: .TP diff --git a/xorriso/xorriso.c b/xorriso/xorriso.c index 69834574..a71ce486 100644 --- a/xorriso/xorriso.c +++ b/xorriso/xorriso.c @@ -2746,6 +2746,7 @@ int Xorriso_new(struct XorrisO ** xorriso,char *progname, int flag) m->pacifier_interval= 1.0; m->pacifier_count= 0; m->pacifier_total= 0; + m->pacifier_fifo= NULL; m->start_time= 0.0; m->last_update_time= 0.0; m->result_line[0]= 0; @@ -6103,7 +6104,9 @@ int Xorriso_cdrskin(struct XorrisO *xorriso, char *whom, int argc, char **argv, "drive_scsi_dev_family=", "fallback_program=", "modesty_on_drive=", "tao_to_sao_tsize=", - "direct_write_amount=", "write_start_address=", "msifile=", "tsize=", + "direct_write_amount=", "write_start_address=", "msifile=", + + "tsize=", "" }; @@ -6125,7 +6128,7 @@ int Xorriso_cdrskin(struct XorrisO *xorriso, char *whom, int argc, char **argv, "--list_ignored_options", "--no_rc", "--no_convert_fs_adr", "--prodvd_cli_compatible", "--single_track", - "--grow_overwriteable_iso", "--help", "--tell_media_space", + "--tell_media_space", "" }; @@ -6135,6 +6138,7 @@ int Xorriso_cdrskin(struct XorrisO *xorriso, char *whom, int argc, char **argv, "Note: This is not cdrecord. See xorriso -help, xorriso -version, man xorriso", "Options:", "\t-version\tprint version information and exit emulation", +"\t--devices\tprint list of available MMC drives and exit emulation", "\tdev=target\tpseudo-SCSI target to use as CD-Recorder", "\t-v\t\tincrement verbose level by one", "\t-checkdrive\tcheck if a driver for the drive is present", @@ -6149,7 +6153,8 @@ int Xorriso_cdrskin(struct XorrisO *xorriso, char *whom, int argc, char **argv, "\t-data\t\tSubsequent tracks are CD-ROM data mode 1 (default)", "\t-pad\t\tpadsize=30k", "\t-nopad\t\tDo not pad", -"\t-help\t\tprint this text to stderr and exit", +"\t-help\t\tprint this text to stderr and exit emulation", +"\t--help\t\tprint xorriso help and exit emulation", "Actually this is the integrated ISO RockRidge filesystem manipulator xorriso", "lending its libburn capabilities to a very limited cdrecord emulation.", "Only a single data track can be burnt to blank or overwriteable media which", @@ -6295,6 +6300,12 @@ no_volunteer:; /* do_scanbus= 1; */ } else if(strcmp(argv[i], "-toc")==0) { do_toc= 1; + } else if(strcmp(argv[i], "--grow_overwriteable_iso")==0) { + sprintf(xorriso->info_text, + "-as %s: Option --grow_overwriteable_iso not supported.", + whom); + Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0); + ret= 0; goto ex; } else if(strcmp(argv[i], "-v")==0 || strcmp(argv[i],"-verbose")==0) { do_verbous++; } else if(strcmp(argv[i], "-vv")==0) { @@ -6305,6 +6316,8 @@ no_volunteer:; do_version= 1; } else if(strcmp(argv[i], "-help")==0) { do_help= 1; + } else if(strcmp(argv[i], "--help")==0) { + do_help= 2; } else if(argv[i][0]=='-' && argv[i][1]!=0) { sprintf(xorriso->info_text, "-as %s: Unknown option %s", whom, Text_shellsafe(argv[i], sfe, 0)); @@ -6334,9 +6347,13 @@ no_volunteer:; ret= 1; goto ex; } if(do_help) { - for(i= 0; strcmp(helptext[i], "@End_of_helptexT@")!=0; i++) { - sprintf(xorriso->info_text, "%s\n", helptext[i]); - Xorriso_info(xorriso,0); + if(do_help==2) { + Xorriso_option_help(xorriso, 0); + } else { + for(i= 0; strcmp(helptext[i], "@End_of_helptexT@")!=0; i++) { + sprintf(xorriso->info_text, "%s\n", helptext[i]); + Xorriso_info(xorriso,0); + } } ret= 1; goto ex; } @@ -7927,6 +7944,11 @@ int Xorriso_option_help(struct XorrisO *xorriso, int flag) " -findx disk_path [-name pattern] like -find but in local filesystem.", " Any -exec option is ignored. Action is always echo.", "", +"Compatibility emulation (argument list may be ended by --):", +" -as cdrecord [-help|-v|dev=|speed=|blank=|fs=|-eject|-atip|padsize=|path|-]", +" Perform some cdrecord gestures, eventually write at most one", +" data track to blank or overwriteable media. See man cdrecord.", +"", "General options:", " -help Print this text", " -abort_on severity Set the threshhold for events to abort the program.", diff --git a/xorriso/xorriso_private.h b/xorriso/xorriso_private.h index ab0b893e..5a279d3c 100644 --- a/xorriso/xorriso_private.h +++ b/xorriso/xorriso_private.h @@ -210,6 +210,8 @@ struct XorrisO { /* the global context of xorriso */ off_t pacifier_count; off_t pacifier_total; + void *pacifier_fifo; + /* result (stdout, R: ) */ char result_line[5*SfileadrL]; int result_line_counter; diff --git a/xorriso/xorriso_timestamp.h b/xorriso/xorriso_timestamp.h index 0ab5e2d7..aad3e3f5 100644 --- a/xorriso/xorriso_timestamp.h +++ b/xorriso/xorriso_timestamp.h @@ -1 +1 @@ -#define Xorriso_timestamP "2008.02.19.184432" +#define Xorriso_timestamP "2008.02.19.212322" diff --git a/xorriso/xorrisoburn.c b/xorriso/xorrisoburn.c index 704ba3c7..6f6dd03f 100644 --- a/xorriso/xorrisoburn.c +++ b/xorriso/xorrisoburn.c @@ -56,7 +56,7 @@ #endif /* Xorriso_standalonE */ -int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive, +int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive, int flag); int Xorriso__read_pacifier(IsoImage *image, IsoFileSource *filesource); @@ -1065,36 +1065,82 @@ int Xorriso_check_burn_abort(struct XorrisO *xorriso, int flag) /* This loop watches burn runs until they end. It issues pacifying update messages to the user. + @param flag bit0-3 = emulation mode + 0= xorriso + 1= cdrskin + bit4= report speed in CD units */ int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive, int flag) { - int ret, size, free_bytes, i, aborting= 0; + int ret, size, free_bytes, i, aborting= 0, emul, buffer_fill= 50, last_sector; struct burn_progress progress; char *status_text; enum burn_drive_status drive_status; - double start_time, current_time; + double start_time, current_time, last_time; + double measured_speed, speed_factor= 1385000; start_time= Sfile_microtime(0); while(burn_drive_get_status(drive, NULL) == BURN_DRIVE_SPAWNING) usleep(100002); + emul= flag&15; + if(flag&16) + speed_factor= 150.0*1024; + progress.sector= 0; + current_time= Sfile_microtime(0); while(1) { + last_time= current_time; + last_sector= progress.sector; drive_status= burn_drive_get_status(drive, &progress); if(drive_status == BURN_DRIVE_IDLE) break; - current_time= Sfile_microtime(0); + current_time= Sfile_microtime(0); if(drive_status == BURN_DRIVE_WRITING && progress.sectors > 0) { - if(progress.sector<=progress.sectors) - sprintf(xorriso->info_text, "Writing: sector %d of %d", - progress.sector, progress.sectors); - else - sprintf(xorriso->info_text, "Writing: sector %d", progress.sector); - ret= isoburn_get_fifo_status(drive, &size, &free_bytes, &status_text); - if(ret>0 ) - sprintf(xorriso->info_text+strlen(xorriso->info_text), - " [fifo %s, %2d%% fill]", status_text, - (int) (100.0-100.0*((double) free_bytes)/(double) size)); + if(emul==1) { + if(progress.sector<=progress.sectors) + sprintf(xorriso->info_text, "%4d of %4d MB written", + progress.sector / 512, progress.sectors / 512); + else + sprintf(xorriso->info_text, "%4d MB written", + progress.sector / 512); + + if(xorriso->pacifier_fifo!=NULL) { + ret= burn_fifo_inquire_status(xorriso->pacifier_fifo, + &size, &free_bytes, &status_text); + if(ret>0 ) + sprintf(xorriso->info_text+strlen(xorriso->info_text), + " (fifo %2d%%)", + (int) (100.0-100.0*((double) free_bytes)/(double) size)); + } + + buffer_fill= 50; + if(progress.buffer_capacity>0) + buffer_fill= (double) (progress.buffer_capacity + - progress.buffer_available) * 100.0 + / (double) progress.buffer_capacity; + sprintf(xorriso->info_text+strlen(xorriso->info_text), " [buf %3d%%]", + buffer_fill); + + if(current_time-last_time>0.2) { + measured_speed= (progress.sector - last_sector) * 2048.0 / + (current_time - last_time); + sprintf(xorriso->info_text+strlen(xorriso->info_text), " %4.1fx.", + measured_speed/speed_factor); + } + + } else { + if(progress.sector<=progress.sectors) + sprintf(xorriso->info_text, "Writing: sector %d of %d", + progress.sector, progress.sectors); + else + sprintf(xorriso->info_text, "Writing: sector %d", progress.sector); + ret= isoburn_get_fifo_status(drive, &size, &free_bytes, &status_text); + if(ret>0 ) + sprintf(xorriso->info_text+strlen(xorriso->info_text), + " [fifo %s, %2d%% fill]", status_text, + (int) (100.0-100.0*((double) free_bytes)/(double) size)); + } } else if(drive_status == BURN_DRIVE_CLOSING_SESSION || drive_status == BURN_DRIVE_CLOSING_TRACK) sprintf(xorriso->info_text, @@ -3937,7 +3983,7 @@ int Xorriso_atip(struct XorrisO *xorriso, int flag) int Xorriso_burn_track(struct XorrisO *xorriso, char *track_source, int flag) { - int ret, fd, unpredicted_size; + int ret, fd, unpredicted_size, profile_number, is_cd= 0; struct burn_drive_info *dinfo; struct burn_drive *drive; struct burn_write_opts *burn_options; @@ -3948,7 +3994,7 @@ int Xorriso_burn_track(struct XorrisO *xorriso, char *track_source, int flag) off_t fixed_size= 0; struct burn_source *data_src, *fifo_src; enum burn_disc_status disc_state; - char reasons[BURN_REASONS_LEN], sfe[5*SfileadrL]; + char reasons[BURN_REASONS_LEN], sfe[5*SfileadrL], profile_name[80]; ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive, @@ -3994,6 +4040,7 @@ int Xorriso_burn_track(struct XorrisO *xorriso, char *track_source, int flag) Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); ret= 0; goto ex; } + xorriso->pacifier_fifo= fifo_src; if(burn_track_set_source(track, fifo_src)!=BURN_SOURCE_OK) { sprintf(xorriso->info_text, "Cannot attach source object to track object"); @@ -4042,6 +4089,8 @@ int Xorriso_burn_track(struct XorrisO *xorriso, char *track_source, int flag) ret= 0; goto ex; } + ret= Xorriso_get_profile(xorriso, &profile_number, profile_name, 2); + is_cd= (ret==2); if(isoburn_needs_emulation(drive)) burn_write_opts_set_start_byte(burn_options, (off_t) 0); ret= Xorriso_sanitize_image_size(xorriso, drive, disc, burn_options, 2); @@ -4051,7 +4100,7 @@ int Xorriso_burn_track(struct XorrisO *xorriso, char *track_source, int flag) xorriso->run_state= 1; /* Indicate that burning has started */ burn_disc_write(burn_options, disc); - ret= Xorriso_pacifier_loop(xorriso, drive, 0); + ret= Xorriso_pacifier_loop(xorriso, drive, 1|(is_cd<<4)); if(ret<=0) goto ex; if(!burn_drive_wrote_well(drive)) { @@ -4069,6 +4118,9 @@ ex:; Xorriso_process_msg_queues(xorriso,0); if(disc!=NULL) burn_disc_free(disc); + if(xorriso->pacifier_fifo!=NULL) + burn_source_free(xorriso->pacifier_fifo); + xorriso->pacifier_fifo= NULL; xorriso->run_state= 0; /* Indicate that burning has ended */ return(ret); }