Organized ecdb source code in structure

experimental/ecdb/trunk/src/Makefile.am

@@ -0,0 +1,14 @@
+## Process this file with automake to produce Makefile.in
+
+bin_PROGRAMS = ecdb 
+
+ecdb_SOURCES = \
+		    ecdb.c ecdb.h \
+		    ecdb_drives.c ecdb_drives.h \
+		    ecdb_image.c ecdb_image.h \
+		    ecdb_burn.c ecdb_burn.h \
+		    ecdb_misc.c ecdb_misc.h
+
+ecdb_CFLAGS = @ECDB_CFLAGS@
+ecdb_LDADD = @ECDB_LIBS@
+

experimental/ecdb/trunk/src/ecdb.c

@@ -0,0 +1,60 @@
+#include "ecdb.h"
+
+Ecdb_Main *em;
+int ecdb_setup();
+void ecdb_shutdown();
+
+int
+main(int argc, char **argv)
+{
+	Ecdb_Project *proj;
+	int i;
+
+	if (!ecdb_setup())
+	{
+		printf("Setup failed\n");
+		return 1;
+	}
+
+	ecdb_print_drive_info();
+	ecdb_burn_init();
+
+	proj = ecdb_project_new();
+
+	i = 1;
+	while ((i < argc) && (argv))
+	{
+		ecore_list_append(proj->files, strdup(argv[i]));
+		i++;
+	}
+	proj->simulate = FALSE;
+	proj->publisher_id = proj->data_preparer_id = proj->system_id = 
+		proj->application_id = proj->copywrite_id = proj->abstract_id =
+		proj->biblio_id = "ecdb";
+	ecdb_aquire_drive(proj, 0);
+	ecdb_burn_project(proj);
+	sleep(7000);
+
+	/* End testing */
+	burn_finish();
+	ecdb_shutdown();
+	return 0;
+};
+
+int
+ecdb_setup(void)
+{
+	em = NULL;
+	em = calloc(1, sizeof(Ecdb_Main));
+	em->drives = NULL;
+	em->projects = ecore_list_new();
+
+	if (!ecdb_aquire_drive_info())
+	{
+		printf("Aquiring drives failed!\n");
+		return 0;
+	}
+	
+	return 1;
+}
+

experimental/ecdb/trunk/src/ecdb.h

@@ -0,0 +1,128 @@
+#ifndef ECDB_H
+#define ECDB_H
+
+#include "config.h"
+#include <Ecore.h>
+#include <Ecore_Data.h>
+#include <Ecore_File.h>
+#include <Efreet_Mime.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <libgen.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+#include <limits.h>
+#include <libburn/libburn.h>
+#include <libisofs/libisofs.h>
+#include <pthread.h>
+
+#undef FREE
+#define FREE(dat) \
+{ \
+	if (dat) { free(dat); dat = NULL; } \
+}
+
+/* Typdefs */
+typedef struct burn_source BurnSource;
+typedef struct burn_disc BurnDisc;
+typedef struct burn_session BurnSession;
+typedef struct burn_write_opts BurnWriteOpts;
+typedef struct burn_track BurnTrack;
+typedef struct burn_progress BurnProgress;
+typedef struct burn_drive_info BurnDriveInfo;
+typedef enum burn_drive_status BurnDriveStatus;
+
+/* ECDB Global Variables */
+typedef struct _Ecdb_Main Ecdb_Main;
+
+struct _Ecdb_Main
+{
+	Ecore_List *projects;
+	Ecore_List *drives;
+};
+
+extern Ecdb_Main *em;
+
+typedef struct _Ecdb_Drive_Info Ecdb_Drive_Info;
+
+struct _Ecdb_Drive_Info
+{
+	/* Speeds */
+	int *read_speeds;
+	int *write_speeds;
+
+	/* Profiles */
+	char *profile_name;
+	int profile_loaded;
+
+	/* Drive info */
+	char *vendor;
+	char *product;
+	char *revision;
+	char *location;
+
+	unsigned char read_dvdram:1;
+	unsigned char read_dvdr:1;
+	unsigned char read_dvdrom:1;
+	unsigned char read_cdr:1;
+	unsigned char read_cdrw:1;
+	unsigned char write_dvdram:1;
+	unsigned char write_dvdr:1;
+	unsigned char write_cdr:1;
+	unsigned char write_simulate:1;
+
+	BurnDriveInfo *tangible;
+};
+
+typedef struct _Ecdb_Project_Info Ecdb_Project;
+
+struct _Ecdb_Project_Info
+{
+	/* Files are important here */
+	Ecore_List *files;
+
+	/* Ids */
+	char *volume_id;
+	char *publisher_id;
+	char *data_preparer_id;
+	char *system_id;
+	char *application_id;
+	char *copywrite_id;
+	char *abstract_id;
+	char *biblio_id;
+
+	/* iso options */
+	unsigned char iso_level:1;
+	unsigned char use_joliet:1;
+	unsigned char use_rockridge:1;
+	unsigned char follow_symlinks:1;
+	unsigned char ignore_hidden:1;
+	unsigned char ignore_special:1;
+	unsigned char iso1990:1;
+
+	/* burn options */
+	unsigned char opc:1;
+	unsigned char multi:1;
+	unsigned char simulate:1;
+	unsigned char underrun_proof:1;
+	int speed;
+
+	/* burn stuff */
+	int fifo_chunksize;
+	int fifo_chunks;
+	int burn_mode;
+
+	/* The drive reference */
+	Ecdb_Drive_Info *drive;
+	BurnProgress progress;
+};
+
+#include "ecdb_drives.h"
+#include "ecdb_image.h"
+#include "ecdb_burn.h"
+#include "ecdb_misc.h"
+
+#endif
+

