Implemented options -outdev and -indev

test/xorriso.1

@@ -45,7 +45,8 @@ Renames or deletes file objects in the ISO image.
 .br
 Changes file properties in the ISO image.
 .br
- > Can write result as completely new image to optical media or filesystem objects.
+Can write result as completely new image to optical media or
+filesystem objects.
 .br
 Can write result as add-on session to appendable multi-session media, 
 to overwriteable media, to regular files, and to block devices.
@@ -98,19 +99,11 @@ MMC media like DVD-RAM, DVD+RW, formatted DVD-RW, and of course not to disk
 files or non-CD/DVD block devices.
 Program growisofs by Andy Polyakov showed how to extend this functionality
 to overwriteable media or disk files which carry valid ISO 9660 filesystems.
-These two expansion methods are referred as "growing" in this text.
+These two expansion methods are referred as \fBgrowing\fR in this text.
-.PP
+.br
-xorriso provides growing as well as an own method which produces a completely
+xorriso provides both ways of growing as well as an own method which produces
- > new ISO image from the old one and the modifications. This unique xorriso
+a completely new ISO image from the old one and the modifications.
- > method produces compact filesystem images with no waste by outdated data blocks
+See below.
- > and it can write modified images to targets which are completely unsuitable
- > for multi-session operations. E.g. fast blanked DVD-RW, named pipes,
- > character devices, sockets.
- > Therefore this method is called "modifying". Its drawback is that the target
- > cannot be the same media which holds the unmodified ISO image but that this
- > media has to be present while the new image gets written to another media.
- > So typically one needs either two optical drives or has to work with
- > filesystem objects as source and/or target media.
 .PP
 xorriso adopts the concept of session by loading an eventual image directory
 tree, allowing to manipulate it by several actions, and to write the new
@@ -131,6 +124,18 @@ session.
 .br
 In some special situations (e.g. in a file-to-file situation) it can be
 useful to store intermediate states and to continue with image manipulations.
+.PP
+The unique xorriso method of \fBmodifying\fR produces compact filesystem
+images with no waste by outdated data blocks and it can write modified images
+to target media which are completely unsuitable for multi-session operations.
+E.g. fast blanked DVD-RW, named pipes, character devices, sockets.
+It is important to note that modified sessions can be written to blank
+media only.
+.br
+Modifying takes place whenever input drive and output drive are not the same.
+See options -dev, -indev, -outdev.
+So for this method one needs either two optical drives or has to work with
+filesystem objects as source and/or target media.
 .SS
 .B Libburn drives:
 .br
@@ -239,21 +244,34 @@ Options with prefix '?' are not tested yet.
 .B Aquiring source and target drive:
 .TP
 \fB\-dev\fR address
-Set input and output drive and load eventual ISO image.
+Set input and output drive to the same address and load eventual ISO image.
+If there is no ISO image then create a blank one.
 Set the image expansion method to growing.
-Only allowed as long as no ISO image was loaded and
+.br
-altered, or after actions -rollback, or -commit.
+This is only allowed as long as no changes are pending in the currently
+loaded ISO image. Eventually  one has to perform -commit or -rollback first.
 Violation yields a SORRY event.
 .br
 An empty address string gives up the current device
 without aquiring a new one.
 .TP
-> \fB\-indev\fR address
+\fB\-indev\fR address
-Set input drive and load eventual ISO image. Switch from
+Set input drive and load eventual ISO image. If the new input drive differs
-growing to modifying. Same restrictions as with -dev
+from outdev then switch from growing to modifying. The same rules and
+restrictions apply as with -dev.
 .TP
-> \fB\-outdev\fR address
+\fB\-outdev\fR address
-Set output drive and switch from growing to modifying.
+Set output drive and if it differs from the input drive then switch from
+growing to modifying. Unlike -dev and -indev this action does not load a
+new ISO image. So it can be performed even if there are pending changes.
+.br
+-outdev can be performed without previous -dev or -indev. In that case an
+empty ISO image with no changes pending is created. It can either be populated
+by help of -add or it can be discarded silently if -dev or -indev are
+performed afterwards.
+.br
+An empty address string gives up the current output drive
+without aquiring a new one. No writing is possible without an output drive.
 .TP
 \fB\-ban_stdio_write\fR
 Allow for writing only the usage of optical drives. Disallow
