Initial import

AUTHORS

@@ -0,0 +1,5 @@
+Developers:
+
+Mario Đanić
+Luke Biddell
+Anant Narayanan 

COPYING

@@ -0,0 +1,280 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS

COPYRIGHT

@@ -0,0 +1,18 @@
+Derek Foreman <derek@signalmarketing.com> and Ben Jansens <xor@orodu.net>
+Copyright (C) 2002-2004  Derek Foreman and Ben Jansens
+Mario Đanić <mario.danic@gmail.com>, Luke Biddell <luke.biddell@gmail.com>, Anant Narayanan <anant@kix.in>
+Copyright (C) 2006 Mario Đanić, Luke Biddell, Anant Narayanan
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

Makefile.am

@@ -0,0 +1,192 @@
+pkgconfigdir=$(libdir)/pkgconfig
+libincludedir=$(includedir)/libburn/@BURN_MAJOR_VERSION@/libburn
+
+lib_LTLIBRARIES = libburn/libburn.la libisofs/libisofs.la
+
+## ========================================================================= ##
+
+# Build libraries
+libburn_libburn_la_LDFLAGS = \
+	-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
+libburn_libburn_la_SOURCES = \
+	libburn/async.c \
+	libburn/async.h \
+	libburn/crc.c \
+	libburn/crc.h \
+	libburn/debug.c \
+	libburn/debug.h \
+	libburn/drive.c \
+	libburn/drive.h \
+	libburn/error.h \
+	libburn/file.c \
+	libburn/file.h \
+	libburn/init.c \
+	libburn/init.h \
+	libburn/lec.c \
+	libburn/lec.h \
+	libburn/libburn.h \
+	libburn/message.c \
+	libburn/message.h \
+	libburn/mmc.c \
+	libburn/mmc.h \
+	libburn/null.c \
+	libburn/null.h \
+	libburn/options.c \
+	libburn/options.h \
+	libburn/read.c \
+	libburn/read.h \
+	libburn/sbc.c \
+	libburn/sbc.h \
+	libburn/sector.c \
+	libburn/sector.h \
+	libburn/sg.c \
+	libburn/sg.h \
+	libburn/source.h \
+	libburn/source.c \
+	libburn/spc.c \
+	libburn/spc.h \
+	libburn/structure.c \
+	libburn/structure.h \
+	libburn/toc.c \
+	libburn/toc.h \
+	libburn/transport.h \
+	libburn/util.c \
+	libburn/util.h \
+	libburn/write.c \
+	libburn/write.h \
+	version.h
+
+libisofs_libisofs_la_LDFLAGS = \
+	-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
+libisofs_libisofs_la_SOURCES = \
+        libisofs/errors.h \
+        libisofs/errors.c \
+        libisofs/tree.h \
+        libisofs/tree.c \
+        libisofs/volume.h \
+        libisofs/volume.c \
+        libisofs/util.h \
+        libisofs/util.c \
+        libisofs/ecma119.c \
+        libisofs/ecma119.h \
+        libisofs/struct.h \
+        libisofs/struct.c \
+        libisofs/susp.h \
+        libisofs/susp.c \
+        libisofs/rockridge.h \
+        libisofs/rockridge.c \
+	libisofs/libisofs.h
+
+libinclude_HEADERS = \
+	libburn/libburn.h \
+	libisofs/libisofs.h
+
+## ========================================================================= ##
+
+## Build test applications
+noinst_PROGRAMS = \
+	test/blank \
+	test/burn \
+	test/burniso \
+	test/devices \
+	test/iso \
+	test/master \
+	test/poll \
+	test/rip \
+	test/toc \
+	test/structest
+
+test_devices_CPPFLAGS = -Ilibburn
+test_devices_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_devices_SOURCES = test/devices.c
+test_poll_CPPFLAGS = -Ilibburn
+test_poll_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_poll_SOURCES = test/poll.c
+test_toc_CPPFLAGS = -Ilibburn
+test_toc_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_toc_SOURCES = test/toc.c
+test_rip_CPPFLAGS = -Ilibburn
+test_rip_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_rip_SOURCES = test/rip.c
+test_burn_CPPFLAGS = -Ilibburn
+test_burn_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_burn_SOURCES = test/burn.c
+test_burniso_CPPFLAGS = -Ilibburn
+test_burniso_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_burniso_SOURCES = test/burniso.c
+test_master_CPPFLAGS = -Ilibburn
+test_master_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_master_SOURCES = test/master.c
+test_structest_CPPFLAGS = -Ilibburn
+test_structest_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_structest_SOURCES = test/structest.c
+test_blank_CPPFLAGS = -Ilibburn
+test_blank_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_blank_SOURCES = test/blank.c
+test_iso_CPPFLAGS = -Ilibisofs
+test_iso_LDADD = $(libisofs_libisofs_la_OBJECTS) $(THREAD_LIBS)
+test_iso_SOURCES = test/iso.c
+
+## ========================================================================= ##
+
+## Build documentation (You need Doxygen for this to work)
+webhost = http://libburn-api.pykix.org
+webpath = /
+
+docdeps = \
+	doc/doxygen.conf \
+	doc/comments \
+	libburn/libburn.h \
+	libisofs/libisofs.h \
+	test/burniso.c
+
+doc: doc/html
+
+doc/html: $(docdeps)
+	$(RM) -r $@
+	doxygen doc/doxygen.conf
+
+doc-upload: doc/html
+	scp -r $</* $(webhost):$(webpath)
+
+.PHONY: doc
+
+## ========================================================================= ##
+
+# Indent source files
+indent_files = \
+	$(libisofs_libisofs_la_SOURCES) \
+	$(libburn_libburn_la_SOURCES) \
+	$(test_devices_SOURCES) \
+	$(test_poll_SOURCES) \
+	$(test_toc_SOURCES) \
+	$(test_rip_SOURCES) \
+	$(test_burn_SOURCES) \
+	$(test_burniso_SOURCES) \
+	$(test_master_SOURCES) \
+	$(test_structest_SOURCES) \
+	$(test_blank_SOURCES)
+
+indent: $(indent_files)
+	indent -bad -bap -nbbb -nbbo -nbc -bli0 -br -bls   \
+		-cdw -ce -cli0 -ncs -nbfda -i8 -l79 -lc79   \
+		-lp -saf -sai -nprs -npsl -saw -sob -ss -ut \
+		-sbi0 -nsc -ts8 -npcs -ncdb -fca            \
+		$^
+
+.PHONY: indent
+
+## ========================================================================= ##
+
+# Extra things
+nodist_pkgconfig_DATA = \
+	libburn-1.pc \
+	libisofs-1.pc
+
+EXTRA_DIST = \
+	libburn-1.pc.in \
+	libisofs-1.pc.in \
+	version.h.in \
+	doc/doxygen.conf.in \
+	README \
+	COPYING

acinclude.m4

@@ -0,0 +1,37 @@
+dnl Function to link an architecture specific file
+dnl LINK_ARCH_SRC(source_dir, arch, source_file)
+AC_DEFUN([COPY_ARCH_SRC],
+[
+  echo "copying $1/$2/$3 -> $1/$3"
+  old="$srcdir/$1/$2/$3"
+  new="$srcdir/$1/$3"
+  cat >$new <<__EOF__
+/* WARNING:  This file was automatically generated!
+ * Original: $old
+ */
+__EOF__
+  cat >>$new <$old
+])
+
+AC_DEFUN([TARGET_SHIZZLE],
+[
+  ARCH=""
+
+  AC_MSG_CHECKING([target operating system])
+
+  case $target in
+    *-*-linux*)
+      ARCH=linux
+      ;;
+    *)
+      AC_ERROR([You are attempting to compile for an unsupported platform])
+      ;;
+  esac
+
+  AC_MSG_RESULT([$ARCH])
+
+  # this doesn't actually do anything yet.. but it will someday when we port
+  # libburn
+
+  #COPY_ARCH_SRC(libburn, $ARCH, transport.c)
+])