experimental/ecdb/trunk/src/ecdb_burn.c

@@ -0,0 +1,158 @@
+#include "ecdb.h"
+
+typedef struct Burn_Data Burn_Data;
+struct Burn_Data
+{
+	BurnDisc *disc;
+	BurnSession *session;
+	Ecore_List *sources;
+	Ecore_List *tracks;
+	Ecdb_Project *proj;
+};
+
+void *_progress_update(void *d);
+
+/* Event handlers */
+int
+ecdb_burn_project(Ecdb_Project *proj)
+{
+	char reasons[BURN_REASONS_LEN];
+	int padding, i;
+	Burn_Data *data;
+	BurnTrack *track;
+	BurnSource *source;
+	BurnWriteOpts *opts;
+	pthread_t progress_update;
+
+	i = 0;
+	data = calloc(1, sizeof(Burn_Data));
+	data->sources = ecore_list_new();
+	data->tracks = ecore_list_new();
+	data->proj = proj;
+
+	if (proj->burn_mode != BURN_AUDIO)
+		padding = 300*1024;
+
+	data->disc = burn_disc_create();
+	data->session = burn_session_create();
+	burn_disc_add_session(data->disc, data->session, BURN_POS_END);
+
+	track = burn_track_create();
+	burn_track_define_data(track, 0, padding, 1, proj->burn_mode);
+
+	while ((source = ecdb_image_project(proj)))
+	{
+		if (burn_track_set_source(track, source) != BURN_SOURCE_OK)
+		{
+			printf("Error: Cannot attach source object to track "
+					"object!\n");
+			return 1;
+		}
+
+		burn_session_add_track(data->session, track, BURN_POS_END);
+		ecore_list_append(data->sources, source);
+		ecore_list_append(data->tracks, track);
+		i++;
+	}
+
+	if (!i)
+	{
+		printf("Failed to add any files to burn disc!\n");
+		return 1;
+	}
+
+	opts = burn_write_opts_new(proj->drive->tangible[0].drive);
+	burn_write_opts_set_perform_opc(opts, proj->opc);
+	burn_write_opts_set_multi(opts, proj->multi);
+	if (proj->simulate)
+		printf("simulating!\n");
+	burn_write_opts_set_simulate(opts, proj->simulate);
+	burn_drive_set_speed(proj->drive->tangible->drive, 0, proj->speed);
+	burn_write_opts_set_underrun_proof(opts, proj->underrun_proof);
+
+	if (burn_write_opts_auto_write_type(opts, data->disc, reasons, 0)
+			== BURN_WRITE_NONE)
+	{
+		printf("Error: Failed to find a suitable write mode for "
+				"disc!\n");
+		return 1;
+	}
+
+	/* Not sure where to put this for now */
+	burn_disc_write(opts, data->disc);
+	burn_write_opts_free(opts);
+
+	pthread_create(&progress_update, NULL, _progress_update, data);
+	pthread_detach(progress_update);
+
+	return 0;
+}
+
+void *
+_progress_update(void *d)
+{
+	Burn_Data *data;
+	BurnProgress p;
+	BurnDriveStatus stat;
+	struct burn_drive *drive;
+
+	data = d;
+
+	if (!data->proj->drive->tangible)
+	{
+		printf("No tangible drive!\n");
+		pthread_exit(NULL);
+	}
+	drive = data->proj->drive->tangible[0].drive;
+
+
+	while (TRUE)
+	{
+		stat = burn_drive_get_status(drive, &p);
+		if (stat == BURN_DRIVE_SPAWNING)
+		{
+			sleep(3);
+			continue;
+		}
+		else if (stat == BURN_DRIVE_IDLE)
+		{
+			BurnTrack *track;
+			BurnSource *source;
+
+			ecore_list_first_goto(data->sources);
+			ecore_list_first_goto(data->tracks);
+
+			while ((source = ecore_list_remove(data->sources)))
+			{
+				burn_source_free(source);
+				track = ecore_list_remove(data->tracks);
+				burn_track_free(track);
+			}
+
+			ecore_list_destroy(data->sources);
+			ecore_list_destroy(data->tracks);
+			burn_session_free(data->session);
+			burn_disc_free(data->disc);
+			burn_drive_release(drive, 0);
+			burn_drive_info_free(data->proj->drive->tangible);
+
+			/* Don't keep in here */
+			printf("fail\n");
+			ecore_list_destroy(data->proj->files);
+			FREE(data->proj);
+
+			/* End testing */
+			printf("here\n");
+			FREE(data);
+
+			pthread_exit(NULL);
+			break;
+		}
+
+		//printf("Total sectors: %d, on sector: %d\n", p.sectors,
+		//				p.sector);
+		data->proj->progress = p;
+		sleep(5);
+	}
+}
+