@@ -330,7 +348,7 @@ Delete the given files from the ISO image.
 Note: This does not free any space on the -indev media, even if
 the deletion is committed to that same media.
 .br
-> The image size will shrink if the image is written to a different
+The image size will shrink if the image is written to a different
 media in modification mode.
 .TP
 \fB\-rm_r\fR iso_rr_path [***]
@@ -847,7 +865,7 @@ enter option and arguments :
 .br
 enter option and arguments :
 .br
-.B \-commit -eject -end
+.B \-commit -eject all -end
 .br
 .SS
 .B Modifying an existing ISO image
@@ -870,7 +888,7 @@ Add new directory tree /movies. Burn to DVD and eject.
  /movies=/home/me/prepared_for_dvd/movies \\
  -- \\
  -commit \\
- -eject
+ -eject all
 .SS
 .B Examples of input timestrings
 .br

test/xorriso.c

@@ -4322,15 +4322,10 @@ int Xorriso_option_commit(struct XorrisO *xorriso, int flag)
    Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
    return(2);
  }
-
+ ret= Xorriso_write_session(xorriso, 0);
- /* >>> care for modifying */
-
- ret= Xorriso_write_growing(xorriso, 0);
  if(ret<=0)
    return(ret);
-
  xorriso->volset_change_pending= 0;
-
  if(flag&1)
    return(1);
  strcpy(newdev, xorriso->outdev);
@@ -4387,14 +4382,17 @@ int Xorriso_option_dev(struct XorrisO *xorriso, char *adr, int flag)
    return(0);
  }
 
+#ifdef NIX
  if((flag&3)==0 || xorriso->in_drive_handle == xorriso->out_drive_handle)
    flag|= 3;
+
  if((flag&3)!=3) {
    /* <<< for now only -dev */;
    fprintf(stderr, ">>> XORRISO : would execute -%sdev %s\n",
            ((flag&3)==1 ? "in" : ((flag&3)==2 ? "out" : "")), adr);
    return(1);
  }