bootstrap

@@ -0,0 +1,6 @@
+#!/bin/sh -x
+
+aclocal-1.7
+libtoolize --copy --force
+autoconf
+automake-1.7 --foreign --add-missing --copy --include-deps

configure.ac

@@ -0,0 +1,103 @@
+AC_INIT([libburn], [0.2.1], [http://libburn.pykix.org])
+AC_PREREQ([2.50])
+dnl AC_CONFIG_HEADER([config.h])	
+
+AC_CANONICAL_HOST
+AC_CANONICAL_TARGET
+
+AM_INIT_AUTOMAKE([subdir-objects])
+
+dnl Making releases:
+dnl   BURN_MICRO_VERSION += 1;
+dnl   BURN_INTERFACE_AGE += 1;
+dnl   BURN_BINARY_AGE += 1;
+dnl if any functions have been added, set BURN_INTERFACE_AGE to 0.
+dnl if backwards compatibility has been broken,
+dnl set BURN_BINARY_AGE and BURN_INTERFACE_AGE to 0.
+dnl
+dnl if MAJOR or MINOR version changes, be sure to change AC_INIT above to match
+dnl
+BURN_MAJOR_VERSION=0
+BURN_MINOR_VERSION=2
+BURN_MICRO_VERSION=1
+BURN_INTERFACE_AGE=0
+BURN_BINARY_AGE=0
+BURN_VERSION=$BURN_MAJOR_VERSION.$BURN_MINOR_VERSION.$BURN_MICRO_VERSION
+
+AC_SUBST(BURN_MAJOR_VERSION)
+AC_SUBST(BURN_MINOR_VERSION)
+AC_SUBST(BURN_MICRO_VERSION)
+AC_SUBST(BURN_INTERFACE_AGE)
+AC_SUBST(BURN_BINARY_AGE)
+AC_SUBST(BURN_VERSION)
+
+dnl Libtool versioning
+LT_RELEASE=$BURN_MAJOR_VERSION.$BURN_MINOR_VERSION
+LT_CURRENT=`expr $BURN_MICRO_VERSION - $BURN_INTERFACE_AGE`
+LT_REVISION=$BURN_INTERFACE_AGE
+LT_AGE=`expr $BURN_BINARY_AGE - $BURN_INTERFACE_AGE`
+LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`
+
+AC_SUBST(LT_RELEASE)
+AC_SUBST(LT_CURRENT)
+AC_SUBST(LT_REVISION)
+AC_SUBST(LT_AGE)
+AC_SUBST(LT_CURRENT_MINUS_AGE)
+
+AC_PREFIX_DEFAULT([/usr/local])
+test "$prefix" = "NONE" && prefix=$ac_default_prefix
+
+AM_MAINTAINER_MODE
+
+AM_PROG_CC_C_O
+AC_C_CONST
+AC_C_INLINE
+AC_C_BIGENDIAN
+
+dnl Large file support
+AC_SYS_LARGEFILE
+AC_FUNC_FSEEKO
+if test ! $ac_cv_func_fseeko; then
+   AC_ERROR([Libburn requires largefile support.])
+fi
+
+AC_PROG_LIBTOOL
+AC_SUBST(LIBTOOL_DEPS)
+LIBTOOL="$LIBTOOL --silent"
+
+AC_PROG_INSTALL
+
+AC_CHECK_HEADERS()
+
+THREAD_LIBS=-lpthread
+AC_SUBST(THREAD_LIBS)
+
+TARGET_SHIZZLE
+
+dnl Add compiler-specific flags
+
+dnl See if the user wants aggressive optimizations of the code
+AC_ARG_ENABLE(debug,
+[  --enable-debug          Disable aggressive optimizations [default=yes]],
+              , enable_debug=yes)
+if test x$enable_debug != xyes; then
+    if test x$GCC = xyes; then
+        CFLAGS="$CFLAGS -O3"
+        CFLAGS="$CFLAGS -fexpensive-optimizations"
+    fi
+    CFLAGS="$CFLAGS -DNDEBUG"
+else
+    if test x$GCC = xyes; then
+        CFLAGS="$CFLAGS -g -pedantic -Wall"
+    fi
+    CFLAGS="$CFLAGS -DDEBUG"
+fi
+
+AC_CONFIG_FILES([
+	Makefile
+	doc/doxygen.conf
+	version.h
+	libburn-1.pc
+	libisofs-1.pc
+	])
+AC_OUTPUT

doc/Makefile

@@ -0,0 +1,4 @@
+all clean:
+	$(MAKE) -C .. -$(MAKEFLAGS) $@
+
+.PHONY: all clean

doc/comments

@@ -0,0 +1,52 @@
+/**
+   @author Dana Jansens, Derek Foreman
+
+   @mainpage Libburn Documentation Index
+
+   @section intro Introduction
+
+   Libburn is an open source library suite for reading, mastering and writing
+   optical discs.
+
+   @section using Using the library
+
+   @subsection concepts Library concepts
+
+   There are a few concepts to introduce in order for you to understand how to
+   use Libburn. So, lets start with them:
+
+   <ol>
+   <li> Read - The process of reading the data on a disc for storage or
+        copying.
+   <li> Write - The process of writing data onto a disc to create a new
+        disc image or append to an existing one.
+   <li> Drive - A Drive is a hardware device used to reading and/or writing
+        discs. CD burners and CD-ROMs are examples of Drives.
+   </ol>
+
+   @subsection working Working with the library
+
+   Now that you understand the above @ref concepts, you're ready to look at the
+   actual use of the library.
+
+   In general, using the library to perform a process consists of the following
+   steps:
+
+   <ol>
+   <li> Initialize the library. (If not already done; a single instance of
+        the library can perform multiple operations simultaneously with
+        multiple drives.)
+   <li> Scan for available Drives.
+   <li> Choose and grab a Drive for reading/writing.
+   <li> Fill in the options for the operation.
+   <li> Wait for the operation to complete, displaying status along the way
+        if desired.
+   <li> Release the Drive.
+   <li> Destroy the library instance. (If you're done working with the
+        library.)
+   </ol>
+
+   Here's a very simple example of burning an ISO file
+
+   @include burniso.c
+*/

doc/doxygen.conf.in

@@ -0,0 +1,186 @@
+# Doxyfile 1.2.18
+
+#---------------------------------------------------------------------------
+# General configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = @PACKAGE_NAME@
+PROJECT_NUMBER         = @PACKAGE_VERSION@
+OUTPUT_DIRECTORY       = 
+OUTPUT_LANGUAGE        = English
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = YES
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        = @top_srcdir@
+INTERNAL_DOCS          = NO
+STRIP_CODE_COMMENTS    = NO
+CASE_SENSE_NAMES       = NO
+SHORT_NAMES            = NO
+HIDE_SCOPE_NAMES       = NO
+VERBATIM_HEADERS       = YES
+SHOW_INCLUDE_FILES     = YES
+JAVADOC_AUTOBRIEF      = YES
+MULTILINE_CPP_IS_BRIEF = YES
+DETAILS_AT_TOP         = YES
+INHERIT_DOCS           = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+DISTRIBUTE_GROUP_DOC   = NO
+TAB_SIZE               = 4
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ALIASES                = 
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_JAVA   = NO
+SHOW_USED_FILES        = YES
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = YES
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = libburn libisofs doc
+FILE_PATTERNS          = libburn.h libisofs.h comments
+RECURSIVE              = NO
+EXCLUDE                = 
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = test
+EXAMPLE_PATTERNS       = 
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = YES
+INLINE_SOURCES         = YES
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION    = YES
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = NO
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = OB OTK _
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = doc/html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            = 
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+CHM_FILE               = 
+HHC_LOCATION           = 
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 4
+GENERATE_TREEVIEW      = NO
+TREEVIEW_WIDTH         = 200
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = letter
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = YES
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+XML_SCHEMA             = 
+XML_DTD                = 
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = 
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = DOXYGEN
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+PERL_PATH              = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = YES
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+TEMPLATE_RELATIONS     = YES
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+GRAPHICAL_HIERARCHY    = NO
+DOT_IMAGE_FORMAT       = png
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO

libburn-1.pc.in

@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libburn
+Description: Disc reading/writing library
+Version: @VERSION@
+Requires: 
+Libs: -L${libdir} -lburn @THREAD_LIBS@
+Cflags: -I${includedir}/libburn/@BURN_MAJOR_VERSION@

libburn/Makefile

@@ -0,0 +1,4 @@
+all clean:
+	$(MAKE) -C .. -$(MAKEFLAGS) $@
+
+.PHONY: all clean

libburn/Makefile.am

@@ -0,0 +1,65 @@
+pkgconfigdir=$(libdir)/pkgconfig
+libincludedir=$(includedir)/libburn/@BURN_MAJOR_VERSION@
+
+lib_LTLIBRARIES = libburn.la
+
+libburn_la_SOURCES = \
+	async.c \
+	async.h \
+	crc.c \
+	crc.h \
+	debug.c \
+	debug.h \
+	drive.c \
+	drive.h \
+	file.c \
+	file.h \
+	init.c \
+	init.h \
+	lec.c \
+	lec.h \
+	message.c \
+	message.h \
+	mmc.c \
+	mmc.h \
+	null.c \
+	null.h \
+	options.c \
+	options.h \
+	read.c \
+	read.h \
+	sbc.c \
+	sbc.h \
+	sector.c \
+	sector.h \
+	sg.c \
+	sg.h \
+	spc.c \
+	spc.h \
+	source.h \
+	source.c \
+	structure.c \
+	structure.h \
+	toc.c \
+	toc.h \
+	transport.h \
+	util.c \
+	util.h \
+	write.c \
+	write.h
+
+libinclude_HEADERS = libburn.h
+
+## ========================================================================= ##
+indent_files = $(libburn_la_SOURCES) 
+
+indent: $(indent_files)
+	indent -bad -bap -nbbb -nbbo -nbc -bli0 -br -bls   \
+	       -cdw -ce -cli0 -ncs -nbfda -i8 -l79 -lc79   \
+	       -lp -saf -sai -nprs -npsl -saw -sob -ss -ut \
+	       -sbi0 -nsc -ts8 -npcs -ncdb -fca            \
+	       $^
+
+.PHONY: indent
+
+## ========================================================================= ##

libburn/async.c

@@ -0,0 +1,191 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#include "libburn.h"
+#include "transport.h"
+#include "drive.h"
+#include "write.h"
+#include "options.h"
+#include "async.h"
+
+#include <pthread.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#define SCAN_GOING() (workers && !workers->drive)
+
+typedef void *(*WorkerFunc) (void *);
+
+struct scan_opts
+{
+	struct burn_drive_info **drives;
+	unsigned int *n_drives;
+
+	int done;
+};
+
+struct erase_opts
+{
+	struct burn_drive *drive;
+	int fast;
+};
+
+struct write_opts
+{
+	struct burn_drive *drive;
+	struct burn_write_opts *opts;
+	struct burn_disc *disc;
+};
+
+struct w_list
+{
+	struct burn_drive *drive;
+	pthread_t thread;
+
+	struct w_list *next;
+
+	union w_list_data
+	{
+		struct scan_opts scan;
+		struct erase_opts erase;
+		struct write_opts write;
+	} u;
+};
+
+static struct w_list *workers;
+
+static struct w_list *find_worker(struct burn_drive *d)
+{
+	struct w_list *a;
+
+	for (a = workers; a; a = a->next)
+		if (a->drive == d)
+			return a;
+	return NULL;
+}
+
+static void add_worker(struct burn_drive *d, WorkerFunc f, void *data)
+{
+	struct w_list *a;
+	struct w_list *tmp;
+
+	a = malloc(sizeof(struct w_list));
+	a->drive = d;
+	a->u = *(union w_list_data *)data;
+
+	/* insert at front of the list */
+	a->next = workers;
+	tmp = workers;
+	workers = a;
+
+	if (d)
+		d->busy = BURN_DRIVE_SPAWNING;
+
+	if (pthread_create(&a->thread, NULL, f, a)) {
+		free(a);
+		workers = tmp;
+		return;
+	}
+}
+
+static void remove_worker(pthread_t th)
+{
+	struct w_list *a, *l = NULL;
+
+	for (a = workers; a; l = a, a = a->next)
+		if (a->thread == th) {
+			if (l)
+				l->next = a->next;
+			else
+				workers = a->next;
+			free(a);
+			break;
+		}
+	assert(a != NULL);	/* wasn't found.. this should not be possible */
+}
+
+static void *scan_worker_func(struct w_list *w)
+{
+	burn_drive_scan_sync(w->u.scan.drives, w->u.scan.n_drives);
+	w->u.scan.done = 1;
+	return NULL;
+}
+
+int burn_drive_scan(struct burn_drive_info *drives[], unsigned int *n_drives)
+{
+	struct scan_opts o;
+	int ret = 0;
+
+	/* cant be anything working! */
+	assert(!(workers && workers->drive));
+
+	if (!workers) {
+		/* start it */
+		o.drives = drives;
+		o.n_drives = n_drives;
+		o.done = 0;
+		add_worker(NULL, (WorkerFunc) scan_worker_func, &o);
+	} else if (workers->u.scan.done) {
+		/* its done */
+		ret = workers->u.scan.done;
+		remove_worker(workers->thread);
+		assert(workers == NULL);
+	} else {
+		/* still going */
+	}
+	return ret;
+}
+
+static void *erase_worker_func(struct w_list *w)
+{
+	burn_disc_erase_sync(w->u.erase.drive, w->u.erase.fast);
+	remove_worker(pthread_self());
+	return NULL;
+}
+
+void burn_disc_erase(struct burn_drive *drive, int fast)
+{
+	struct erase_opts o;
+
+	assert(drive);
+	assert(!SCAN_GOING());
+	assert(!find_worker(drive));
+
+	o.drive = drive;
+	o.fast = fast;
+	add_worker(drive, (WorkerFunc) erase_worker_func, &o);
+}
+
+static void *write_disc_worker_func(struct w_list *w)
+{
+	burn_disc_write_sync(w->u.write.opts, w->u.write.disc);
+
+	/* the options are refcounted, free out ref count which we added below 
+	 */
+	burn_write_opts_free(w->u.write.opts);
+
+	remove_worker(pthread_self());
+	return NULL;
+}
+
+void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
+{
+	struct write_opts o;
+
+	assert(!SCAN_GOING());
+	assert(!find_worker(opts->drive));
+	o.drive = opts->drive;
+	o.opts = opts;
+	o.disc = disc;
+
+	opts->refcount++;
+
+	add_worker(opts->drive, (WorkerFunc) write_disc_worker_func, &o);
+}
+
+void burn_async_join_all(void)
+{
+	void *ret;
+
+	while (workers)
+		pthread_join(workers->thread, &ret);
+}

libburn/async.h

@@ -0,0 +1,8 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#ifndef BURN__ASYNC_H
+#define BURN__ASYNC_H
+
+void burn_async_join_all(void);
+struct burn_write_opts;
+#endif /* BURN__ASYNC_H */

libburn/crc.c

@@ -0,0 +1,122 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#include "crc.h"
+
+static unsigned short ccitt_table[256] = {
+	0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
+	0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
+	0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
+	0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
+	0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
+	0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
+	0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
+	0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
+	0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
+	0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
+	0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
+	0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
+	0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
+	0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
+	0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
+	0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
+	0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
+	0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
+	0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
+	0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
+	0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
+	0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+	0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
+	0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
+	0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
+	0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
+	0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
+	0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
+	0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
+	0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
+	0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
+	0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
+};
+
+unsigned long crc32_table[256] = {
+	0x00000000L, 0x90910101L, 0x91210201L, 0x01B00300L,
+	0x92410401L, 0x02D00500L, 0x03600600L, 0x93F10701L,
+	0x94810801L, 0x04100900L, 0x05A00A00L, 0x95310B01L,
+	0x06C00C00L, 0x96510D01L, 0x97E10E01L, 0x07700F00L,
+	0x99011001L, 0x09901100L, 0x08201200L, 0x98B11301L,
+	0x0B401400L, 0x9BD11501L, 0x9A611601L, 0x0AF01700L,
+	0x0D801800L, 0x9D111901L, 0x9CA11A01L, 0x0C301B00L,
+	0x9FC11C01L, 0x0F501D00L, 0x0EE01E00L, 0x9E711F01L,
+	0x82012001L, 0x12902100L, 0x13202200L, 0x83B12301L,
+	0x10402400L, 0x80D12501L, 0x81612601L, 0x11F02700L,
+	0x16802800L, 0x86112901L, 0x87A12A01L, 0x17302B00L,
+	0x84C12C01L, 0x14502D00L, 0x15E02E00L, 0x85712F01L,
+	0x1B003000L, 0x8B913101L, 0x8A213201L, 0x1AB03300L,
+	0x89413401L, 0x19D03500L, 0x18603600L, 0x88F13701L,
+	0x8F813801L, 0x1F103900L, 0x1EA03A00L, 0x8E313B01L,
+	0x1DC03C00L, 0x8D513D01L, 0x8CE13E01L, 0x1C703F00L,
+	0xB4014001L, 0x24904100L, 0x25204200L, 0xB5B14301L,
+	0x26404400L, 0xB6D14501L, 0xB7614601L, 0x27F04700L,
+	0x20804800L, 0xB0114901L, 0xB1A14A01L, 0x21304B00L,
+	0xB2C14C01L, 0x22504D00L, 0x23E04E00L, 0xB3714F01L,
+	0x2D005000L, 0xBD915101L, 0xBC215201L, 0x2CB05300L,
+	0xBF415401L, 0x2FD05500L, 0x2E605600L, 0xBEF15701L,
+	0xB9815801L, 0x29105900L, 0x28A05A00L, 0xB8315B01L,
+	0x2BC05C00L, 0xBB515D01L, 0xBAE15E01L, 0x2A705F00L,
+	0x36006000L, 0xA6916101L, 0xA7216201L, 0x37B06300L,
+	0xA4416401L, 0x34D06500L, 0x35606600L, 0xA5F16701L,
+	0xA2816801L, 0x32106900L, 0x33A06A00L, 0xA3316B01L,
+	0x30C06C00L, 0xA0516D01L, 0xA1E16E01L, 0x31706F00L,
+	0xAF017001L, 0x3F907100L, 0x3E207200L, 0xAEB17301L,
+	0x3D407400L, 0xADD17501L, 0xAC617601L, 0x3CF07700L,
+	0x3B807800L, 0xAB117901L, 0xAAA17A01L, 0x3A307B00L,
+	0xA9C17C01L, 0x39507D00L, 0x38E07E00L, 0xA8717F01L,
+	0xD8018001L, 0x48908100L, 0x49208200L, 0xD9B18301L,
+	0x4A408400L, 0xDAD18501L, 0xDB618601L, 0x4BF08700L,
+	0x4C808800L, 0xDC118901L, 0xDDA18A01L, 0x4D308B00L,
+	0xDEC18C01L, 0x4E508D00L, 0x4FE08E00L, 0xDF718F01L,
+	0x41009000L, 0xD1919101L, 0xD0219201L, 0x40B09300L,
+	0xD3419401L, 0x43D09500L, 0x42609600L, 0xD2F19701L,
+	0xD5819801L, 0x45109900L, 0x44A09A00L, 0xD4319B01L,
+	0x47C09C00L, 0xD7519D01L, 0xD6E19E01L, 0x46709F00L,
+	0x5A00A000L, 0xCA91A101L, 0xCB21A201L, 0x5BB0A300L,
+	0xC841A401L, 0x58D0A500L, 0x5960A600L, 0xC9F1A701L,
+	0xCE81A801L, 0x5E10A900L, 0x5FA0AA00L, 0xCF31AB01L,
+	0x5CC0AC00L, 0xCC51AD01L, 0xCDE1AE01L, 0x5D70AF00L,
+	0xC301B001L, 0x5390B100L, 0x5220B200L, 0xC2B1B301L,
+	0x5140B400L, 0xC1D1B501L, 0xC061B601L, 0x50F0B700L,
+	0x5780B800L, 0xC711B901L, 0xC6A1BA01L, 0x5630BB00L,
+	0xC5C1BC01L, 0x5550BD00L, 0x54E0BE00L, 0xC471BF01L,
+	0x6C00C000L, 0xFC91C101L, 0xFD21C201L, 0x6DB0C300L,
+	0xFE41C401L, 0x6ED0C500L, 0x6F60C600L, 0xFFF1C701L,
+	0xF881C801L, 0x6810C900L, 0x69A0CA00L, 0xF931CB01L,
+	0x6AC0CC00L, 0xFA51CD01L, 0xFBE1CE01L, 0x6B70CF00L,
+	0xF501D001L, 0x6590D100L, 0x6420D200L, 0xF4B1D301L,
+	0x6740D400L, 0xF7D1D501L, 0xF661D601L, 0x66F0D700L,
+	0x6180D800L, 0xF111D901L, 0xF0A1DA01L, 0x6030DB00L,
+	0xF3C1DC01L, 0x6350DD00L, 0x62E0DE00L, 0xF271DF01L,
+	0xEE01E001L, 0x7E90E100L, 0x7F20E200L, 0xEFB1E301L,
+	0x7C40E400L, 0xECD1E501L, 0xED61E601L, 0x7DF0E700L,
+	0x7A80E800L, 0xEA11E901L, 0xEBA1EA01L, 0x7B30EB00L,
+	0xE8C1EC01L, 0x7850ED00L, 0x79E0EE00L, 0xE971EF01L,
+	0x7700F000L, 0xE791F101L, 0xE621F201L, 0x76B0F300L,
+	0xE541F401L, 0x75D0F500L, 0x7460F600L, 0xE4F1F701L,
+	0xE381F801L, 0x7310F900L, 0x72A0FA00L, 0xE231FB01L,
+	0x71C0FC00L, 0xE151FD01L, 0xE0E1FE01L, 0x7070FF00L
+};
+
+unsigned short crc_ccitt(unsigned char *q, int len)
+{
+	unsigned short crc = 0;
+
+	while (len-- > 0)
+		crc = ccitt_table[(crc >> 8 ^ *q++) & 0xff] ^ (crc << 8);
+	return ~crc;
+}
+unsigned int crc_32(unsigned char *data, int len)
+{
+	unsigned int crc = 0;
+
+	while (len-- > 0)
+		crc = crc32_table[(crc ^ *data++) & 0xffL] ^ (crc >> 8);
+	return crc;
+}

libburn/crc.h

@@ -0,0 +1,9 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#ifndef BURN__CRC_H
+#define BURN__CRC_H
+
+unsigned short crc_ccitt(unsigned char *, int len);
+unsigned int crc_32(unsigned char *, int len);
+
+#endif /* BURN__CRC_H */

libburn/debug.c

@@ -0,0 +1,35 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "libburn.h"
+#include "debug.h"
+
+static int burn_verbosity = 0;
+
+void burn_set_verbosity(int v)
+{
+	burn_verbosity = v;
+}
+
+void burn_print(int level, const char *a, ...)
+{
+#ifdef WIN32
+	char debug_string_data[256];
+#endif
+	va_list vl;
+
+	if (level <= burn_verbosity) {
+		va_start(vl, a);
+#ifdef WIN32
+		vsprintf(debug_string_data, a, vl);
+		OutputDebugString(debug_string_data);
+#else
+		vfprintf(stderr, a, vl);
+#endif
+	}
+}

libburn/debug.h

@@ -0,0 +1,8 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#ifndef BURN__DEBUG_H
+#define BURN__DEBUG_H
+
+void burn_print(int level, const char *a, ...);
+
+#endif /* BURN__DEBUG_H */

libburn/drive.c

@@ -0,0 +1,369 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#include <malloc.h>
+#include <unistd.h>
+#include <signal.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <pthread.h>
+#include "libburn.h"
+#include "drive.h"
+#include "transport.h"
+#include "message.h"
+#include "debug.h"
+#include "init.h"
+#include "toc.h"
+#include "util.h"
+#include "sg.h"
+#include "structure.h"
+
+static struct burn_drive drive_array[255];
+static int drivetop = -1;
+
+void burn_drive_free(void)
+{
+	int i;
+	struct burn_drive *d;
+
+	for (i = 0; i < drivetop + 1; i++) {
+		d = &drive_array[i];
+		free((void *)d->idata);
+		free((void *)d->mdata);
+		free((void *)d->toc_entry);
+		free(d->devname);
+	}
+	drivetop = -1;
+	memset(drive_array, 0, sizeof(drive_array));
+}
+
+/*
+void drive_read_lead_in(int dnum)
+{
+	mmc_read_lead_in(&drive_array[dnum], get_4k());
+}
+*/
+unsigned int burn_drive_count(void)
+{
+	return drivetop + 1;
+}
+
+int burn_drive_grab(struct burn_drive *d, int le)
+{
+	int errcode;
+
+	if (!d->released) {
+		burn_print(1, "can't grab - already grabbed\n");
+		return 0;
+	}
+	errcode = d->grab(d);
+
+	if (errcode == 0) {
+		burn_print(1, "low level drive grab failed\n");
+		return 0;
+	}
+	d->busy = BURN_DRIVE_GRABBING;
+
+	if (le)
+		d->load(d);
+
+	d->lock(d);
+	d->status = BURN_DISC_BLANK;
+	if (d->mdata->cdr_write || d->mdata->cdrw_write ||
+	    d->mdata->dvdr_write || d->mdata->dvdram_write) {
+		d->read_disc_info(d);
+	} else
+		d->read_toc(d);
+	d->busy = BURN_DRIVE_IDLE;
+	return 1;
+}
+
+struct burn_drive *burn_drive_register(struct burn_drive *d)
+{
+	d->block_types[0] = 0;
+	d->block_types[1] = 0;
+	d->block_types[2] = 0;
+	d->block_types[3] = 0;
+	d->toc_temp = 0;
+	d->nwa = 0;
+	d->alba = 0;
+	d->rlba = 0;
+	d->cancel = 0;
+	d->busy = BURN_DRIVE_IDLE;
+	d->toc_entries = 0;
+	d->toc_entry = NULL;
+	d->disc = NULL;
+	d->erasable = 0;
+	memcpy(&drive_array[drivetop + 1], d, sizeof(struct burn_drive));
+	pthread_mutex_init(&drive_array[drivetop + 1].access_lock, NULL);
+	return &drive_array[++drivetop];
+}
+
+void burn_drive_release(struct burn_drive *d, int le)
+{
+	if (d->released)
+		burn_print(1, "second release on drive!\n");
+	assert(!d->busy);
+	if (le)
+		d->eject(d);
+	d->unlock(d);
+
+	d->release(d);
+
+	d->status = BURN_DISC_UNREADY;
+	d->released = 1;
+	if (d->toc_entry)
+		free(d->toc_entry);
+	d->toc_entry = NULL;
+	d->toc_entries = 0;
+	if (d->disc != NULL) {
+		burn_disc_free(d->disc);
+		d->disc = NULL;
+	}
+}
+
+void burn_wait_all(void)
+{
+	unsigned int i;
+	int finished = 0;
+	struct burn_drive *d;
+
+	while (!finished) {
+		finished = 1;
+		d = drive_array;
+		for (i = burn_drive_count(); i > 0; --i, ++d) {
+			assert(d->released);
+		}
+		if (!finished)
+			sleep(1);
+	}
+}
+
+void burn_disc_erase_sync(struct burn_drive *d, int fast)
+{
+	burn_message_clear_queue();
+
+	burn_print(1, "erasing drive %s %s\n", d->idata->vendor,
+		   d->idata->product);
+
+	if (d->status != BURN_DISC_FULL)
+		return;
+	d->cancel = 0;
+	d->busy = BURN_DRIVE_ERASING;
+	d->erase(d, fast);
+	/* reset the progress */
+	d->progress.session = 0;
+	d->progress.sessions = 1;
+	d->progress.track = 0;
+	d->progress.tracks = 1;
+	d->progress.index = 0;
+	d->progress.indices = 1;
+	d->progress.start_sector = 0;
+	d->progress.sectors = 0x10000;
+	d->progress.sector = 0;
+	/* read the initial 0 stage */
+	while (!d->test_unit_ready(d) && d->get_erase_progress(d) == 0)
+		sleep(1);
+	while (!d->test_unit_ready(d) &&
+	       (d->progress.sector = d->get_erase_progress(d)) > 0)
+		sleep(1);
+	d->progress.sector = 0x10000;
+	d->busy = BURN_DRIVE_IDLE;
+}
+
+enum burn_disc_status burn_disc_get_status(struct burn_drive *d)
+{
+	assert(!d->released);
+	return d->status;
+}
+
+int burn_disc_erasable(struct burn_drive *d)
+{
+	return d->erasable;
+}
+enum burn_drive_status burn_drive_get_status(struct burn_drive *d,
+					     struct burn_progress *p)
+{
+	if (p) {
+		memcpy(p, &(d->progress), sizeof(struct burn_progress));
+		/* TODO: add mutex */
+	}
+	return d->busy;
+}
+
+void burn_drive_cancel(struct burn_drive *d)
+{
+	pthread_mutex_lock(&d->access_lock);
+	d->cancel = 1;
+	pthread_mutex_unlock(&d->access_lock);
+}
+
+int burn_drive_get_block_types(struct burn_drive *d,
+			       enum burn_write_types write_type)
+{
+	burn_print(12, "write type: %d\n", write_type);
+	assert(			/* (write_type >= BURN_WRITE_PACKET) && */
+		      (write_type <= BURN_WRITE_RAW));
+	return d->block_types[write_type];
+}
+
+static void strip_spaces(char *str)
+{
+	char *tmp;
+
+	tmp = str + strlen(str) - 1;
+	while (isspace(*tmp))
+		*(tmp--) = '\0';
+
+	tmp = str;
+	while (*tmp) {
+		if (isspace(*tmp) && isspace(*(tmp + 1))) {
+			char *tmp2;
+
+			for (tmp2 = tmp + 1; *tmp2; ++tmp2)
+				*(tmp2 - 1) = *tmp2;
+			*(tmp2 - 1) = '\0';
+		} else
+			++tmp;
+	}
+}
+
+static int drive_getcaps(struct burn_drive *d, struct burn_drive_info *out)
+{
+	struct scsi_inquiry_data *id;
+
+	assert(d->idata);
+	assert(d->mdata);
+	if (!d->idata->valid || !d->mdata->valid)
+		return 0;
+
+	id = (struct scsi_inquiry_data *)d->idata;
+
+	memcpy(out->vendor, id->vendor, sizeof(id->vendor));
+	strip_spaces(out->vendor);
+	memcpy(out->product, id->product, sizeof(id->product));
+	strip_spaces(out->product);
+	memcpy(out->revision, id->revision, sizeof(id->revision));
+	strip_spaces(out->revision);
+	strncpy(out->location, d->devname, 16);
+	out->location[16] = '\0';
+	out->buffer_size = d->mdata->buffer_size;
+	out->read_dvdram = !!d->mdata->dvdram_read;
+	out->read_dvdr = !!d->mdata->dvdr_read;
+	out->read_dvdrom = !!d->mdata->dvdrom_read;
+	out->read_cdr = !!d->mdata->cdr_read;
+	out->read_cdrw = !!d->mdata->cdrw_read;
+	out->write_dvdram = !!d->mdata->dvdram_write;
+	out->write_dvdr = !!d->mdata->dvdr_write;
+	out->write_cdr = !!d->mdata->cdr_write;
+	out->write_cdrw = !!d->mdata->cdrw_write;
+	out->write_simulate = !!d->mdata->simulate;
+	out->c2_errors = !!d->mdata->c2_pointers;
+	out->drive = d;
+	/* update available block types for burners */
+	if (out->write_dvdram || out->write_dvdr ||
+	    out->write_cdrw || out->write_cdr)
+		d->probe_write_modes(d);
+	out->tao_block_types = d->block_types[BURN_WRITE_TAO];
+	out->sao_block_types = d->block_types[BURN_WRITE_SAO];
+	out->raw_block_types = d->block_types[BURN_WRITE_RAW];
+	out->packet_block_types = d->block_types[BURN_WRITE_PACKET];
+	return 1;
+}
+
+int burn_drive_scan_sync(struct burn_drive_info *drives[],
+			 unsigned int *n_drives)
+{
+	/* state vars for the scan process */
+	static int scanning = 0, scanned, found;
+	static unsigned num_scanned, count;
+	unsigned int i;
+	struct burn_drive *d;
+
+	assert(burn_running);
+
+	if (!scanning) {
+		scanning = 1;
+		/* make sure the drives aren't in use */
+		burn_wait_all();	/* make sure the queue cleans up
+					   before checking for the released
+					   state */
+
+		d = drive_array;
+		count = burn_drive_count();
+		for (i = 0; i < count; ++i, ++d)
+			assert(d->released == 1);
+
+		/* refresh the lib's drives */
+		sg_enumerate();
+		ata_enumerate();
+		count = burn_drive_count();
+		if (count)
+			*drives =
+				malloc(sizeof(struct burn_drive_info) * count);
+		else
+			*drives = NULL;
+		*n_drives = scanned = found = num_scanned = 0;
+	}
+
+	for (i = 0; i < count; ++i) {
+		if (scanned & (1 << i))
+			continue;	/* already scanned the device */
+
+		while (!drive_getcaps(&drive_array[i],
+				      &(*drives)[num_scanned])) {
+			sleep(1);
+		}
+		scanned |= 1 << i;
+		found |= 1 << i;
+		num_scanned++;
+		(*n_drives)++;
+	}
+
+	if (num_scanned == count) {
+		/* done scanning */
+		scanning = 0;
+		return 1;
+	}
+	return 0;
+}
+
+void burn_drive_info_free(struct burn_drive_info *info)
+{
+	free(info);
+	burn_drive_free();
+}
+
+struct burn_disc *burn_drive_get_disc(struct burn_drive *d)
+{
+	d->disc->refcnt++;
+	return d->disc;
+}
+
+void burn_drive_set_speed(struct burn_drive *d, int r, int w)
+{
+	d->set_speed(d, r, w);
+}
+
+int burn_msf_to_sectors(int m, int s, int f)
+{
+	return (m * 60 + s) * 75 + f;
+}
+
+void burn_sectors_to_msf(int sectors, int *m, int *s, int *f)
+{
+	*m = sectors / (60 * 75);
+	*s = (sectors - *m * 60 * 75) / 75;
+	*f = sectors - *m * 60 * 75 - *s * 75;
+}
+
+int burn_drive_get_read_speed(struct burn_drive *d)
+{
+	return d->mdata->max_read_speed;
+}
+
+int burn_drive_get_write_speed(struct burn_drive *d)
+{
+	return d->mdata->max_write_speed;
+}

libburn/drive.h

@@ -0,0 +1,53 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#ifndef __DRIVE
+#define __DRIVE
+
+#include "libburn.h"
+#include "toc.h"
+#include "structure.h"
+
+struct burn_drive;
+struct command;
+struct mempage;
+
+#define LEAD_IN 1
+#define GAP 2
+#define USER_DATA 3
+#define LEAD_OUT 4
+#define SYNC 5
+
+#define SESSION_LEADOUT_ENTRY(d,s) (d)->toc->session[(s)].leadout_entry
+
+#define CURRENT_SESSION_START(d) \
+	burn_msf_to_lba(d->toc->session[d->currsession].start_m, \
+	                   d->toc->session[d->currsession].start_s, \
+	                   d->toc->session[d->currsession].start_f)
+
+#define SESSION_END(d,s) \
+	TOC_ENTRY_PLBA((d)->toc, SESSION_LEADOUT_ENTRY((d), (s)))
+
+#define PREVIOUS_SESSION_END(d) \
+	TOC_ENTRY_PLBA((d)->toc, SESSION_LEADOUT_ENTRY((d), (d)->currsession-1))
+
+#define LAST_SESSION_END(d) \
+	TOC_ENTRY_PLBA((d)->toc, \
+	               SESSION_LEADOUT_ENTRY((d), (d)->toc->sessions-1))
+
+struct burn_drive *burn_drive_register(struct burn_drive *);
+
+unsigned int burn_drive_count(void);
+void burn_wait_all(void);
+int burn_sector_length_write(struct burn_drive *d);
+int burn_track_control(struct burn_drive *d, int);
+void burn_write_empty_sector(int fd);
+void burn_write_empty_subcode(int fd);
+void burn_drive_free(void);
+
+int burn_drive_scan_sync(struct burn_drive_info *drives[],
+			 unsigned int *n_drives);
+void burn_disc_erase_sync(struct burn_drive *d, int fast);
+int burn_drive_get_block_types(struct burn_drive *d,
+			       enum burn_write_types write_type);
+
+#endif /* __DRIVE */

libburn/error.h

@@ -0,0 +1,8 @@
+/* -*- indent-tabs-mode; t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#ifndef __ERROR_H
+#define __ERROR_H
+
+#define BE_CANCELLED 1
+
+#endif /* __ERROR_H */

libburn/file.c

@@ -0,0 +1,187 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include "source.h"
+#include "libburn.h"
+#include "file.h"
+
+/* main channel data can be padded on read, but 0 padding the subs will make
+an unreadable disc */
+
+
+/* This is a generic OS oriented function wrapper which compensates
+   shortcommings of read() in respect to a guaranteed amount of return data.
+   See  man 2 read , paragraph "RETURN VALUE".
+   Possibly libburn/file.c is not the right storage location for this.
+   To make it ready for a move, this function is not declared static.
+*/
+static int read_full_buffer(int fd, unsigned char *buffer, int size)
+{
+	int ret,summed_ret = 0;
+
+	/* make safe against partial buffer returns */
+	while (1) {
+		ret = read(fd, buffer + summed_ret, size - summed_ret);
+		if (ret <= 0)
+	break;
+		summed_ret += ret;
+		if (summed_ret >= size)
+	break;
+	}
+	if (ret < 0)		 /* error encountered. abort immediately */
+		return ret;
+	return summed_ret;
+}
+
+
+static int file_read(struct burn_source *source,
+		     unsigned char *buffer,
+		     int size)
+{
+	struct burn_source_fd *fs = source->data;
+
+	return read_full_buffer(fs->datafd, buffer, size);
+}
+
+static int file_read_sub(struct burn_source *source,
+			 unsigned char *buffer,
+			 int size)
+{
+	struct burn_source_file *fs = source->data;
+
+	return read_full_buffer(fs->subfd, buffer, size);
+}
+
+static void file_free(struct burn_source *source)
+{
+	struct burn_source_file *fs = source->data;
+
+	close(fs->datafd);
+	if (source->read_sub)
+		close(fs->subfd);
+	free(fs);
+}
+
+static off_t file_size(struct burn_source *source)
+{
+	struct stat buf;
+	struct burn_source_file *fs = source->data;
+
+	if (fstat(fs->datafd, &buf) == -1)
+		return (off_t) 0;
+	/* for now we keep it compatible to the old (int) return value */
+	if(buf.st_size >= 1308622848)  /* 2 GB - 800 MB to prevent rollover */ 
+		return (off_t) 1308622848;
+	return (off_t) buf.st_size;
+}
+
+struct burn_source *burn_file_source_new(const char *path, const char *subpath)
+{
+	struct burn_source_file *fs;
+	struct burn_source *src;
+	int fd1, fd2 = 0;
+
+	if (!path)
+		return NULL;
+	fd1 = open(path, O_RDONLY);
+	if (fd1 == -1)
+		return NULL;
+	if (subpath) {
+		fd2 = open(subpath, O_RDONLY);
+		if (fd2 == -1) {
+			close(fd1);
+			return NULL;
+		}
+	}
+	fs = malloc(sizeof(struct burn_source_file));
+	fs->datafd = fd1;
+
+	if (subpath)
+		fs->subfd = fd2;
+
+	src = burn_source_new();
+	src->read = file_read;
+	if (subpath)
+		src->read_sub = file_read_sub;
+
+	src->get_size = file_size;
+	src->free_data = file_free;
+	src->data = fs;
+	return src;
+}
+
+
+/* ------ provisory location for the new source subclass fd --------- */
+
+static off_t fd_get_size(struct burn_source *source)
+{
+	struct stat buf;
+	struct burn_source_fd *fs = source->data;
+
+	if (fs->fixed_size > 0)
+		return fs->fixed_size;
+	if (fstat(fs->datafd, &buf) == -1)
+		return (off_t) 0;
+	/* for now we keep it compatible to the old (int) return value */
+	if (buf.st_size >= 1308622848) /* 2 GB - 800 MB to prevent rollover */
+		return (off_t) 1308622848;
+	return buf.st_size;
+}
+
+static int fd_read(struct burn_source *source,
+		     unsigned char *buffer,
+		     int size)
+{
+	struct burn_source_fd *fs = source->data;
+
+	return read_full_buffer(fs->datafd, buffer, size);
+}
+
+
+static int fd_read_sub(struct burn_source *source,
+		     unsigned char *buffer,
+		     int size)
+{
+	struct burn_source_fd *fs = source->data;
+
+	return read_full_buffer(fs->subfd, buffer, size);
+}
+
+
+static void fd_free_data(struct burn_source *source)
+{
+	struct burn_source_fd *fs = source->data;
+
+	close(fs->datafd);
+	if (source->read_sub)
+		close(fs->subfd);
+	free(fs);
+}
+
+
+struct burn_source *burn_fd_source_new(int datafd, int subfd, off_t size)
+{
+	struct burn_source_fd *fs;
+	struct burn_source *src;
+
+	if (datafd == -1)
+		return NULL;
+	fs = malloc(sizeof(struct burn_source_fd));
+	fs->datafd = datafd;
+	fs->subfd = subfd;
+	fs->fixed_size = size;
+
+	src = burn_source_new();
+	src->read = fd_read;
+	if(subfd != -1)
+		src->read = fd_read_sub;
+	src->get_size = fd_get_size;
+	src->free_data = fd_free_data;
+	src->data = fs;
+	return src;
+}
+

libburn/file.h

@@ -0,0 +1,22 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#ifndef BURN__FILE_H
+#define BURN__FILE_H
+
+struct burn_source_file
+{
+	int datafd;
+	int subfd;
+};
+
+
+/* ------ provisory location for the new source subclass fd --------- */
+
+struct burn_source_fd
+{
+	int datafd;
+	int subfd;
+	off_t fixed_size;
+};
+
+#endif /* LIBBURN__FILE_H */

libburn/init.c

@@ -0,0 +1,33 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#include <unistd.h>
+#include <assert.h>
+#include <stdio.h>
+#include <signal.h>
+#include "init.h"
+#include "sg.h"
+#include "error.h"
+#include "libburn.h"
+#include "drive.h"
+
+int burn_running = 0;
+
+int burn_initialize(void)
+{
+	if (burn_running)
+		return 1;
+
+	burn_running = 1;
+	return 1;
+}
+
+void burn_finish(void)
+{
+	assert(burn_running);
+
+	burn_wait_all();
+
+	burn_drive_free();
+
+	burn_running = 0;
+}

libburn/init.h

@@ -0,0 +1,8 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#ifndef BURN__INIT_H
+#define BURN__INIT_H
+
+extern int burn_running;
+
+#endif /* BURN__INIT_H */

libburn/lec.c

@@ -0,0 +1,451 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+/* borrowed HEAVILY from cdrdao */
+
+#include <string.h>
+#include "lec.h"
+
+#define LEC_HEADER_OFFSET 12