experimental/ecdb/trunk/src/ecdb_burn.h

@@ -0,0 +1,6 @@
+#ifndef ECDB_BURN_H
+#define ECDB_BURN_H
+
+int ecdb_burn_project(Ecdb_Project *proj);
+
+#endif

experimental/ecdb/trunk/src/ecdb_drives.c

@@ -0,0 +1,163 @@
+#include "ecdb.h"
+
+void ecdb_drive_info_free_cb(void *data);
+
+int
+ecdb_aquire_drive_info(void)
+{
+	int ret, i;
+	unsigned int drive_num;
+	struct burn_drive_info *drives_current;
+	struct burn_speed_descriptor *speeds;
+
+	ecdb_burn_init();
+
+	ret = 0;
+	if (em->drives)
+		ecore_list_destroy(em->drives);
+
+	em->drives = ecore_list_new();
+	ecore_list_free_cb_set(em->drives, ecdb_drive_info_free_cb);
+
+	while (!ret)
+		ret = burn_drive_scan(&drives_current, &drive_num);
+
+	for (i = 0; i < drive_num; i++)
+	{
+		Ecdb_Drive_Info *drive;
+
+		drive = calloc(1, sizeof(Ecdb_Drive_Info));
+
+		/* It would be nice if there was an easier way to do this */
+		drive->product = strdup(drives_current[i].product);
+		drive->vendor = strdup(drives_current[i].vendor);
+		drive->revision = strdup(drives_current[i].revision);
+		drive->location = strdup(drives_current[i].location);
+		drive->read_dvdram = drives_current[i].read_dvdram;
+		drive->read_dvdr = drives_current[i].read_dvdr;
+		drive->read_dvdrom = drives_current[i].read_dvdrom;
+		drive->read_cdr = drives_current[i].read_cdr;
+		drive->read_cdrw = drives_current[i].read_cdrw;
+		drive->write_dvdram = drives_current[i].write_dvdram;
+		drive->write_dvdr = drives_current[i].write_dvdr;
+		drive->write_cdr = drives_current[i].write_cdr;
+		drive->write_simulate = drives_current[i].write_simulate;
+
+		burn_drive_get_speedlist(drives_current[i].drive, &speeds);
+
+		drive->profile_name = strdup(speeds->profile_name);
+		drive->profile_loaded = speeds->profile_loaded;
+
+		while (speeds->next)
+		{
+			i++;
+			speeds = speeds->next;
+		}
+
+		drive->read_speeds = calloc(i + 2, sizeof(int));
+		drive->write_speeds = calloc(i + 2, sizeof(int));
+
+		drive->read_speeds[0] = i + 1;
+		drive->write_speeds[0] = i + 1;
+
+		for (ret = 1; ret <= i; ret++)
+		{
+			drive->write_speeds[ret] = speeds->write_speed;
+			drive->read_speeds[ret] = speeds->read_speed;
+			speeds = speeds->prev;
+		}
+
+		burn_drive_free_speedlist(&speeds);
+		ecore_list_append(em->drives, drive);
+	}
+
+	burn_drive_info_free(drives_current);
+	burn_finish();
+
+	return TRUE;
+}
+
+void
+ecdb_drive_info_free_cb(void *data)
+{
+	Ecdb_Drive_Info *info;
+
+	info = data;
+
+	FREE(info->read_speeds);
+	FREE(info->write_speeds);
+	FREE(info->vendor);
+	FREE(info->product);
+	FREE(info->revision);
+	FREE(info->location);
+	FREE(info->profile_name);
+	FREE(info);
+}
+
+void
+ecdb_print_drive_info(void)
+{
+	Ecdb_Drive_Info *drive;
+	int j, i, h;
+
+	ecore_list_first_goto(em->drives);
+	while ((drive = ecore_list_next(em->drives)))
+	{
+		printf("Vendor: %s, Product: %s, Revision: %s, "
+				"Location: %s\n",
+				drive->vendor, drive->product,
+				drive->revision, drive->location);
+		printf("Profile name: %s, Loaded: %d\n",
+				drive->profile_name,
+				drive->profile_loaded);
+		printf("Read DVDRAM: %d, Read DVDR: %d, Read DVDROM: %d, "
+				"Read CDR: %d, Read CDRW: %d\n",
+				drive->read_dvdram,
+				drive->read_dvdr,
+				drive->read_dvdrom,
+				drive->read_cdr,
+				drive->read_cdrw);
+		printf("Write DVDRAM: %d, Write DVDR: %d, Write CDR: %d, "
+				"Write Simulate: %d\n",
+				drive->write_dvdram,
+				drive->write_dvdr,
+				drive->write_cdr,
+				drive->write_simulate);
+
+		j = drive->read_speeds[0];
+
+		for (i = 1; i < j; i ++)
+		{
+			if ((h = drive->write_speeds[i]))
+				printf("Write: %d\n", h);
+			if ((h = drive->read_speeds[i]))
+				printf("Read: %d\n", h);
+		}
+	}
+}
+
+int
+ecdb_aquire_drive(Ecdb_Project *proj, unsigned int idx)
+{
+	Ecdb_Drive_Info *info;
+	char adr[BURN_DRIVE_ADR_LEN];
+
+	info = ecore_list_index_goto(em->drives, idx);
+	if (burn_drive_convert_fs_adr(info->location, adr) <= 0)
+	{
+		printf("Error: Address doesn't provide cd burner!\n");
+		return 1;
+	}
+
+	if (burn_drive_scan_and_grab(&info->tangible, adr, 1) > 0)
+	{
+		proj->drive = info;
+		return 0;
+	}
+	else
+	{
+		info->tangible = NULL;
+		return 1;
+	}
+}
+	