+#endif
 
  if(xorriso->volset_change_pending && (flag&1)) {
    sprintf(xorriso->info_text,
@@ -5378,10 +5376,7 @@ int Xorriso_option_print_size(struct XorrisO *xorriso, int flag)
    Xorriso_result(xorriso,0);
    return(2);
  }
-
+ ret= Xorriso_write_session(xorriso, 1);
- /* >>> care for modifying */
-
- ret= Xorriso_write_growing(xorriso, 1);
  if(ret<=0) {
    sprintf(xorriso->info_text,"-print-size: Failed to set up virtual -commit");
    Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
@@ -5559,7 +5554,7 @@ int Xorriso_option_rollback(struct XorrisO *xorriso, int flag)
 
  if(Sfile_str(indev, xorriso->indev, 0)<=0)
    return(-1);
- ret= Xorriso_give_up_drive(xorriso, 1);
+ ret= Xorriso_give_up_drive(xorriso, 1|8);
  if(ret<=0)
    return(ret);
  ret= Xorriso_option_dev(xorriso, indev,
@@ -5657,7 +5652,7 @@ int Xorriso_option_tell_media_space(struct XorrisO *xorriso, int flag)
  int ret, free_space= 0, media_space= 0;
 
  ret= Xorriso_tell_media_space(xorriso, &media_space, &free_space, 0);
- if(ret<0) {
+ if(ret<=0) {
    sprintf(xorriso->info_text, "Cannot -tell_media_space");
    Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
    return(0);
@@ -5697,9 +5692,23 @@ int Xorriso_option_temp_mem_limit(struct XorrisO *xorriso, char *size,
 /* Option -toc */
 int Xorriso_option_toc(struct XorrisO *xorriso, int flag)
 {
- int ret;
+ int ret, in_ret= 1000;
 
- ret= Xorriso_toc(xorriso, 0);
+ if(strcmp(xorriso->indev,xorriso->outdev)==0)
+   ret= Xorriso_toc(xorriso, 0);
+ else {
+   if(xorriso->indev[0]!=0)
+     in_ret= Xorriso_toc(xorriso, 0);
+   if(xorriso->indev[0]!=0 && xorriso->outdev[0]!=0) {
+     strcpy(xorriso->result_line, "-------------: ---------------------------------------------------------------\n");
+     Xorriso_result(xorriso,0);
+   }
+   ret= 1;
+   if(xorriso->outdev[0]!=0)
+     ret= Xorriso_toc(xorriso, 2);
+   if(in_ret<ret)
+     ret= in_ret;
+ }
  return(ret);
 }
 
@@ -5977,7 +5986,7 @@ next_command:;
 
  } else if(strcmp(cmd,"-outdev")==0) {
    (*idx)++;
-   ret= Xorriso_option_dev(xorriso, arg1, 1);
+   ret= Xorriso_option_dev(xorriso, arg1, 2);
 
  } else if(strcmp(cmd,"-page")==0) {
    (*idx)+= 2;

test/xorriso_timestamp.h

@@ -1 +1 @@
-#define Xorriso_timestamP "2007.11.14.142904"
+#define Xorriso_timestamP "2007.11.14.143119"

test/xorrisoburn.c

@@ -127,7 +127,8 @@ int Xorriso_get_drive_handles(struct XorrisO *xorriso,
    *dinfo= (struct burn_drive_info *) xorriso->in_drive_handle;
  if(*dinfo==NULL) {
    Xorriso_process_msg_queues(xorriso,0);
-   sprintf(xorriso->info_text, "No drive aquired %s", attempt);
+   sprintf(xorriso->info_text, "No %s drive aquired %s",
+           (flag&2 ? "output" : "input"), attempt);
    Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
    return(0);
  }
@@ -136,83 +137,177 @@ int Xorriso_get_drive_handles(struct XorrisO *xorriso,
 }
 
 
+int Xorriso_create_empty_iso(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+ struct iso_volset *volset;
+ struct isoburn_read_opts ropts;
+ struct burn_drive_info *dinfo= NULL;
+ struct burn_drive *drive= NULL;
+
+ if(xorriso->out_drive_handle != NULL) {
+   ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                  "on attempt to attach volset to drive", 2);
+   if(ret<=0)
+     return(ret);
+ }
+ if(xorriso->in_volset_handle!=NULL) {
+   iso_volset_free((struct iso_volset *) xorriso->in_volset_handle);
+   xorriso->in_volset_handle= NULL;
+   xorriso->volset_change_pending= 0;
+ }
+ memset(&ropts, sizeof(ropts), 0);
+ ropts.pretend_blank= 1;
+ ret= isoburn_read_volset(drive, &ropts, &volset);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(ret<=0) {
+   sprintf(xorriso->info_text, "Failed to create new empty ISO image object");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+ xorriso->in_volset_handle= volset;
+ xorriso->volset_change_pending= 0;
+ return(1);
+}
+
+
 /* @param flag bit0=aquire as isoburn input drive
                bit1=aquire as libburn output drive (as isoburn drive if bit0)
+   @return <=0 failure , 1= ok
+           2=success, but not writeable with bit1
+           3=success, but not blank and not ISO with bit0
 */
 int Xorriso_aquire_drive(struct XorrisO *xorriso, char *adr, int flag)
 {
- int ret;
+ int ret, hret, not_writeable= 0;
- struct burn_drive_info *dinfo= NULL;
+ struct burn_drive_info *dinfo= NULL, *out_dinfo, *in_dinfo;
- struct burn_drive *drive;
+ struct burn_drive *drive, *out_drive, *in_drive;
  enum burn_disc_status state;
  struct iso_volset *volset;
  struct isoburn_read_opts ropts;
 
-
+ if((flag&3)==0) { 
- if((flag&3)!=3) { 
    sprintf(xorriso->info_text, 
          "XORRISOBURN program error : Xorriso_aquire_drive bit0+bit1 not set");
    Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
    return(0);
  }
- ret= Xorriso_give_up_drive(xorriso, flag&3);
+ ret= Xorriso_give_up_drive(xorriso, (flag&3)|8);
  if(ret<=0)
    return(ret);
 
- ret= isoburn_drive_scan_and_grab(&dinfo, adr, 1);
+ if((flag&3)==1 && xorriso->out_drive_handle!=NULL) {
- Xorriso_process_msg_queues(xorriso,0);
+   ret= Xorriso_get_drive_handles(xorriso, &out_dinfo, &out_drive,
- if(ret<=0) {
+                         "on attempt to compare new indev with outdev", 2);
-   sprintf(xorriso->info_text,"Cannot aquire drive '%s'", adr); 
+   if(ret<=0)
-   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     goto ex;
-   return(0);
+   ret= burn_drive_equals_adr(out_drive, adr, 1);
+   if(ret==1)
+     dinfo= out_dinfo;
+ } else if((flag&3)==2 && xorriso->in_drive_handle!=NULL) {
+   ret= Xorriso_get_drive_handles(xorriso, &in_dinfo, &in_drive,
+                         "on attempt to compare new indev with outdev", 0);
+   if(ret<=0)
+     goto ex;
+   ret= burn_drive_equals_adr(in_drive, adr, 1);
+   if(ret==1)
+     dinfo= in_dinfo;
  }
+
+ if(dinfo==NULL) {
+   ret= isoburn_drive_scan_and_grab(&dinfo, adr, 1);
+   Xorriso_process_msg_queues(xorriso,0);
+   if(ret<=0) {
+     sprintf(xorriso->info_text,"Cannot aquire drive '%s'", adr); 
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     return(0);
+   }
+ }
+ drive= dinfo[0].drive;
+ state= isoburn_disc_get_status(drive);
+ Xorriso_process_msg_queues(xorriso,0);
+
  if(flag&2) {
    xorriso->out_drive_handle= dinfo;
-   if(Sfile_str(xorriso->indev, adr, 0)<=0)
+   if(Sfile_str(xorriso->outdev, adr, 0)<=0)
      return(-1);
+   if(state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE) {
+     sprintf(xorriso->info_text, "Disc status unsuitable for writing");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
+     not_writeable= 1;
+   }
  }
  if(flag&1) {
    xorriso->in_drive_handle= dinfo;
-   if(Sfile_str(xorriso->outdev, adr, 0)<=0)
+   if(Sfile_str(xorriso->indev, adr, 0)<=0)
      return(-1);
- } else
+ } else if(flag&2) {
-   return(1);
+   if(xorriso->in_volset_handle==NULL) {
+     /* No volume loaded: create empty one */
+     ret= Xorriso_create_empty_iso(xorriso, 0);
+     if(ret<=0)
+       return(ret);
+   } else {
+     iso_volset_ref(xorriso->in_volset_handle);
+     ret= isoburn_attach_volset(drive,
+                              (struct iso_volset *) xorriso->in_volset_handle);
+     if(ret<=0) {
+       sprintf(xorriso->info_text,
+               "Failed to attach ISO image object to outdev");
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+       return(-1);
+     }
+   }
+   Xorriso_toc(xorriso, 1|2);
+   return(1+not_writeable);
+ }
 
- drive= dinfo[0].drive;
+ if(xorriso->in_volset_handle!=NULL)
+   iso_volset_free((struct iso_volset *) xorriso->in_volset_handle);
+ xorriso->in_volset_handle= NULL;
 
  /* check for invalid state */
- state= isoburn_disc_get_status(drive);
+ if(state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE &&
- Xorriso_process_msg_queues(xorriso,0);
+    state != BURN_DISC_FULL) {
- 
+   sprintf(xorriso->info_text,
- /* >>> show drive and media status */;
+           "Disc status not blank and unsuitable for reading");
-
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
- if(state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE) {
+   return(0);
-   sprintf(xorriso->info_text, "Disc status unsuitable for writing");
-   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
  }
  /* fill read opts */ 
+ memset(&ropts, sizeof(ropts), 0);
  ropts.norock= 0;
  ropts.nojoliet= 0;
  ropts.preferjoliet= 0;
  ropts.uid= 0;
  ropts.gid= 0;
  ropts.mode= 0555;
+ ropts.pretend_blank= 0;
 
  if(isoburn_read_volset(drive, &ropts, &volset) <= 0) {
    Xorriso_process_msg_queues(xorriso,0);
    sprintf(xorriso->info_text,"Cannot read ISO image volset");
    Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
-   ret= 0; goto ex;
+   ret= 3; goto ex;
  }
  xorriso->in_volset_handle= volset;
+ if(xorriso->out_drive_handle != NULL &&
+    xorriso->out_drive_handle != xorriso->in_drive_handle) {
+   ret= Xorriso_get_drive_handles(xorriso, &out_dinfo, &out_drive,
+                         "on attempt to attach ISO image volset to outdev", 2);
+   if(ret<=0)
+     goto ex;
+   iso_volset_ref(xorriso->in_volset_handle);
+   isoburn_attach_volset(out_drive, xorriso->in_volset_handle);
+ }
  Xorriso_process_msg_queues(xorriso,0);
  Xorriso_toc(xorriso, 1);
- ret= 1;
+ ret= 1+not_writeable;
 ex:
- if(ret<0) {
+ if(ret<=0) {
-
+   hret= Xorriso_give_up_drive(xorriso, flag&3);
-   /* >>> give up drive */;
+   if(hret<ret)
-
+     ret= hret;
  }
  Xorriso_process_msg_queues(xorriso,0);
  return(ret);
@@ -222,10 +317,11 @@ ex:
 /* @param flag bit0=input drive
                bit1=output drive
                bit2=eject
+               bit3=no info message or toc
 */
 int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag)
 {
- int in_is_out_too;
+ int in_is_out_too, ret;
  struct burn_drive_info *dinfo;
  struct burn_drive *drive;
  
@@ -233,33 +329,45 @@ int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag)
    
  if((flag&1) && xorriso->in_drive_handle != NULL) {
    Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
-                             "on attempt to give drive up", 0);
+                             "on attempt to give up drive", 0);
-   if(drive!=NULL)
+
-     isoburn_drive_release(drive,!!(flag&4));
+   if(!in_is_out_too) {
+     if(drive!=NULL && !in_is_out_too)
+       isoburn_drive_release(drive,!!(flag&4));
+     if(dinfo!=NULL && !in_is_out_too)
+       burn_drive_info_free(dinfo);
+   }
+   xorriso->in_drive_handle= NULL;
+   xorriso->indev[0]= 0;
 
    if(xorriso->in_volset_handle!=NULL)
      iso_volset_free((struct iso_volset *) xorriso->in_volset_handle);
    xorriso->in_volset_handle= NULL;
    xorriso->volset_change_pending= 0;
 
-   if(dinfo!=NULL)
+   in_is_out_too= 0;
-     burn_drive_info_free(dinfo);
-   xorriso->in_drive_handle= NULL;
-   xorriso->indev[0]= 0;
-   if(in_is_out_too) {
-     xorriso->out_drive_handle= NULL;
-     xorriso->outdev[0]= 0;
-   }
  }
  if((flag&2) && xorriso->out_drive_handle!=NULL) {
    Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
                              "on attempt to give drive up", 2);
-   if(drive!=NULL)
+   if(!in_is_out_too) {
-     isoburn_drive_release(drive,!!(flag&4));
+     if(drive!=NULL)
-   if(dinfo!=NULL)
+       isoburn_drive_release(drive,!!(flag&4));
-     burn_drive_info_free(dinfo);
+     if(dinfo!=NULL)
+       burn_drive_info_free(dinfo);
+   }
    xorriso->out_drive_handle= NULL;
    xorriso->outdev[0]= 0;
+ } else if((flag&1) && xorriso->out_drive_handle!=NULL) {
+   ret= Xorriso_create_empty_iso(xorriso, 0);
+   if(ret<=0)
+     return(ret);
+   if(!(flag&8)) {
+     sprintf(xorriso->info_text,
+             "Only the output drive remains. Created empty ISO image.\n");
+     Xorriso_info(xorriso, 0);
+     Xorriso_toc(xorriso, 1|2);
+   }
  }
  Xorriso_process_msg_queues(xorriso,0);
  return(1);
@@ -287,19 +395,19 @@ int Xorriso_make_write_options(
 
 /* @param flag bit0= do not write but only prepare and return size in sectors
 */
-int Xorriso_write_growing(struct XorrisO *xorriso, int flag)
+int Xorriso_write_session(struct XorrisO *xorriso, int flag)
 {
  int ret, media_space;
  struct isoburn_source_opts sopts;
- struct burn_drive_info *dinfo;
+ struct burn_drive_info *dinfo, *source_dinfo;
- struct burn_drive *drive;
+ struct burn_drive *drive, *source_drive;
  struct burn_disc *disc= NULL;
  struct burn_write_opts *burn_options;
  off_t readcounter= 0,writecounter= 0;
  int num_sessions= 0, num_tracks= 0;
  struct burn_session **sessions;
  struct burn_track **tracks;
-
+ enum burn_disc_status s;
 
  ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
                                 "on attempt to write", 2);
@@ -327,9 +435,31 @@ int Xorriso_write_growing(struct XorrisO *xorriso, int flag)
  sopts.ouput_charset= NULL;
  sopts.fifo_size= xorriso->fs * 2048;
 
- if (isoburn_prepare_disc(drive, &disc, &sopts) <= 0) {
+ if(xorriso->out_drive_handle == xorriso->in_drive_handle ||
+    xorriso->in_drive_handle == NULL) {
+   ret= isoburn_prepare_disc(drive, &disc, &sopts);
+ } else {
+   s= isoburn_disc_get_status(drive);
+   if(s!=BURN_DISC_BLANK) {
+     s= burn_disc_get_status(drive);
+     if(s!=BURN_DISC_BLANK)
+       sprintf(xorriso->info_text,
+               "-indev differs from -outdev and -outdev media is not blank");
+     else
+       sprintf(xorriso->info_text,
+        "-indev differs from -outdev and -outdev media holds valid ISO image");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     {ret= 0; goto ex;}
+   }
+   ret= Xorriso_get_drive_handles(xorriso, &source_dinfo, &source_drive,
+                                  "on attempt to get source for write", 0);
+   if(ret<=0)
+     goto ex;
+   ret= isoburn_prepare_new_image(source_drive, &disc, &sopts);
+ }
+ if (ret <= 0) {
    Xorriso_process_msg_queues(xorriso,0);
-   sprintf(xorriso->info_text,"Cannot prepare disc");
+   sprintf(xorriso->info_text,"Failed to prepare session write run");
    Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
    {ret= 0; goto ex;}
  }
@@ -341,6 +471,7 @@ int Xorriso_write_growing(struct XorrisO *xorriso, int flag)
  ret= burn_disc_get_sectors(disc);
  if(flag&1)
    goto ex;
+
  media_space= burn_disc_available_space(drive, burn_options) / (off_t) 2048;
  if(media_space < ret) {
    Xorriso_process_msg_queues(xorriso,0);
@@ -972,13 +1103,15 @@ int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag)
 
 
 /* @param flag bit0=short report form
+               bit1=report about output drive
 */
 int Xorriso_toc(struct XorrisO *xorriso, int flag)
 {
  int num_sessions= 0, num_tracks= 0, lba= 0, nwa= -1, pmin, psec, pframe, ret;
  int track_count= 0, session_no, track_no, profile_no= -1;
  int last_track_start= 0, last_track_size= -1, num_data= 0, is_data= 0;
- char profile_name[80],*respt;
+ int is_inout_drive= 0;
+ char profile_name[80],*respt,*devadr;
  struct burn_disc *disc= NULL;
  struct burn_session **sessions;
  struct burn_track **tracks;
@@ -988,13 +1121,21 @@ int Xorriso_toc(struct XorrisO *xorriso, int flag)
  enum burn_disc_status s;
 
  ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
-                                "on attempt to print Table Of Content", 2);
+                               "on attempt to print Table Of Content", flag&2);
  if(ret<=0)
    return(0);
 
  respt= xorriso->result_line;
 
- sprintf(respt, "Drive current: -indev '%s'\n", xorriso->indev);
+ if(strcmp(xorriso->indev, xorriso->outdev)==0)
+   is_inout_drive= 1;
+ if(flag&2)
+   devadr= xorriso->outdev;
+ else
+   devadr= xorriso->indev;
+ sprintf(respt, "Drive current: %s '%s'\n",
+         (is_inout_drive ? "-dev" : (flag&2 ? "-outdev" : "-indev")),
+         devadr);
  Xorriso_result(xorriso,0);
  sprintf(respt, "Drive type   : vendor '%s' product '%s' revision '%s'\n",
         dinfo[0].vendor, dinfo[0].product, dinfo[0].revision);
@@ -1211,10 +1352,7 @@ int Xorriso_tell_media_space(struct XorrisO *xorriso,
  burn_write_opts_free(burn_options);
 
  if(xorriso->volset_change_pending) {
-
+   ret= Xorriso_write_session(xorriso, 1);
-   /* >>> care for modifying */
-
-   ret= Xorriso_write_growing(xorriso, 1);
    if(ret>0)
      (*free_space)-= ret;
  }
@@ -1321,12 +1459,6 @@ int Xorriso_format_media(struct XorrisO *xorriso, int flag)
  int ret, mode_flag= 0;
  struct burn_drive_info *dinfo;
  struct burn_drive *drive;
-
-#ifdef NIX
- struct burn_progress p;
- double percent = 1.0;
-#endif
-
  int current_profile;
  char current_profile_name[80];
 
@@ -1363,30 +1495,6 @@ int Xorriso_format_media(struct XorrisO *xorriso, int flag)
  if(ret<=0)
    return(ret);
 
-#ifdef NIX
-
- usleep(1000000);
- while(burn_drive_get_status(drive, &p) != BURN_DRIVE_IDLE) {
-   if(p.sectors>0 && p.sector>=0) /* display 1 to 99 percent */
-     percent = 1.0 + ((double) p.sector+1.0)
-               / ((double) p.sectors) * 98.0;
-   sprintf(xorriso->info_text, "Formatting  ( %.1f%% done )", percent);
-   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0);
-   usleep(1000000);
- }
-
- burn_disc_get_profile(dinfo[0].drive, &current_profile, current_profile_name);
- sprintf(xorriso->info_text, "Media type now: %4.4xh  \"%s\"\n",
-         current_profile, current_profile_name);
- Xorriso_info(xorriso, 0);
- if(current_profile != 0x13 && current_profile != 0x1a) {
-   sprintf(xorriso->info_text, 
-           "Failed to change media profile to desired value.");
-   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
-   return(0);
- }
-#endif
-
  Xorriso_process_msg_queues(xorriso,0);
  sprintf(xorriso->info_text, "Formatting done\n");
  Xorriso_info(xorriso,0);

test/xorrisoburn.h

@@ -18,11 +18,17 @@ struct XorrisO;
 
 int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag);
 
+int Xorriso_create_empty_iso(struct XorrisO *xorriso, int flag);
+
+/* @param flag bit0=aquire as isoburn input drive
+               bit1=aquire as libburn output drive (as isoburn drive if bit0)
+   @return <=0 failure , 1=success , 2=neither readable or writeable
+*/
 int Xorriso_aquire_drive(struct XorrisO *xorriso, char *adr, int flag);
 
 int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag);
 
-int Xorriso_write_growing(struct XorrisO *xorriso, int flag);
+int Xorriso_write_session(struct XorrisO *xorriso, int flag);
 
 /* @param flag bit0=graft in as empty directory, not as copy from disk
    @return <=0 = error , 1 = added simple node , 2 = added directory
@@ -32,7 +38,8 @@ int Xorriso_graft_in(struct XorrisO *xorriso, char *disk_path, char *img_path,
 
 int Xorriso__text_to_sev(char *severity_name, int *severity_number,int flag);
 
-/* @param flag bit0=short report form
+/* @param flag bit0=report about output drive 
+               bit1=short report form
 */
 int Xorriso_toc(struct XorrisO *xorriso, int flag);