experimental/ecdb/trunk/src/ecdb_drives.h

@@ -0,0 +1,8 @@
+#ifndef ECDB_DRIVES_H
+#define ECDB_DRIVES_H
+
+int ecdb_aquire_drive_info(void);
+void ecdb_print_drive_info(void);
+int ecdb_aquire_drive(Ecdb_Project *proj, unsigned int idx);
+
+#endif

experimental/ecdb/trunk/src/ecdb_image.c

@@ -0,0 +1,128 @@
+#include "ecdb.h"
+
+/* Some limitations here need to be worked out
+ * Handle: audio, etc */
+BurnSource *
+ecdb_image_project(Ecdb_Project *proj)
+{
+	IsoImage *image;
+	IsoDir *root;
+	IsoWriteOpts *opts;
+	BurnSource *data_src, *fifo_src;
+	char *path;
+	int ret;
+
+	efreet_mime_init();
+
+	if ((!proj->files) || (ecore_list_empty_is(proj->files)))
+		return NULL;
+	else if (ecore_list_count(proj->files) == 1)
+	{
+		path = ecore_list_first(proj->files);
+		if ((path) && (!ecore_file_is_dir(path)) &&
+				(!strcmp(efreet_mime_type_get(path),
+					 "application/x-cd-image")))
+		{
+			path = ecore_list_first_remove(proj->files);
+			data_src = burn_file_source_new(path, NULL);
+			FREE(path);
+			goto FIFO_CREATE;
+		}
+	}
+
+	ecdb_image_init();
+
+	ret = iso_image_new(proj->volume_id, &image);
+
+	if (!ret)
+	{
+		printf("Failed to create an iso image!\n");
+		iso_finish();
+		return NULL;
+	}
+
+	/* Disk ids */
+	if (proj->publisher_id)
+		iso_image_set_publisher_id(image, proj->publisher_id);
+	if (proj->data_preparer_id)
+		iso_image_set_data_preparer_id(image,
+						proj->data_preparer_id);
+	if (proj->system_id)
+		iso_image_set_system_id(image, proj->system_id);
+	if (proj->application_id)
+		iso_image_set_application_id(image, proj->application_id);
+	if (proj->copywrite_id)
+		iso_image_set_copyright_file_id(image, proj->copywrite_id);
+	if (proj->abstract_id)
+		iso_image_set_abstract_file_id(image, proj->abstract_id);
+	if (proj->biblio_id)
+		iso_image_set_biblio_file_id(image, proj->biblio_id);
+
+	/* Write Options - default to distribution for now */
+	ret = iso_write_opts_new(&opts, 2);
+	if (!ret)
+	{
+		printf("Failed to create writing options!\n");
+		iso_image_unref(image);
+		iso_finish();
+		return NULL;
+	}
+
+	/* Most set by default with 2 ^ */
+	iso_write_opts_set_iso_level(opts, proj->iso_level);
+	iso_write_opts_set_joliet(opts, proj->use_joliet);
+	iso_write_opts_set_rockridge(opts, proj->use_rockridge);
+	iso_write_opts_set_iso1999(opts, proj->iso1990);
+	//iso_write_opts_set_appendable(opts, proj->appendable);
+	
+	iso_tree_set_follow_symlinks(image, proj->follow_symlinks);
+	iso_tree_set_ignore_hidden(image, proj->ignore_hidden);
+	iso_tree_set_ignore_special(image, proj->ignore_special);
+
+	root = iso_image_get_root(image);
+	ecore_list_first_goto(proj->files);
+
+	ret = 0;
+	while ((path = ecore_list_remove(proj->files)))
+	{
+		/* For now just this, in future special, symlink */
+		if (ecore_file_is_dir(path))
+			iso_tree_add_dir_rec(image, root, path);
+		else if (ecore_file_exists(path))
+			iso_tree_add_node(image, root, path, NULL);
+		else
+		{
+			FREE(path);
+			continue;
+		}
+		FREE(path);
+		ret++;
+	}
+
+	if (!ret)
+	{
+		printf("No files appended to image!\n");
+		iso_image_unref(image);
+		iso_write_opts_free(opts);
+		iso_finish();
+	}
+
+	/* Valgrind segfaults around here for some reason, otherwise not
+	 * strange
+	 */
+	iso_image_create_burn_source(image, opts, &data_src);
+	iso_write_opts_free(opts);
+
+	/* unref here? not sure from docs */
+	iso_image_unref(image);
+
+	FIFO_CREATE:
+	fifo_src = burn_fifo_source_new(data_src,
+			proj->fifo_chunksize, proj->fifo_chunks, 0);
+	burn_source_free(data_src);
+	iso_finish();
+	efreet_mime_shutdown();
+
+	return fifo_src;
+}
+

experimental/ecdb/trunk/src/ecdb_image.h

@@ -0,0 +1,7 @@
+#ifndef ECDB_IMAGE_H
+#define ECDB_IMAGE_H
+
+BurnSource *ecdb_image_project(Ecdb_Project *proj);
+
+#endif
+

experimental/ecdb/trunk/src/ecdb_misc.c

@@ -0,0 +1,44 @@
+#include "ecdb.h"
+
+Ecdb_Project *
+ecdb_project_new(void)
+{
+	Ecdb_Project *proj;
+
+	proj = calloc(1, sizeof(Ecdb_Project));
+	proj->files = ecore_list_new();
+	ecore_list_append(em->projects, proj);
+	
+	/* Create some sane defaults */
+	proj->burn_mode = BURN_MODE1;
+	proj->fifo_chunksize = 2048;
+	proj->fifo_chunks = 2048;
+	
+	return proj;
+}
+
+void
+ecdb_shutdown(void)
+{
+	if (em->projects)
+		ecore_list_destroy(em->projects);
+	if (em->drives)
+		ecore_list_destroy(em->drives);
+	free(em);
+}
+
+void
+ecdb_burn_init(void)
+{
+	burn_initialize();
+	burn_msgs_set_severities("NEVER", "SORRY", "ecdb: ");
+	burn_set_signal_handling("ecdb: ", NULL, 0);
+}
+
+void
+ecdb_image_init(void)
+{
+	iso_init();
+	iso_set_msgs_severities("NEVER", "SORRY", "ecdb: ");
+}
+

experimental/ecdb/trunk/src/ecdb_misc.h

@@ -0,0 +1,9 @@
+#ifndef ECDB_MISC_H
+#define ECDB_MISC_H
+
+Ecdb_Project *ecdb_project_new(void);
+void ecdb_shutdown(void);
+void ecdb_burn_init(void);
+void ecdb_image_init(void);
+
+#endif