Added abandoned KDE3 version of K3B

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/k3b@1084400 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
author: tpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da> 2010-02-03 02:15:56 +0000
committer: tpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da> 2010-02-03 02:15:56 +0000
commit: 50b48aec6ddd451a6d1709c0942477b503457663 (patch)
tree: a9ece53ec06fd0a2819de7a2a6de997193566626 /libk3bdevice
download: k3b-50b48aec6ddd451a6d1709c0942477b503457663.tar.gz
k3b-50b48aec6ddd451a6d1709c0942477b503457663.zip
35 files changed, 12689 insertions, 0 deletions
diff --git a/libk3bdevice/Makefile.am b/libk3bdevice/Makefile.am
new file mode 100644
index 0000000..bd6aaf8
--- /dev/null
+++ b/libk3bdevice/Makefile.am
@@ -0,0 +1,34 @@
+AM_CPPFLAGS= -I$(srcdir)/libk3bdevice -I$(srcdir) $(all_includes) $(HAL_INCS) $(DBUS_INCS) $(DBUSQT_INCS)
+
+KDE_CXXFLAGS = $(ENABLE_PERMISSIVE_FLAG)
+
+METASOURCES = AUTO
+
+lib_LTLIBRARIES = libk3bdevice.la
+
+libk3bdevice_la_LIBADD = $(LIB_KIO) $(RESMGR_LIB) $(CAM_LIB) $(HAL_DBUS_LIBS)
+
+# lib version 5 for K3b 1.0
+libk3bdevice_la_LDFLAGS = $(all_libraries) -version-info 5:0:0 -no-undefined
+
+if include_HAL
+libk3bdevice_la_SOURCES = k3bdevice.cpp k3bdevice_mmc.cpp k3bscsicommand.cpp \
+k3btrack.cpp k3btoc.cpp k3bdevicemanager.cpp k3bmsf.cpp k3bdiskinfo.cpp \
+k3bdeviceglobals.cpp k3bcrc.cpp k3bcdtext.cpp k3bhalconnection.cpp \
+k3bdebug.cpp
+
+include_HEADERS = k3bdevicemanager.h k3bdevice.h k3btoc.h k3btrack.h \
+k3bdeviceglobals.h k3bdiskinfo.h k3bcdtext.h k3bmsf.h k3bdevicetypes.h \
+k3bdevice_export.h k3bhalconnection.h k3bdebug.h
+else
+libk3bdevice_la_SOURCES = k3bdevice.cpp k3bdevice_mmc.cpp k3bscsicommand.cpp \
+k3btrack.cpp k3btoc.cpp k3bdevicemanager.cpp k3bmsf.cpp k3bdiskinfo.cpp \
+k3bdeviceglobals.cpp k3bcrc.cpp k3bcdtext.cpp k3bdebug.cpp
+
+include_HEADERS = k3bdevicemanager.h k3bdevice.h k3btoc.h k3btrack.h \
+k3bdeviceglobals.h k3bdiskinfo.h k3bcdtext.h k3bmsf.h k3bdevicetypes.h \
+k3bdevice_export.h k3bdebug.h
+endif
+
+messages: rc.cpp
+	$(XGETTEXT) `find -name "*.cpp" -or -name "*.h"` -o $(podir)/libk3bdevice.pot
diff --git a/libk3bdevice/configure.in.bot b/libk3bdevice/configure.in.bot
new file mode 100644
index 0000000..fbb068d
--- /dev/null
+++ b/libk3bdevice/configure.in.bot
@@ -0,0 +1,20 @@
+echo ""
+
+if test -n "$RESMGR_LIB"; then
+	echo "K3b - Resmgr support:                        yes"
+else
+	echo "K3b - Resmgr support:                         no"
+fi
+
+echo ""
+
+
+if test x$have_hal = xyes; then
+	echo "K3b - Compile HAL support                    yes"
+else
+	echo "K3b - Compile HAL support                     no"
+if test "x$ac_cv_use_hal" = "xyes" ; then
+	echo "K3b -     You are missing the HAL >= 0.5 headers and libraries"
+	echo "K3b -     or the DBus Qt bindings."
+fi
+fi
diff --git a/libk3bdevice/configure.in.in b/libk3bdevice/configure.in.in
new file mode 100644
index 0000000..5cabeec
--- /dev/null
+++ b/libk3bdevice/configure.in.in
@@ -0,0 +1,212 @@
+dnl FIXME: only make the linux header check on linux systems.
+
+linux_scsi=no
+AC_MSG_CHECKING(for linux scsi headers)
+AC_LANG_SAVE
+AC_LANG_CPLUSPLUS
+AC_TRY_COMPILE([
+	#include <linux/version.h>
+	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,50)
+	typedef unsigned char u8;
+	#endif
+	#include <sys/types.h>
+	#include <linux/../scsi/scsi.h> /* cope with silly includes */
+	],
+	[],
+	[linux_scsi=yes])
+AC_MSG_RESULT($linux_scsi)
+
+case "$host_os" in
+freebsd*|dragonfly*)
+	# I'll be damned if lousy coding prevents us from running
+	# this application.
+	linux_scsi=yes
+	;;
+esac
+
+if test "x$linux_scsi" = "xno" ; then
+	DO_NOT_COMPILE="$DO_NOT_COMPILE k3b"
+fi
+AC_LANG_RESTORE
+
+dnl - find the cam_* functions
+AC_CHECK_FUNC(cam_close_device,
+	[CAM_LIB=""],
+	[AC_CHECK_LIB(cam, cam_close_device, [CAM_LIB=-lcam], [CAM_LIB=""])]
+	)
+AC_SUBST(CAM_LIB)
+
+
+
+dnl === check for resmgr - begin ============
+AC_ARG_WITH(
+	resmgr, 
+	AS_HELP_STRING([--without-resmgr], [build K3b without ResMgr support (default=no)]), 
+	[ac_cv_use_resmgr=$withval], 
+	[ac_cv_use_resmgr=yes]
+)
+
+if test "$ac_cv_use_resmgr" = "yes"; then
+  RESMGR_LIB=""
+  KDE_CHECK_HEADERS(resmgr.h, [
+         KDE_CHECK_LIB(resmgr,rsm_open_device,[
+                 RESMGR_LIB="-lresmgr"
+                 AC_DEFINE(HAVE_RESMGR,1,[defined if you have resmgr libraries and headers])
+         ])
+  ])
+  AC_SUBST(RESMGR_LIB)
+fi
+dnl === check for resmgr - end ============
+
+
+
+
+
+# HAL check from kdebase/kioslave/media
+
+AC_ARG_WITH(
+	hal, 
+	AS_HELP_STRING(
+		[--without-hal], 
+		[build K3b without HAL support (default=no)]),
+	[ac_cv_use_hal=$withval], 
+	[ac_cv_use_hal=yes]
+)
+
+if test "x$ac_cv_use_hal" = "xyes" ; then
+
+########### Check for the HAL
+
+  AC_MSG_CHECKING(for the HAL)
+
+  hal_inc=NOTFOUND
+  hal_lib=NOTFOUND
+  hal=NOTFOUND
+
+  search_incs="$kde_includes /usr/include /usr/include/hal /usr/local/include /usr/local/include/hal"
+  AC_FIND_FILE(libhal.h libhal-storage.h, $search_incs, hal_incdir)
+
+  if [test -r $hal_incdir/libhal.h] ; then
+    HAL_INCS="-I$hal_incdir"
+    hal_inc=FOUND
+  fi
+
+  if test -r $hal_incdir/libhal-storage.h ; then
+    hal_storage_version=4
+    grep LibHalVolume $hal_incdir/libhal-storage.h \
+    > /dev/null 2>&1 && hal_storage_version=5
+    if test $hal_storage_version = 4 ; then
+      AC_DEFINE(HAL_0_4, , [HAL API version 0.4])
+    fi
+  fi
+
+  search_libs="$kde_libraries /usr/lib64 /usr/lib /usr/local/lib /lib /lib64"
+  AC_FIND_FILE(libhal.so, $search_libs, hal_libdir)
+
+  if [test -r $hal_libdir/libhal.so] ; then
+    HAL_LIBS="-L$hal_libdir -lhal"
+    hal_lib=FOUND
+  fi
+
+
+  if [test $hal_inc = FOUND] && [test $hal_lib = FOUND] ; then
+      AC_MSG_RESULT(headers $hal_incdir  libraries $hal_libdir)
+  	hal=FOUND
+  else
+      AC_MSG_RESULT(searched but not found)
+  fi
+
+  AC_SUBST(HAL_INCS)
+  AC_SUBST(HAL_LIBS)
+
+
+########### Check for DBus
+
+  AC_MSG_CHECKING(for DBus)
+
+  dbus_inc=NOTFOUND
+  dbus_lib=NOTFOUND
+  dbus=NOTFOUND
+
+  search_incs="$kde_includes /usr/include /usr/include/dbus-1.0 /usr/local/include /usr/local/include/dbus-1.0"
+  AC_FIND_FILE(dbus/dbus.h, $search_incs, dbus_incdir)
+
+  search_incs_arch_deps="$kde_includes /usr/lib64/dbus-1.0/include /usr/lib/dbus-1.0/include /usr/local/lib/dbus-1.0/include"
+  AC_FIND_FILE(dbus/dbus-arch-deps.h, $search_incs_arch_deps, dbus_incdir_arch_deps)
+
+  if [test -r $dbus_incdir/dbus/dbus.h] && [test -r $dbus_incdir_arch_deps/dbus/dbus-arch-deps.h] ; then
+    DBUS_INCS="-I$dbus_incdir -I$dbus_incdir_arch_deps"
+    dbus_inc=FOUND
+  fi
+
+  search_libs="$kde_libraries /usr/lib64 /usr/lib /usr/local/lib /lib /lib64"
+  AC_FIND_FILE(libdbus-1.so, $search_libs, dbus_libdir)
+
+  if test -r $dbus_libdir/libdbus-1.so ; then
+    DBUS_LIBS="-L$dbus_libdir -ldbus-1"
+    dbus_lib=FOUND
+  fi
+
+  if [test $dbus_inc = FOUND] && [test $dbus_lib = FOUND] ; then
+    AC_MSG_RESULT(headers $dbus_incdir $dbus_incdir_arch_deps  libraries $dbus_libdir)
+    dbus=FOUND
+  else
+    AC_MSG_RESULT(searched but not found)
+  fi
+
+  AC_SUBST(DBUS_INCS)
+  AC_SUBST(DBUS_LIBS)
+
+########### Check for DBus-Qt bindings
+
+  AC_MSG_CHECKING(for DBus-Qt bindings)
+
+  dbusqt_inc=NOTFOUND
+  dbusqt_lib=NOTFOUND
+  dbusqt=NOTFOUND
+
+  search_incs="$kde_includes /usr/include /usr/include/dbus-1.0 /usr/local/include /usr/local/include/dbus-1.0"
+  AC_FIND_FILE(dbus/connection.h, $search_incs, dbusqt_incdir)
+
+  if test -r $dbusqt_incdir/dbus/connection.h ; then
+    have_qt_patch=0
+    grep dbus_connection_setup_with_qt_main $dbusqt_incdir/dbus/connection.h \
+    > /dev/null 2>&1 && have_qt_patch=1
+    if test $have_qt_patch = 1 ; then
+      DBUSQT_INCS="-I$dbusqt_incdir"
+      dbusqt_inc=FOUND
+    fi
+  fi
+
+  search_libs="$kde_libraries /usr/lib /usr/lib64 /usr/local/lib"
+  AC_FIND_FILE(libdbus-qt-1.so, $search_libs, dbusqt_libdir)
+
+  if test -r $dbusqt_libdir/libdbus-qt-1.so ; then
+    DBUSQT_LIBS="-L$dbusqt_libdir -ldbus-qt-1"
+    dbusqt_lib=FOUND
+  fi
+
+  if [test $dbusqt_inc = FOUND] && [test $dbusqt_lib = FOUND] ; then
+    AC_MSG_RESULT(headers $dbusqt_incdir libraries $dbusqt_libdir)
+    dbusqt=FOUND
+  else
+    AC_MSG_RESULT(searched but not found)
+  fi
+
+  AC_SUBST(DBUSQT_INCS)
+  AC_SUBST(DBUSQT_LIBS)
+fi
+
+########### Check if media HAL backend sould be compiled
+
+have_hal=no
+HAL_DBUS_LIBS=""
+if [test "x$hal" = "xFOUND"] && [test "x$dbus" = "xFOUND"] && [test "x$dbusqt" = "xFOUND"] && [ test $hal_storage_version = 5 ] ; then
+  AC_DEFINE(HAVE_HAL, , [compile in HAL support])
+  have_hal=yes
+  HAL_DBUS_LIBS="$HAL_LIBS $DBUS_LIBS $DBUSQT_LIBS"
+fi
+
+AM_CONDITIONAL(include_HAL, [test x$have_hal = xyes])
+AC_SUBST(HAL_DBUS_LIBS)
+
diff --git a/libk3bdevice/k3bcdtext.cpp b/libk3bdevice/k3bcdtext.cpp
new file mode 100644
index 0000000..713f7dd
--- /dev/null
+++ b/libk3bdevice/k3bcdtext.cpp
@@ -0,0 +1,685 @@
+/* 
+ *
+ * $Id: k3bcdtext.cpp 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include <config.h>
+
+#include "k3bcdtext.h"
+#include "k3bcrc.h"
+
+#include <k3bdebug.h>
+
+#include <qtextcodec.h>
+
+#include <string.h>
+
+
+namespace K3bDevice {
+
+  struct cdtext_pack {
+    unsigned char id1;
+    unsigned char id2;
+    unsigned char id3;
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char dbcc:       1;
+    unsigned char blocknum:   3;
+    unsigned char charpos:    4;
+#else
+    unsigned char charpos:    4;
+    unsigned char blocknum:   3;
+    unsigned char dbcc:       1;
+#endif
+    unsigned char data[12];
+    unsigned char crc[2];
+  };
+
+  /**
+   * This one is taken from cdrecord
+   */
+  struct text_size_block {
+    char charcode;
+    char first_track;
+    char last_track;
+    char copyr_flags;
+    char pack_count[16];
+    char last_seqnum[8];
+    char language_codes[8];
+  };
+
+  void debugRawTextPackData( const unsigned char* data, int dataLen )
+  {
+    k3bDebug() << endl << " id1    | id2    | id3    | charps | blockn | dbcc | data           | crc |" << endl;
+  
+    cdtext_pack* pack = (cdtext_pack*)data;
+  
+    for( int i = 0; i < dataLen/18; ++i ) {
+      QString s;
+      s += QString( " %1 |" ).arg( pack[i].id1, 6, 16 );
+      s += QString( " %1 |" ).arg( pack[i].id2, 6 );
+      s += QString( " %1 |" ).arg( pack[i].id3, 6 );
+      s += QString( " %1 |" ).arg( pack[i].charpos, 6 );
+      s += QString( " %1 |" ).arg( pack[i].blocknum, 6 );
+      s += QString( " %1 |" ).arg( pack[i].dbcc, 4 );
+//       char str[12];
+//       sprintf( str, "%c%c%c%c%c%c%c%c%c%c%c%c",
+// 	       pack[i].data[0] == '\0' ? '�' : pack[i].data[0],
+// 	       pack[i].data[1] == '\0' ? '�' : pack[i].data[1],
+// 	       pack[i].data[2] == '\0' ? '�' : pack[i].data[2],
+// 	       pack[i].data[3] == '\0' ? '�' : pack[i].data[3],
+// 	       pack[i].data[4] == '\0' ? '�' : pack[i].data[4],
+// 	       pack[i].data[5] == '\0' ? '�' : pack[i].data[5],
+// 	       pack[i].data[6] == '\0' ? '�' : pack[i].data[6],
+// 	       pack[i].data[7] == '\0' ? '�' : pack[i].data[7],
+// 	       pack[i].data[8] == '\0' ? '�' : pack[i].data[8],
+// 	       pack[i].data[9] == '\0' ? '�' : pack[i].data[9],
+// 	       pack[i].data[10] == '\0' ? '�' : pack[i].data[10],
+// 	       pack[i].data[11] == '\0' ? '�' : pack[i].data[11] );
+//       s += QString( " %1 |" ).arg( "'" + QCString(str,13) + "'", 14 );
+//       Q_UINT16 crc = pack[i].crc[0]<<8|pack[i].crc[1];
+//       s += QString( " %1 |" ).arg( crc );
+      k3bDebug() << s << endl;
+    }
+  }
+
+}
+
+
+
+K3bDevice::CdText::CdText()
+{
+}
+
+
+K3bDevice::CdText::CdText( const K3bDevice::CdText& text )
+  : QValueVector<K3bDevice::TrackCdText>( text ),
+    m_title( text.title() ),
+    m_performer( text.performer() ),
+    m_songwriter( text.songwriter() ),
+    m_composer( text.composer() ),
+    m_arranger( text.arranger() ),
+    m_message( text.message() ),
+    m_discId( text.discId() ),
+    m_upcEan( text.upcEan() )
+{
+}
+
+
+K3bDevice::CdText::CdText( const unsigned char* data, int len )
+{
+  setRawPackData( data, len );
+}
+
+
+K3bDevice::CdText::CdText( const QByteArray& b )
+{
+  setRawPackData( b );
+}
+
+
+K3bDevice::CdText::CdText( int size )
+{
+  resize( size );
+}
+
+
+void K3bDevice::CdText::clear()
+{
+  QValueVector<TrackCdText>::clear();
+
+  m_title.setLength(0);
+  m_performer.setLength(0);
+  m_songwriter.setLength(0);
+  m_composer.setLength(0);
+  m_arranger.setLength(0);
+  m_message.setLength(0);
+  m_discId.setLength(0);
+  m_upcEan.setLength(0);
+}
+
+
+void K3bDevice::CdText::setRawPackData( const unsigned char* data, int len )
+{
+  clear();
+
+  int r = len%18;
+  if( r > 0 && r != 4 ) {
+    k3bDebug() << "(K3bDevice::CdText) invalid cdtext size: " << len << endl;
+  }
+  else if( len-r > 0 ) {
+    debugRawTextPackData( &data[r], len-r );
+
+    cdtext_pack* pack = (cdtext_pack*)&data[r];
+
+
+    for( int i = 0; i < (len-r)/18; ++i ) {
+
+      if( pack[i].dbcc ) {
+	k3bDebug() << "(K3bDevice::CdText) Double byte code not supported" << endl;
+	return;
+      }
+
+      //
+      // For some reason all crc bits are inverted.
+      //
+      pack[i].crc[0] ^= 0xff;
+      pack[i].crc[1] ^= 0xff;
+
+      Q_UINT16 crc = calcX25( reinterpret_cast<unsigned char*>(&pack[i]), 18 );
+
+      pack[i].crc[0] ^= 0xff;
+      pack[i].crc[1] ^= 0xff;
+
+      if( crc != 0x0000 )
+	k3bDebug() << "(K3bDevice::CdText) CRC invalid!" << endl;
+
+
+      //
+      // pack.data has a length of 12
+      //
+      // id1 tells us the tracknumber of the data (0 for global)
+      // data may contain multiple \0. In that case after every \0 the track number increases 1
+      //
+
+      char* nullPos = (char*)pack[i].data - 1;
+	
+      unsigned int trackNo = pack[i].id2;
+
+      while( nullPos ) {
+	if( count() < trackNo )
+	  resize( trackNo );
+
+	char* nextNullPos = (char*)::memchr( nullPos+1, '\0', 11 - (nullPos - (char*)pack[i].data) );
+	QString txtstr;	    
+	if( nextNullPos ) // take all chars up to the next null
+	  txtstr = QString::fromLatin1( (char*)nullPos+1, nextNullPos - nullPos - 1 );
+	else // take all chars to the end of the pack data (12 bytes)
+	  txtstr = QString::fromLatin1( (char*)nullPos+1, 11 - (nullPos - (char*)pack[i].data) );
+	  
+	//
+	// a tab character means to use the same as for the previous track
+	//
+	if( txtstr == "\t" )
+	  txtstr = textForPackType( pack[i].id1, trackNo-1 );
+
+	switch( pack[i].id1 ) {
+	case 0x80: // Title
+	  if( trackNo == 0 )
+	    m_title.append( txtstr );
+	  else
+	    at(trackNo-1).m_title.append( txtstr );
+	  break;
+
+	case 0x81: // Performer
+	  if( trackNo == 0 )
+	    m_performer.append( txtstr );
+	  else
+	    at(trackNo-1).m_performer.append( txtstr );
+	  break;
+
+	case 0x82: // Writer
+	  if( trackNo == 0 )
+	    m_songwriter.append( txtstr );
+	  else
+	    at(trackNo-1).m_songwriter.append( txtstr );
+	  break;
+
+	case 0x83: // Composer
+	  if( trackNo == 0 )
+	    m_composer.append( txtstr );
+	  else
+	    at(trackNo-1).m_composer.append( txtstr );
+	  break;
+
+	case 0x84: // Arranger
+	  if( trackNo == 0 )
+	    m_arranger.append( txtstr );
+	  else
+	    at(trackNo-1).m_arranger.append( txtstr );
+	  break;
+
+	case 0x85: // Message
+	  if( trackNo == 0 )
+	    m_message.append( txtstr );
+	  else
+	    at(trackNo-1).m_message.append( txtstr );
+	  break;
+
+	case 0x86: // Disc identification
+	  // only global
+	  if( trackNo == 0 )
+	    m_discId.append( txtstr );
+	  break;
+
+	case 0x8e: // Upc or isrc
+	  if( trackNo == 0 )
+	    m_upcEan.append( txtstr );
+	  else
+	    at(trackNo-1).m_isrc.append( txtstr );
+	  break;
+
+	  // TODO: support for binary data
+	  // 0x88: TOC 
+	  // 0x89: second TOC
+	  // 0x8f: Size information
+
+	default:
+	  break;
+	}
+	  
+	trackNo++;
+	nullPos = nextNullPos;
+      }
+    }
+
+    // remove empty fields at the end
+    unsigned int i = count();
+    while( i > 0 && at(i-1).isEmpty() )
+      --i;
+    resize( i );
+  }
+  else
+    k3bDebug() << "(K3bDevice::CdText) zero-sized CD-TEXT: " << len << endl; 
+}
+
+
+void K3bDevice::CdText::setRawPackData( const QByteArray& b )
+{
+  setRawPackData( reinterpret_cast<const unsigned char*>(b.data()), b.size() );
+}
+
+QByteArray K3bDevice::CdText::rawPackData() const
+{ 
+  // FIXME: every pack block may only consist of up to 255 packs.
+
+  unsigned int pc = 0;
+  unsigned int alreadyCountedPacks = 0;
+
+
+  //
+  // prepare the size information block
+  //
+  text_size_block tsize;
+  ::memset( &tsize, 0, sizeof(text_size_block) );
+  tsize.charcode = 0;              // ISO 8859-1
+  tsize.first_track = 1;
+  tsize.last_track = count();
+  tsize.pack_count[0xF] = 3;
+  tsize.language_codes[0] = 0x09;  // English (from cdrecord)
+
+
+  //
+  // create the CD-Text packs
+  //
+  QByteArray data(0);
+  for( int i = 0; i <= 6; ++i ) {
+    if( textLengthForPackType( 0x80 | i ) ) {
+      appendByteArray( data, createPackData( 0x80 | i, pc ) );
+      tsize.pack_count[i] = pc - alreadyCountedPacks;
+      alreadyCountedPacks = pc;
+    }
+  }
+  if( textLengthForPackType( 0x8E ) ) {
+    appendByteArray( data, createPackData( 0x8E, pc ) );
+    tsize.pack_count[0xE] = pc - alreadyCountedPacks;
+    alreadyCountedPacks = pc;
+  }
+
+
+  // pc is the number of the next pack and we add 3 size packs
+  tsize.last_seqnum[0] = pc + 2;
+
+
+  //
+  // create the size info packs
+  //
+  unsigned int dataFill = data.size();
+  data.resize( data.size() + 3 * sizeof(cdtext_pack) );
+  for( int i = 0; i < 3; ++i ) {
+    cdtext_pack pack;
+    ::memset( &pack, 0, sizeof(cdtext_pack) );
+    pack.id1 = 0x8F;
+    pack.id2 = i;
+    pack.id3 = pc+i;
+    ::memcpy( pack.data, &reinterpret_cast<char*>(&tsize)[i*12], 12 );
+    savePack( &pack, data, dataFill );
+  }
+
+  //
+  // add MMC header
+  //
+  QByteArray a( 4 );
+  a[0] = (data.size()+2)>>8 & 0xff;
+  a[1] = (data.size()+2) & 0xff;
+  a[2] = a[3] = 0;
+  appendByteArray( a, data );
+
+  return a;
+}
+
+
+void K3bDevice::CdText::appendByteArray( QByteArray& a, const QByteArray& b ) const
+{
+  unsigned int oldSize = a.size();
+  a.resize( oldSize + b.size() );
+  ::memcpy( &a.data()[oldSize], b.data(), b.size() );
+}
+
+
+// this method also creates completely empty packs
+QByteArray K3bDevice::CdText::createPackData( int packType, unsigned int& packCount ) const
+{
+  QByteArray data;
+  unsigned int dataFill = 0;
+  QCString text = encodeCdText( textForPackType( packType, 0 ) );
+  unsigned int currentTrack = 0;
+  unsigned int textPos = 0;
+  unsigned int packPos = 0;
+
+  //
+  // initialize the first pack
+  //
+  cdtext_pack pack;
+  ::memset( &pack, 0, sizeof(cdtext_pack) );
+  pack.id1 = packType;
+  pack.id3 = packCount;
+
+  //
+  // We break this loop when all texts have been packed
+  //
+  while( 1 ) {
+    //
+    // Copy as many bytes as possible into the pack
+    //
+    int copyBytes = QMIN( 12-packPos, text.length()-textPos );
+    ::memcpy( reinterpret_cast<char*>(&pack.data[packPos]), &text.data()[textPos], copyBytes );
+    textPos += copyBytes;
+    packPos += copyBytes;
+
+
+    //
+    // Check if the packdata is full
+    //
+    if( packPos > 11 ) {
+
+      savePack( &pack, data, dataFill );
+      ++packCount;
+
+      //
+      // reset the pack
+      //
+      ::memset( &pack, 0, sizeof(cdtext_pack) );
+      pack.id1 = packType;
+      pack.id2 = currentTrack;
+      pack.id3 = packCount;
+      packPos = 0;
+
+      // update the charpos in case we continue a text in the next pack
+      if( textPos <= text.length() )
+	pack.charpos = ( textPos > 15 ? 15 : textPos );
+    }
+
+
+    //
+    // Check if we have no text data left
+    //
+    if( textPos >= text.length() ) {
+
+      // add one zero spacer byte
+      ++packPos;
+
+      ++currentTrack;
+
+      // Check if all texts have been packed
+      if( currentTrack > count() ) {
+	savePack( &pack, data, dataFill );
+	++packCount;
+
+	data.resize( dataFill );
+	return data;
+      }
+
+      // next text block
+      text = encodeCdText( textForPackType( packType, currentTrack ) );
+      textPos = 0;
+    }
+  }
+}
+
+
+void K3bDevice::CdText::savePack( cdtext_pack* pack, QByteArray& data, unsigned int& dataFill ) const
+{
+  // create CRC
+  Q_UINT16 crc = calcX25( reinterpret_cast<unsigned char*>(pack), sizeof(cdtext_pack)-2 );
+
+  // invert for Redbook compliance
+  crc ^= 0xffff;
+
+  pack->crc[0] = (crc>>8) & 0xff;
+  pack->crc[1] = crc & 0xff;
+
+
+  // append the pack to data  
+  if( data.size() < dataFill + sizeof(cdtext_pack) )
+    data.resize( dataFill + sizeof(cdtext_pack), QGArray::SpeedOptim );
+
+  ::memcpy( &data.data()[dataFill], reinterpret_cast<char*>( pack ), sizeof(cdtext_pack) );
+
+  dataFill += sizeof(cdtext_pack);
+}
+
+
+// track 0 means global cdtext
+const QString& K3bDevice::CdText::textForPackType( int packType, unsigned int track ) const
+{
+  switch( packType ) {
+  default:
+  case 0x80:
+    if( track == 0 )
+      return title();
+    else
+      return at(track-1).title();
+
+  case 0x81:
+    if( track == 0 )
+      return performer();
+    else
+      return at(track-1).performer();
+
+  case 0x82:
+    if( track == 0 )
+      return songwriter();
+    else
+      return at(track-1).songwriter();
+
+  case 0x83:
+    if( track == 0 )
+      return composer();
+    else
+      return at(track-1).composer();
+
+  case 0x84:
+    if( track == 0 )
+      return arranger();
+    else
+      return at(track-1).arranger();
+
+  case 0x85:
+    if( track == 0 )
+      return message();
+    else
+      return at(track-1).message();
+
+  case 0x86:
+    if( track == 0 )
+      return discId();
+    else 
+      return QString::null;
+
+//   case 0x87:
+//     if( track == 0 )
+//       return genre();
+//     else
+//       return at(track-1).title();
+
+  case 0x8E:
+    if( track == 0 )
+      return upcEan();
+    else
+      return at(track-1).isrc();
+  }
+}
+
+
+// count the overall length of a certain packtype texts
+unsigned int K3bDevice::CdText::textLengthForPackType( int packType ) const
+{
+  unsigned int len = 0;
+  for( unsigned int i = 0; i <= count(); ++i )
+    len += encodeCdText( textForPackType( packType, i ) ).length();
+  return len;
+}
+
+
+QCString K3bDevice::encodeCdText( const QString& s, bool* illegalChars )
+{
+  if( illegalChars )
+    *illegalChars = false;
+
+  // TODO: do this without QT
+  QTextCodec* codec = QTextCodec::codecForName("ISO8859-1");
+  if( codec ) {
+    QCString encoded = codec->fromUnicode( s );
+    return encoded;
+  }
+  else {
+    QCString r(s.length()+1);
+
+    for( unsigned int i = 0; i < s.length(); ++i ) {
+      if( s[i].latin1() == 0 ) { // non-ASCII character
+	r[i] = ' ';
+	if( illegalChars )
+	  *illegalChars = true;
+      }
+      else
+	r[i] = s[i].latin1();
+    }
+
+    return r;
+  }
+}
+
+
+bool K3bDevice::CdText::checkCrc( const QByteArray& rawData )
+{
+  return checkCrc( reinterpret_cast<const unsigned char*>(rawData.data()), rawData.size() );
+}
+
+
+bool K3bDevice::CdText::checkCrc( const unsigned char* data, int len )
+{
+  int r = len%18;
+  if( r > 0 && r != 4 ) {
+    k3bDebug() << "(K3bDevice::CdText) invalid cdtext size: " << len << endl;
+    return false;
+  }
+  else {
+    len -= r;
+
+    // TODO: what if the crc field is not used? All zeros?
+
+    for( int i = 0; i < (len-r)/18; ++i ) {
+      cdtext_pack* pack = (cdtext_pack*)&data[r];
+
+      //
+      // For some reason all crc bits are inverted.
+      //
+      pack[i].crc[0] ^= 0xff;
+      pack[i].crc[1] ^= 0xff;
+
+      int crc = calcX25( reinterpret_cast<unsigned char*>(&pack[i]), 18 );
+
+      pack[i].crc[0] ^= 0xff;
+      pack[i].crc[1] ^= 0xff;
+
+      if( crc != 0x0000 )
+	return false;
+    }
+
+    return true;
+  }
+}
+
+
+void K3bDevice::CdText::debug() const
+{
+  // debug the stuff
+  k3bDebug() << "CD-TEXT data:" << endl
+	    << "Global:" << endl
+	    << "  Title:      '" << title() << "'" << endl
+	    << "  Performer:  '" << performer() << "'" << endl
+	    << "  Songwriter: '" << songwriter() << "'" << endl
+	    << "  Composer:   '" << composer() << "'" << endl
+	    << "  Arranger:   '" << arranger() << "'" << endl
+	    << "  Message:    '" << message() << "'" << endl
+	    << "  Disc ID:    '" << discId() << "'" << endl
+	    << "  Upc Ean:    '" << upcEan() << "'" << endl;
+  for( unsigned int i = 0; i < count(); ++i ) {
+    k3bDebug() << "Track " << (i+1) << ":" << endl
+	      << "  Title:      '" << at(i).title() << "'" << endl
+	      << "  Performer:  '" << at(i).performer() << "'" << endl
+	      << "  Songwriter: '" << at(i).songwriter() << "'" << endl
+	      << "  Composer:   '" << at(i).composer() << "'" << endl
+	      << "  Arranger:   '" << at(i).arranger() << "'" << endl
+	      << "  Message:    '" << at(i).message() << "'" << endl
+	      << "  Isrc:       '" << at(i).isrc() << "'" << endl;
+  }
+}
+
+
+bool K3bDevice::TrackCdText::operator==( const K3bDevice::TrackCdText& other ) const
+{
+  return( m_title == other.m_title &&
+	  m_performer == other.m_performer &&
+	  m_songwriter == other.m_songwriter &&
+	  m_composer == other.m_composer &&
+	  m_arranger == other.m_arranger &&
+	  m_message == other.m_message &&
+	  m_isrc == other.m_isrc );
+}
+
+
+bool K3bDevice::TrackCdText::operator!=( const K3bDevice::TrackCdText& other ) const
+{
+  return !operator==( other );
+}
+
+
+bool K3bDevice::CdText::operator==( const K3bDevice::CdText& other ) const
+{
+  return( m_title == other.m_title &&
+	  m_performer == other.m_performer &&
+	  m_songwriter == other.m_songwriter &&
+	  m_composer == other.m_composer &&
+	  m_arranger == other.m_arranger &&
+	  m_message == other.m_message &&
+	  m_discId == other.m_discId &&
+	  m_upcEan == other.m_upcEan &&
+	  QValueVector<TrackCdText>::operator==( other ) );
+}
+
+
+bool K3bDevice::CdText::operator!=( const K3bDevice::CdText& other ) const
+{
+  return !operator==( other );
+}
diff --git a/libk3bdevice/k3bcdtext.h b/libk3bdevice/k3bcdtext.h
new file mode 100644
index 0000000..10f6c82
--- /dev/null
+++ b/libk3bdevice/k3bcdtext.h
@@ -0,0 +1,201 @@
+/* 
+ *
+ * $Id: k3bcdtext.h 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#ifndef _K3B_CDTEXT_H_
+#define _K3B_CDTEXT_H_
+
+#include <qstring.h>
+#include <qvaluevector.h>
+#include "k3bdevice_export.h"
+
+namespace K3bDevice
+{
+  struct cdtext_pack;
+
+  class TrackCdText
+    {
+      friend class Device;
+      
+    public:
+      TrackCdText() {
+      }
+
+      void clear() {
+	m_title.truncate(0);
+	m_performer.truncate(0);
+	m_songwriter.truncate(0);
+	m_composer.truncate(0);
+	m_arranger.truncate(0);
+	m_message.truncate(0);
+	m_isrc.truncate(0);
+      }
+
+      const QString& title() const { return m_title; }
+      const QString& performer() const { return m_performer; }
+      const QString& songwriter() const { return m_songwriter; }
+      const QString& composer() const { return m_composer; }
+      const QString& arranger() const { return m_arranger; }
+      const QString& message() const { return m_message; }
+      const QString& isrc() const { return m_isrc; }
+
+      // TODO: use the real CD-TEXT charset (a modified ISO8859-1)
+      void setTitle( const QString& s ) { m_title = s; fixup(m_title); }
+      void setPerformer( const QString& s ) { m_performer = s; fixup(m_performer); }
+      void setSongwriter( const QString& s ) { m_songwriter = s; fixup(m_songwriter); }
+      void setComposer( const QString& s ) { m_composer = s; fixup(m_composer); }
+      void setArranger( const QString& s ) { m_arranger = s; fixup(m_arranger); }
+      void setMessage( const QString& s ) { m_message = s; fixup(m_message); }
+      void setIsrc( const QString& s ) { m_isrc = s; fixup(m_isrc); }
+
+      bool isEmpty() const {
+	if( !m_title.isEmpty() )
+	  return false;
+	if( !m_performer.isEmpty() )
+	  return false;
+	if( !m_songwriter.isEmpty() )
+	  return false;
+	if( !m_composer.isEmpty() )
+	  return false;
+	if( !m_arranger.isEmpty() )
+	  return false;
+	if( !m_message.isEmpty() )
+	  return false;
+	if( !m_isrc.isEmpty() )
+	  return false;
+
+	return true;
+      }
+
+      bool operator==( const TrackCdText& ) const;
+      bool operator!=( const TrackCdText& ) const;
+
+    private:
+      // TODO: remove this (see above)
+      void fixup( QString& s ) { s.replace( '/', "_" ); s.replace( '\"', "_" ); }
+
+      QString m_title;
+      QString m_performer;
+      QString m_songwriter;
+      QString m_composer;
+      QString m_arranger;
+      QString m_message;
+      QString m_isrc;
+
+      friend class CdText;
+    };
+
+  class LIBK3BDEVICE_EXPORT CdText : public QValueVector<TrackCdText>
+    {
+      friend class Device;
+
+    public:
+      CdText();
+      CdText( const unsigned char* data, int len );
+      CdText( const QByteArray& );
+      CdText( int size );
+      CdText( const CdText& );
+
+      void setRawPackData( const unsigned char*, int );
+      void setRawPackData( const QByteArray& );
+
+      QByteArray rawPackData() const;
+
+      bool empty() const {
+	if( !m_title.isEmpty() )
+	  return false;
+	if( !m_performer.isEmpty() )
+	  return false;
+	if( !m_songwriter.isEmpty() )
+	  return false;
+	if( !m_composer.isEmpty() )
+	  return false;
+	if( !m_arranger.isEmpty() )
+	  return false;
+	if( !m_message.isEmpty() )
+	  return false;
+	if( !m_discId.isEmpty() )
+	  return false;
+	if( !m_upcEan.isEmpty() )
+	  return false;
+	
+	for( unsigned int i = 0; i < count(); ++i )
+	  if( !at(i).isEmpty() )
+	    return false;
+
+	return true;
+      }
+
+      bool isEmpty() const {
+	return empty();
+      }
+
+      void clear();
+
+      const QString& title() const { return m_title; }
+      const QString& performer() const { return m_performer; }
+      const QString& songwriter() const { return m_songwriter; }
+      const QString& composer() const { return m_composer; }
+      const QString& arranger() const { return m_arranger; }
+      const QString& message() const { return m_message; }
+      const QString& discId() const { return m_discId; }
+      const QString& upcEan() const { return m_upcEan; }
+
+      // TODO: use the real CD-TEXT charset (a modified ISO8859-1)
+      void setTitle( const QString& s ) { m_title = s; fixup(m_title); }
+      void setPerformer( const QString& s ) { m_performer = s; fixup(m_performer); }
+      void setSongwriter( const QString& s ) { m_songwriter = s; fixup(m_songwriter); }
+      void setComposer( const QString& s ) { m_composer = s; fixup(m_composer); }
+      void setArranger( const QString& s ) { m_arranger = s; fixup(m_arranger); }
+      void setMessage( const QString& s ) { m_message = s; fixup(m_message); }
+      void setDiscId( const QString& s ) { m_discId = s; fixup(m_discId); }
+      void setUpcEan( const QString& s ) { m_upcEan = s; fixup(m_upcEan); }
+
+      void debug() const;
+
+      /**
+       * Returns false if found a crc error in the raw cdtext block or it has a
+       * wrong length.
+       */
+      static bool checkCrc( const unsigned char*, int );
+      static bool checkCrc( const QByteArray& );
+
+      bool operator==( const CdText& ) const;
+      bool operator!=( const CdText& ) const;
+	
+    private:
+      // TODO: remove this (see above)
+      void fixup( QString& s ) { s.replace( '/', "_" ); s.replace( '\"', "_" ); }
+
+      const QString& textForPackType( int packType, unsigned int track ) const;
+      unsigned int textLengthForPackType( int packType ) const;
+      QByteArray createPackData( int packType, unsigned int& ) const;
+      void savePack( cdtext_pack* pack, QByteArray& data, unsigned int& dataFill ) const;
+      void appendByteArray( QByteArray& a, const QByteArray& b ) const;
+
+      QString m_title;
+      QString m_performer;
+      QString m_songwriter;
+      QString m_composer;
+      QString m_arranger;
+      QString m_message;
+      QString m_discId;
+      QString m_upcEan;
+    };
+
+  QCString encodeCdText( const QString& s, bool* illegalChars = 0 );
+}
+
+#endif
diff --git a/libk3bdevice/k3bcrc.cpp b/libk3bdevice/k3bcrc.cpp
new file mode 100644
index 0000000..f533ae7
--- /dev/null
+++ b/libk3bdevice/k3bcrc.cpp
@@ -0,0 +1,80 @@
+/* 
+ *
+ * $Id: k3bcrc.cpp 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include "k3bcrc.h"
+
+#include <k3bdebug.h>
+
+
+static Q_UINT16 g_x25Table[1<<8] = {
+  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,
+};
+
+
+Q_UINT16 K3bDevice::calcX25( unsigned char* message, unsigned int len, Q_UINT16 crc )
+{
+  while( len-- ) {
+    crc = (crc<<8) ^ g_x25Table[(crc>>8) ^ (*message++)];
+  }
+
+  return crc;
+}
+
+
+bool K3bDevice::checkQCrc( unsigned char* subdata )
+{
+  // Red Book for some reason inverts the CRC bytes
+  subdata[10] ^= 0xff;
+  subdata[11] ^= 0xff;
+
+  Q_UINT16 crc = calcX25( subdata, 12 );
+
+  // correct the data
+  subdata[10] ^= 0xff;
+  subdata[11] ^= 0xff;
+
+  return( crc == 0x0000 );
+}
diff --git a/libk3bdevice/k3bcrc.h b/libk3bdevice/k3bcrc.h
new file mode 100644
index 0000000..ee7d6a6
--- /dev/null
+++ b/libk3bdevice/k3bcrc.h
@@ -0,0 +1,35 @@
+/* 
+ *
+ * $Id: k3bcrc.h 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#ifndef _K3B_CRC_H_
+#define _K3B_CRC_H_
+
+#include <qglobal.h>
+
+namespace K3bDevice
+{
+  //  static K3bCrc* x25();
+
+  // bool check( unsigned char* message, unsigned int len, unsigned char* crc, unsigned int crcLen );
+
+  Q_UINT16 calcX25( unsigned char* message, unsigned int len, Q_UINT16 start = 0x0000 );
+
+  /**
+   * subdata is 12 bytes in long.
+   */
+  bool checkQCrc( unsigned char* subdata );
+};
+
+#endif
diff --git a/libk3bdevice/k3bdebug.cpp b/libk3bdevice/k3bdebug.cpp
new file mode 100644
index 0000000..40774aa
--- /dev/null
+++ b/libk3bdevice/k3bdebug.cpp
@@ -0,0 +1,137 @@
+/*
+ *
+ * $Id: k3bemptydiscwaiter.cpp 606691 2006-11-21 12:15:21Z trueg $
+ * Copyright (C) 2006 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include "k3bdebug.h"
+
+#include <stdio.h>
+
+
+K3bDebug::K3bDebug()
+{
+}
+
+
+K3bDebug::~K3bDebug()
+{
+}
+
+
+K3bDebug& K3bDebug::operator<<( int i )
+{
+  fprintf( stderr, "%i", i );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( long l )
+{
+  fprintf( stderr, "%li", l );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( unsigned int i )
+{
+  fprintf( stderr, "%u", i );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( unsigned long l )
+{
+  fprintf( stderr, "%lu", l );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( unsigned long long l )
+{
+  fprintf( stderr, "%llu", l );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( char c )
+{
+  fprintf( stderr, "%c", c );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( float f )
+{
+  fprintf( stderr, "%f", f );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( double d )
+{
+  fprintf( stderr, "%f", d );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( const QString& s )
+{
+  fprintf( stderr, "%s", s.utf8().data() );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( const QCString& s )
+{
+  fprintf( stderr, "%s", s.data() );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( const char* s )
+{
+  fprintf( stderr, "%s", s );
+  return *this;
+}
+
+
+K3bDebug& K3bDebug::operator<<( const K3b::Msf& msf )
+{
+  return *this << msf.toString();
+}
+
+
+K3bDebug& K3bDebug::operator<<( K3BDBGFUNC f )
+{
+  return f( *this );
+}
+
+
+K3bDebug& K3bDebug::k3bDebug()
+{
+  static K3bDebug s_debug;
+  return s_debug;
+}
+
+
+
+K3bDebug& k3bDebug()
+{
+  return K3bDebug::k3bDebug();
+}
+
+
+K3bDebug& endl( K3bDebug& s )
+{
+  return s << '\n';
+}
diff --git a/libk3bdevice/k3bdebug.h b/libk3bdevice/k3bdebug.h
new file mode 100644
index 0000000..8bdd374
--- /dev/null
+++ b/libk3bdevice/k3bdebug.h
@@ -0,0 +1,63 @@
+/*
+ *
+ * $Id: k3bemptydiscwaiter.cpp 606691 2006-11-21 12:15:21Z trueg $
+ * Copyright (C) 2006 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#ifndef _K3B_DEBUG_H_
+#define _K3B_DEBUG_H_
+
+#include <qstring.h>
+
+#include <k3bmsf.h>
+#include <k3bdevice_export.h>
+
+class K3bDebug;
+
+typedef K3bDebug& (*K3BDBGFUNC)( K3bDebug& );
+
+/**
+ * K3bDebug as compared to KDebug does not need anything. No KInstance or whatever
+ * and does not use anything except fprintf.
+ * Thus, K3bDebug is fully thread-safe and safe in general
+ */
+class LIBK3BDEVICE_EXPORT K3bDebug
+{
+ public:
+  ~K3bDebug();
+
+  K3bDebug& operator<<( int );
+  K3bDebug& operator<<( long );
+  K3bDebug& operator<<( unsigned int );
+  K3bDebug& operator<<( unsigned long );
+  K3bDebug& operator<<( unsigned long long );
+  K3bDebug& operator<<( char );
+  K3bDebug& operator<<( float );
+  K3bDebug& operator<<( double );
+  K3bDebug& operator<<( const QString& );
+  K3bDebug& operator<<( const QCString& );
+  K3bDebug& operator<<( const char* );
+  K3bDebug& operator<<( const K3b::Msf& );
+
+  K3bDebug& operator<<( K3BDBGFUNC );
+
+  static K3bDebug& k3bDebug();
+
+ private:
+  K3bDebug();
+};
+
+LIBK3BDEVICE_EXPORT K3bDebug& k3bDebug();
+LIBK3BDEVICE_EXPORT K3bDebug& endl( K3bDebug& );
+
+#endif
diff --git a/libk3bdevice/k3bdevice.cpp b/libk3bdevice/k3bdevice.cpp
new file mode 100644
index 0000000..45ba7bf
--- /dev/null
+++ b/libk3bdevice/k3bdevice.cpp
@@ -0,0 +1,3650 @@
+/*
+ *
+ * $Id: k3bdevice.cpp 732002 2007-11-02 14:13:14Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include <config.h>
+
+
+#include "k3bdevice.h"
+#include "k3bdeviceglobals.h"
+#include "k3btrack.h"
+#include "k3btoc.h"
+#include "k3bdiskinfo.h"
+#include "k3bmmc.h"
+#include "k3bscsicommand.h"
+#include "k3bcrc.h"
+
+#include <qstringlist.h>
+#include <qfile.h>
+#include <qglobal.h>
+#include <qvaluevector.h>
+#include <qmutex.h>
+
+#include <k3bdebug.h>
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <math.h>
+#include <stdarg.h>
+
+
+#ifdef Q_OS_LINUX
+
+#include <linux/version.h>
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,70)
+typedef unsigned char u8;
+#endif
+
+#undef __STRICT_ANSI__
+#include <linux/cdrom.h>
+#define __STRICT_ANSI__
+
+#endif // Q_OS_LINUX
+
+#ifdef Q_OS_FREEBSD
+#include <stdio.h>
+#include <camlib.h>
+#define CD_FRAMESIZE_RAW 2352
+#endif
+
+#ifdef Q_OS_NETBSD
+#include <sys/cdio.h>
+#endif
+
+#ifdef HAVE_RESMGR
+extern "C" {
+#include <resmgr.h>
+}
+#endif
+
+
+//
+// Very evil hacking: force the speed values to be acurate
+// as long as "they" do not introduce other "broken" DVD
+// speeds like 2.4 this works fine
+//
+static int fixupDvdWritingSpeed( int speed )
+{
+  //
+  // Some writers report their speeds in 1000 bytes per second instead of 1024.
+  //
+  if( speed % 1385 == 0 )
+    return speed;
+
+  else if( speed % 1352 == 0 )
+    return speed*1385/1352;
+
+  // has to be 2.4x speed
+  else
+    return 3324;
+}
+
+
+const char* K3bDevice::Device::cdrdao_drivers[] =
+  { "auto", "plextor", "plextor-scan", "cdd2600", "generic-mmc",
+    "generic-mmc-raw", "ricoh-mp6200", "sony-cdu920",
+    "sony-cdu948", "taiyo-yuden", "teac-cdr55", "toshiba",
+    "yamaha-cdr10x", 0
+  };
+
+
+#if defined(Q_OS_LINUX) || defined(Q_OS_NETBSD)
+int K3bDevice::openDevice( const char* name, bool write )
+{
+  int fd = -1;
+  int flags = O_NONBLOCK;
+  if( write )
+    flags |= O_RDWR;
+  else
+    flags |= O_RDONLY;
+
+#ifdef HAVE_RESMGR
+  // first try resmgr
+  fd = ::rsm_open_device( name, flags );
+  //  k3bDebug() << "(K3bDevice::Device) resmgr open: " << fd << endl;
+#endif
+
+  if( fd < 0 )
+    fd = ::open( name, flags );
+
+  if( fd < 0 ) {
+    k3bDebug() << "(K3bDevice::Device) could not open device "
+	      << name << ( write ? " for writing" : " for reading" ) << endl;
+    k3bDebug() << "                    (" << strerror(errno) << ")" << endl;
+    fd = -1;
+
+    // at least open it read-only (which is sufficient for kernels < 2.6.8 anyway)
+    if( write )
+      return openDevice( name, false );
+  }
+
+  return fd;
+}
+#endif
+
+
+class K3bDevice::Device::Private
+{
+public:
+  Private()
+    : supportedProfiles(0),
+#ifdef Q_OS_LINUX
+      deviceFd(-1),
+#endif
+#ifdef Q_OS_NETBSD
+      deviceFd(-1),
+#endif
+#ifdef Q_OS_FREEBSD
+      cam(0),
+#endif
+      openedReadWrite(false),
+      burnfree(false) {
+  }
+
+  int readCapabilities;
+  int writeCapabilities;
+  int supportedProfiles;
+  QStringList allNodes;
+#ifdef Q_OS_LINUX
+  int deviceFd;
+#endif
+#ifdef Q_OS_NETBSD
+  int deviceFd;
+#endif
+#ifdef Q_OS_FREEBSD
+  struct cam_device *cam;
+#endif
+  bool openedReadWrite;
+  bool burnfree;
+
+  QMutex mutex;
+    QMutex openCloseMutex;
+};
+
+
+K3bDevice::Device::Device( const QString& devname )
+  : m_bus(-1),
+    m_target(-1),
+    m_lun(-1),
+    m_writeModes(0)
+{
+  d = new Private;
+
+  m_blockDevice = devname;
+  d->allNodes.append(devname);
+
+  m_cdrdaoDriver = "auto";
+  m_cdTextCapable = 0;
+  m_maxWriteSpeed = 0;
+  m_maxReadSpeed = 0;
+  d->burnfree = false;
+  m_dvdMinusTestwrite = true;
+  m_bufferSize = 0;
+}
+
+
+K3bDevice::Device::~Device()
+{
+  close();
+  delete d;
+}
+
+
+bool K3bDevice::Device::init( bool bCheckWritingModes )
+{
+  k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": init()" << endl;
+
+  //
+  // they all should read CD-ROM.
+  //
+  d->readCapabilities = MEDIA_CD_ROM;
+  d->writeCapabilities = 0;
+  d->supportedProfiles = 0;
+
+  if( !open() )
+    return false;
+
+  //
+  // inquiry
+  // use a 36 bytes buffer since not all devices return the full inquiry struct
+  //
+  ScsiCommand cmd( this );
+  unsigned char buf[36];
+  cmd.clear();
+  ::memset( buf, 0, sizeof(buf) );
+  struct inquiry* inq = (struct inquiry*)buf;
+  cmd[0] = MMC_INQUIRY;
+  cmd[4] = sizeof(buf);
+  cmd[5] = 0;
+  if( cmd.transport( TR_DIR_READ, buf, sizeof(buf) ) ) {
+    kdError() << "(K3bDevice::Device) Unable to do inquiry." << endl;
+    close();
+    return false;
+  }
+  else {
+    m_vendor = QString::fromLatin1( (char*)(inq->vendor), 8 ).stripWhiteSpace();
+    m_description = QString::fromLatin1( (char*)(inq->product), 16 ).stripWhiteSpace();
+    m_version = QString::fromLatin1( (char*)(inq->revision), 4 ).stripWhiteSpace();
+  }
+
+  if( m_vendor.isEmpty() )
+    m_vendor = "UNKNOWN";
+  if( m_description.isEmpty() )
+    m_description = "UNKNOWN";
+
+  //
+  // We probe all features of the device. Since not all devices support the GET CONFIGURATION command
+  // we also query the mode page 2A and use the cdrom.h stuff to get as much information as possible
+  //
+  checkFeatures();
+
+  //
+  // Check the supported write modes (WRITINGMODE_TAO, WRITINGMODE_SAO, WRITINGMODE_RAW) by trying to set them
+  // We do this before checking mode page 2A in case some readers allow changin
+  // the write parameter page
+  //
+  if( bCheckWritingModes )
+    checkWritingModes();
+
+  //
+  // Most current drives support the 2A mode page
+  // Here we can get some more information (cdrecord -prcap does exactly this)
+  //
+  checkFor2AFeatures();
+
+  m_maxWriteSpeed = determineMaximalWriteSpeed();
+
+  //
+  // Check Just-Link via Ricoh mode page 0x30
+  //
+  if( !d->burnfree )
+    checkForJustLink();
+
+  //
+  // Support for some very old drives
+  //
+  checkForAncientWriters();
+
+  //
+  // If it can be written it can also be read
+  //
+  d->readCapabilities |= d->writeCapabilities;
+
+  close();
+
+  return furtherInit();
+}
+
+
+bool K3bDevice::Device::furtherInit()
+{
+#ifdef Q_OS_LINUX
+
+  //
+  // Since all CDR drives at least support WRITINGMODE_TAO, all CDRW drives should support
+  // mode page 2a and all DVD writer should support mode page 2a or the GET CONFIGURATION
+  // command this is redundant and may be removed for BSD ports or even completely
+  //
+  // We just keep it here because of the "should" in the sentence above. If someone can tell me
+  // that the linux driver does nothing more we can remove it completely.
+  //
+  open();
+  int drivetype = ::ioctl( handle(), CDROM_GET_CAPABILITY, CDSL_CURRENT );
+  if( drivetype < 0 ) {
+    k3bDebug() << "Error while retrieving capabilities." << endl;
+    close();
+    return false;
+  }
+
+  d->readCapabilities |= DEVICE_CD_ROM;
+
+  if( drivetype & CDC_CD_R )
+    d->writeCapabilities |= MEDIA_CD_R;
+  if( drivetype & CDC_CD_RW )
+    d->writeCapabilities |= MEDIA_CD_RW;
+  if( drivetype & CDC_DVD_R )
+    d->writeCapabilities |= MEDIA_DVD_R;
+  if( drivetype & CDC_DVD )
+    d->readCapabilities |= MEDIA_DVD_ROM;
+
+  close();
+
+#endif // Q_OS_LINUX
+  return true;
+}
+
+
+void K3bDevice::Device::checkForAncientWriters()
+{
+  // TODO: add a boolean which determines if this device is non-MMC so we may warn the user at K3b startup about it
+
+  //
+  // There are a lot writers out there which behave like the TEAC R5XS
+  //
+  if( ( vendor().startsWith("TEAC") && ( description().startsWith("CD-R50S") ||
+					 description().startsWith("CD-R55S") ) )
+      ||
+      ( vendor().startsWith("SAF") && ( description().startsWith("CD-R2006PLUS") ||
+					description().startsWith("CD-RW226") ||
+					description().startsWith("CD-R4012") ) )
+      ||
+      ( vendor().startsWith("JVC") && ( description().startsWith("XR-W2001") ||
+					description().startsWith("XR-W2010") ||
+					description().startsWith("R2626") ) )
+      ||
+      ( vendor().startsWith("PINNACLE") && ( description().startsWith("RCD-1000") ||
+					description().startsWith("RCD5020") ||
+					description().startsWith("RCD5040") ||
+					description().startsWith("RCD 4X4") ) )
+      ||
+      ( vendor().startsWith("Traxdata") && description().startsWith("CDR4120") ) ) {
+    m_writeModes = WRITINGMODE_TAO;
+    d->readCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+    d->writeCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+    m_maxWriteSpeed = 4;
+    m_maxReadSpeed = 12;
+    m_bufferSize = 1024;
+    d->burnfree = false;
+  }
+  else if( vendor().startsWith("TEAC") ) {
+    if( description().startsWith("CD-R56S") ) {
+      m_writeModes |= TAO;
+      d->readCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      d->writeCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      m_maxWriteSpeed = 6;
+      m_maxReadSpeed = 24;
+      m_bufferSize = 1302;
+      d->burnfree = false;
+    }
+    if( description().startsWith("CD-R58S") ) {
+      m_writeModes |= TAO;
+      d->readCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      d->writeCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      m_maxWriteSpeed = 8;
+      m_maxReadSpeed = 24;
+      m_bufferSize = 4096;
+      d->burnfree = false;
+    }
+  }
+  else if( vendor().startsWith("MATSHITA") ) {
+    if( description().startsWith("CD-R   CW-7501") ) {
+      m_writeModes = WRITINGMODE_TAO|WRITINGMODE_SAO;
+      d->readCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      d->writeCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      m_maxWriteSpeed = 2;
+      m_maxReadSpeed = 4;
+      m_bufferSize = 1024;
+      d->burnfree = false;
+    }
+    if( description().startsWith("CD-R   CW-7502") ) {
+      m_writeModes = WRITINGMODE_TAO|WRITINGMODE_SAO;
+      d->readCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      d->writeCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      m_maxWriteSpeed = 4;
+      m_maxReadSpeed = 8;
+      m_bufferSize = 1024;
+      d->burnfree = false;
+    }
+    else if( description().startsWith("CD-R56S") ) {
+      m_writeModes |= WRITINGMODE_TAO;
+      d->readCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      d->writeCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      m_maxWriteSpeed = 6;
+      m_maxReadSpeed = 24;
+      m_bufferSize = 1302;
+      d->burnfree = false;
+    }
+  }
+  else if( vendor().startsWith("HP") ) {
+    if( description().startsWith("CD-Writer 6020") ) {
+      m_writeModes = WRITINGMODE_TAO;
+      d->readCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      d->writeCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      m_maxWriteSpeed = 2;
+      m_maxReadSpeed = 6;
+      m_bufferSize = 1024;
+      d->burnfree = false;
+    }
+  }
+  else if( vendor().startsWith( "PHILIPS" ) ) {
+    if( description().startsWith( "CDD2600" ) ) {
+      m_writeModes = WRITINGMODE_TAO|WRITINGMODE_SAO;
+      d->readCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      d->writeCapabilities = MEDIA_CD_ROM|MEDIA_CD_R;
+      m_maxWriteSpeed = 2;
+      m_maxReadSpeed = 6;
+      m_bufferSize = 1024;
+      d->burnfree = false;
+    }
+  }
+}
+
+
+K3bDevice::Interface K3bDevice::Device::interfaceType() const
+{
+  if( m_bus != -1 && m_target != -1 && m_lun != -1 )
+    return SCSI;
+  else
+    return IDE;
+}
+
+
+bool K3bDevice::Device::dao() const
+{
+  return m_writeModes & WRITINGMODE_SAO;
+}
+
+
+bool K3bDevice::Device::supportsRawWriting() const
+{
+  return( writingModes() & (WRITINGMODE_RAW|WRITINGMODE_RAW_R16|WRITINGMODE_RAW_R96P|WRITINGMODE_RAW_R96R) );
+}
+
+
+bool K3bDevice::Device::writesCd() const
+{
+  return ( d->writeCapabilities & MEDIA_CD_R ) && ( m_writeModes & WRITINGMODE_TAO );
+}
+
+
+bool K3bDevice::Device::burner() const
+{
+  return ( writesCd() || writesDvd() );
+}
+
+
+bool K3bDevice::Device::writesCdrw() const
+{
+  return d->writeCapabilities & MEDIA_CD_RW;
+}
+
+
+bool K3bDevice::Device::writesDvd() const
+{
+  return ( writesDvdPlus() || writesDvdMinus() );
+}
+
+
+bool K3bDevice::Device::writesDvdPlus() const
+{
+  return d->writeCapabilities & (MEDIA_DVD_PLUS_R|MEDIA_DVD_PLUS_RW);
+}
+
+
+bool K3bDevice::Device::writesDvdMinus() const
+{
+  return d->writeCapabilities & (MEDIA_DVD_R|MEDIA_DVD_RW);
+}
+
+
+bool K3bDevice::Device::readsDvd() const
+{
+  return d->readCapabilities & MEDIA_DVD_ROM;
+}
+
+
+int K3bDevice::Device::type() const
+{
+  int r = 0;
+  if( readCapabilities() & MEDIA_CD_ROM )
+    r |= DEVICE_CD_ROM;
+  if( writeCapabilities() & MEDIA_CD_R )
+    r |= DEVICE_CD_R;
+  if( writeCapabilities() & MEDIA_CD_RW )
+    r |= DEVICE_CD_RW;
+  if( readCapabilities() & MEDIA_DVD_ROM )
+    r |= DEVICE_DVD_ROM;
+  if( writeCapabilities() & MEDIA_DVD_RAM )
+    r |= DEVICE_DVD_RAM;
+  if( writeCapabilities() & MEDIA_DVD_R )
+    r |= DEVICE_DVD_R;
+  if( writeCapabilities() & MEDIA_DVD_RW )
+    r |= DEVICE_DVD_RW;
+  if( writeCapabilities() & MEDIA_DVD_R_DL )
+    r |= DEVICE_DVD_R_DL;
+  if( writeCapabilities() & MEDIA_DVD_PLUS_R )
+    r |= DEVICE_DVD_PLUS_R;
+  if( writeCapabilities() & MEDIA_DVD_PLUS_RW )
+    r |= DEVICE_DVD_PLUS_RW;
+  if( writeCapabilities() & MEDIA_DVD_PLUS_R_DL )
+    r |= DEVICE_DVD_PLUS_R_DL;
+  if( readCapabilities() & MEDIA_HD_DVD_ROM )
+    r |= DEVICE_HD_DVD_ROM;
+  if( writeCapabilities() & MEDIA_HD_DVD_R )
+    r |= DEVICE_HD_DVD_R;
+  if( writeCapabilities() & MEDIA_HD_DVD_RAM )
+    r |= DEVICE_HD_DVD_RAM;
+  if( readCapabilities() & MEDIA_BD_ROM )
+    r |= DEVICE_BD_ROM;
+  if( writeCapabilities() & MEDIA_BD_R )
+    r |= DEVICE_BD_R;
+  if( writeCapabilities() & MEDIA_BD_RE )
+    r |= DEVICE_BD_RE;
+
+  return r;
+}
+
+
+int K3bDevice::Device::readCapabilities() const
+{
+  return d->readCapabilities;
+}
+
+
+int K3bDevice::Device::writeCapabilities() const
+{
+  return d->writeCapabilities;
+}
+
+
+const QString& K3bDevice::Device::devicename() const
+{
+  return blockDeviceName();
+}
+
+
+QString K3bDevice::Device::busTargetLun() const
+{
+  return QString("%1,%2,%3").arg(m_bus).arg(m_target).arg(m_lun);
+}
+
+
+int K3bDevice::Device::cdTextCapable() const
+{
+  if( cdrdaoDriver() == "auto" )
+    return 0;
+  else
+    return m_cdTextCapable;
+}
+
+
+void K3bDevice::Device::setCdTextCapability( bool b )
+{
+  m_cdTextCapable = ( b ? 1 : 2 );
+}
+
+
+bool K3bDevice::Device::burnproof() const
+{
+  return burnfree();
+}
+
+
+bool K3bDevice::Device::burnfree() const
+{
+  return d->burnfree;
+}
+
+
+bool K3bDevice::Device::isDVD() const
+{
+  if( readsDvd() )
+    return( mediaType() & MEDIA_DVD_ALL );
+  else
+    return false;
+}
+
+
+int K3bDevice::Device::isEmpty() const
+{
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  int ret = STATE_UNKNOWN;
+  if( !open() )
+    return STATE_UNKNOWN;
+
+  if( !testUnitReady() )
+    return STATE_NO_MEDIA;
+
+  unsigned char* data = 0;
+  unsigned int dataLen = 0;
+
+  if( readDiscInformation( &data, dataLen ) ) {
+    disc_info_t* inf = (disc_info_t*)data;
+    switch( inf->status ) {
+    case 0:
+      ret = STATE_EMPTY;
+      break;
+    case 1:
+      ret = STATE_INCOMPLETE;
+      break;
+    case 2:
+      ret = STATE_COMPLETE;
+      break;
+    default:
+      ret = STATE_UNKNOWN;
+      break;
+    }
+
+    delete [] data;
+  }
+
+  if( needToClose )
+    close();
+
+  return ret;
+}
+
+
+int K3bDevice::Device::numSessions() const
+{
+  //
+  // Session Info
+  // ============
+  // Byte 0-1: Data Length
+  // Byte   2: First Complete Session Number (Hex) - always 1
+  // Byte   3: Last Complete Session Number (Hex)
+  //
+
+  int ret = -1;
+
+  unsigned char* data = 0;
+  unsigned int len = 0;
+
+  if( mediaType() & MEDIA_CD_ALL ) {
+    //
+    // Althought disk_info should get the real value without ide-scsi
+    // I keep getting wrong values (the value is too high. I think the leadout
+    // gets counted as session sometimes :()
+    //
+    if( readTocPmaAtip( &data, len, 1, 0, 0 ) ) {
+      ret = data[3];
+
+      delete [] data;
+    }
+    else {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": could not get session info !" << endl;
+    }
+  }
+  else {
+    if( readDiscInformation( &data, len ) ) {
+      ret = (int)( data[9]<<8 | data[4] );
+
+      // do only count complete sessions
+      if( (data[2]>>2) != 3 )
+	ret--;
+
+      delete [] data;
+    }
+  }
+
+  return ret;
+}
+
+
+int K3bDevice::Device::getDataMode( const K3b::Msf& sector ) const
+{
+  bool needToClose = !isOpen();
+
+  int ret = Track::UNKNOWN;
+
+  if( !open() )
+    return ret;
+
+  // we use readCdMsf here since it's defined mandatory in MMC1 and
+  // we only use this method for CDs anyway
+  unsigned char data[2352];
+  bool readSuccess = readCdMsf( data, 2352,
+				0,      // all sector types
+				false,  // no dap
+				sector,
+				sector+1,
+				true, // SYNC
+				true, // HEADER
+				true, // SUBHEADER
+				true, // USER DATA
+				true, // EDC/ECC
+				0,    // no c2 info
+				0 );
+
+  if( readSuccess ) {
+    if ( data[15] == 0x1 )
+      ret = Track::MODE1;
+    else if ( data[15] == 0x2 )
+      ret = Track::MODE2;
+    if ( ret == Track::MODE2 ) {
+      if ( data[16] == data[20] &&
+           data[17] == data[21] &&
+           data[18] == data[22] &&
+           data[19] == data[23] ) {
+	if ( data[18] & 0x20 )
+	  ret = Track::XA_FORM2;
+	else
+	  ret = Track::XA_FORM1;
+      }
+    }
+  }
+
+  if( needToClose )
+    close();
+
+  return ret;
+}
+
+
+
+int K3bDevice::Device::getTrackDataMode( const K3bDevice::Track& track ) const
+{
+  return getDataMode( track.firstSector() );
+}
+
+
+K3bDevice::Toc K3bDevice::Device::readToc() const
+{
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  Toc toc;
+
+  if( !open() )
+    return toc;
+
+  int mt = mediaType();
+
+  //
+  // Use the profile if available because DVD-ROM units need to treat DVD+-R(W) media as DVD-ROM
+  // if supported at all
+  //
+  if( currentProfile() == MEDIA_DVD_ROM )
+    mt = MEDIA_DVD_ROM;
+
+  if( mt & (MEDIA_DVD_MINUS_ALL|MEDIA_DVD_PLUS_RW|MEDIA_DVD_ROM) ) {
+    if( !readFormattedToc( toc, mt ) ) {
+      K3b::Msf size;
+      if( readCapacity( size ) ) {
+	Track track;
+	track.m_firstSector = 0;
+	track.m_lastSector = size.lba();
+	track.m_session = 1;
+	track.m_type = Track::DATA;
+	track.m_mode = Track::DVD;
+	track.m_copyPermitted = ( mt != MEDIA_DVD_ROM );
+	track.m_preEmphasis = ( mt != MEDIA_DVD_ROM );
+
+	toc.append( track );
+      }
+      else
+	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		  << "READ CAPACITY for toc failed." << endl;
+    }
+  }
+
+  else if( mt & (MEDIA_DVD_PLUS_R|MEDIA_DVD_PLUS_R_DL) ) {
+    //
+    // a DVD+R disk may have multiple sessions
+    // every session may contain up to 16 fragments
+    // if the disk is open there is one open session
+    // every closed session is viewed as a track whereas
+    // every fragment of the open session is viewed as a track
+    //
+    // We may use
+    // READ DISK INFORMATION
+    // READ TRACK INFORMATION: track number FFh, however, does not refer to the invisible track
+    // READ TOC/PMA/ATIP: form 0 refers to all closed sessions
+    //                    form 1 refers to the last closed session
+    //
+    readFormattedToc( toc, mt );
+  }
+
+  else if( mt & MEDIA_BD_ALL ) {
+    readFormattedToc( toc, mt );
+  }
+
+  else if( mt == MEDIA_DVD_RAM ) {
+    k3bDebug() << "(K3bDevice::readDvdToc) no dvdram support" << endl;
+  }
+
+
+  else if( mt & MEDIA_CD_ALL ) {
+    bool success = readRawToc( toc );
+    if( !success ) {
+      success = readFormattedToc( toc, mt );
+
+#ifdef Q_OS_LINUX
+      if( !success ) {
+	k3bDebug() << "(K3bDevice::Device) MMC READ TOC failed. falling back to cdrom.h." << endl;
+	readTocLinux(toc);
+      }
+#endif
+
+      if( success )
+	fixupToc( toc );
+    }
+  }
+
+  if( needToClose )
+    close();
+
+  return toc;
+}
+
+
+void K3bDevice::Device::readIsrcMcn( K3bDevice::Toc& toc ) const
+{
+  // read MCN and ISRC of all tracks
+  QCString mcn;
+  if( readMcn( mcn ) ) {
+    toc.setMcn( mcn );
+    k3bDebug() << "(K3bDevice::Device) found MCN: " << mcn << endl;
+  }
+  else
+    k3bDebug() << "(K3bDevice::Device) no MCN found." << endl;
+
+  for( unsigned int i = 1; i <= toc.count(); ++i ) {
+    QCString isrc;
+    if( toc[i-1].type() == Track::AUDIO ) {
+      if( readIsrc( i, isrc ) ) {
+	k3bDebug() << "(K3bDevice::Device) found ISRC for track " << i << ": " << isrc << endl;
+	toc[i-1].setIsrc( isrc );
+      }
+      else
+	k3bDebug() << "(K3bDevice::Device) no ISRC found for track " << i << endl;
+    }
+  }
+}
+
+
+bool K3bDevice::Device::readFormattedToc( K3bDevice::Toc& toc, int mt ) const
+{
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  bool success = false;
+
+  toc.clear();
+
+  unsigned int lastTrack = 0;
+
+  unsigned char* data = 0;
+  unsigned int dataLen = 0;
+  if( !(mt & MEDIA_CD_ALL) ) {
+    //
+    // on DVD-R(W) multisession disks only two sessions are represented as tracks in the readTocPmaAtip
+    // response (fabricated TOC). Thus, we use readDiscInformation for DVD media to get the proper number of tracks
+    //
+    if( readDiscInformation( &data, dataLen ) ) {
+      lastTrack = (int)( data[11]<<8 | data[6] );
+
+      delete [] data;
+
+      if( readTrackInformation( &data, dataLen, 1, lastTrack ) ) {
+	track_info_t* trackInfo = (track_info_t*)data;
+
+	if( trackInfo->blank ) {
+	  lastTrack--;
+	}
+
+	delete [] data;
+
+	success = true;
+      }
+      else
+	return false;
+    }
+    else
+      return false;
+  }
+  else {
+    if( readTocPmaAtip( &data, dataLen, 0, 0, 1 ) ) {
+
+      if( dataLen < 4 ) {
+	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": formatted toc data too small." << endl;
+      }
+      else if( dataLen != ( (unsigned int)sizeof(toc_track_descriptor) * ((unsigned int)data[3]+1) ) + 4 ) {
+	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": invalid formatted toc data length: "
+		  << (dataLen-2) << endl;
+      }
+      else {
+	lastTrack = data[3];
+	toc_track_descriptor* td = (toc_track_descriptor*)&data[4];
+	for( unsigned int i = 0; i < lastTrack; ++i ) {
+
+	  Track track;
+	  unsigned int control = 0;
+
+	  //
+	  // In case READ TRACK INFORMATION fails:
+	  // no session number info
+	  // no track length and thus possibly incorrect last sector for
+	  // multisession disks
+	  //
+	  track.m_firstSector = from4Byte( td[i].start_adr );
+	  track.m_lastSector = from4Byte( td[i+1].start_adr ) - 1;
+	  control = td[i].control;
+
+	  track.m_type = (control & 0x4) ? Track::DATA : Track::AUDIO;
+	  track.m_mode = getTrackDataMode( track );
+	  track.m_copyPermitted = ( control & 0x2 );
+	  track.m_preEmphasis = ( control & 0x1 );
+
+	  toc.append( track );
+	}
+
+	success = true;
+      }
+
+      delete [] data;
+    }
+  }
+
+
+  //
+  // Try to get information for all the tracks
+  //
+  for( unsigned int i = 0; i < lastTrack; ++i ) {
+    if( toc.count() < i+1 )
+      toc.append( Track() );
+
+    unsigned char* trackData = 0;
+    unsigned int trackDataLen = 0;
+    if( readTrackInformation( &trackData, trackDataLen, 1, i+1 ) ) {
+      track_info_t* trackInfo = (track_info_t*)trackData;
+
+      toc[i].m_firstSector = from4Byte( trackInfo->track_start );
+
+      if( i > 0 && toc[i-1].m_lastSector == 0 )
+	toc[i-1].m_lastSector = toc[i].m_firstSector - 1;
+
+      // There are drives that return 0 track length here!
+      // Some drives even return an invalid length here. :(
+      if( from4Byte( trackInfo->track_size ) > 0 )
+	toc[i].m_lastSector = toc[i].m_firstSector + from4Byte( trackInfo->track_size ) - 1;
+
+      if( trackInfo->nwa_v ) {
+	toc[i].m_nextWritableAddress = from4Byte( trackInfo->next_writable );
+	toc[i].m_freeBlocks = from4Byte( trackInfo->free_blocks );
+      }
+
+      toc[i].m_session = (int)(trackInfo->session_number_m<<8 & 0xf0 |
+			       trackInfo->session_number_l & 0x0f);  //FIXME: is this BCD?
+
+      int control = trackInfo->track_mode;
+
+      if( mt & MEDIA_CD_ALL ) {
+	toc[i].m_type = (control & 0x4) ? Track::DATA : Track::AUDIO;
+	toc[i].m_mode = getTrackDataMode( toc[i] );
+      }
+      else {
+	toc[i].m_type = Track::DATA;
+	toc[i].m_mode = Track::DVD;
+      }
+      toc[i].m_copyPermitted = ( control & 0x2 );
+      toc[i].m_preEmphasis = ( control & 0x1 );
+
+      delete [] trackData;
+    }
+    else if( !(mt & MEDIA_CD_ALL) ) {
+      success = false;
+    }
+  }
+
+  // this can only happen with DVD media
+  if( !toc.isEmpty() && toc.last().lastSector() == 0 ) {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " no track length for the last non-empty track." << endl;
+    unsigned char* trackData = 0;
+    unsigned int trackDataLen = 0;
+    if( readTrackInformation( &trackData, trackDataLen, 1, lastTrack+1 ) ) {
+      track_info_t* trackInfo = (track_info_t*)trackData;
+
+      toc.last().m_lastSector = from4Byte( trackInfo->track_start ) - 1;
+
+      delete [] trackData;
+    }
+  }
+
+
+  if( needToClose )
+    close();
+
+  return success;
+}
+
+
+bool K3bDevice::Device::readRawToc( K3bDevice::Toc& toc ) const
+{
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  bool success = false;
+
+  toc.clear();
+
+  if( open() ) {
+    //
+    // Read Raw TOC (format: 0010b)
+    //
+    // For POINT from 01h-63h we get all the tracks
+    // POINT a1h gices us the last track number in the session in PMIN
+    // POINT a2h gives the start of the session lead-out in PMIN,PSEC,PFRAME
+    //
+
+    unsigned char* data = 0;
+    unsigned int dataLen = 0;
+
+    if( readTocPmaAtip( &data, dataLen, 2, false, 1 ) ) {
+      if( dataLen > 4 ) {
+	success = true;
+
+	toc_raw_track_descriptor* tr = (toc_raw_track_descriptor*)&data[4];
+
+	//
+	// debug the raw toc data
+	//
+	k3bDebug() << "Session |  ADR   | CONTROL|  TNO   | POINT  |  Min   |  Sec   | Frame  |  Zero  |  PMIN  |  PSEC  | PFRAME |" << endl;
+	for( unsigned int i = 0; i < (dataLen-4)/(int)sizeof(toc_raw_track_descriptor); ++i ) {
+	  QString s;
+	  s += QString( " %1 |" ).arg( (int)tr[i].session_number, 6 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].adr, 6 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].control, 6 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].tno, 6 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].point, 6, 16 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].min, 6 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].sec, 6 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].frame, 6 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].zero, 6, 16 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].p_min, 6 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].p_sec, 6 );
+	  s += QString( " %1 |" ).arg( (int)tr[i].p_frame, 6 );
+	  k3bDebug() << s << endl;
+	}
+
+	//
+	// First we try to determine if the raw toc data uses BCD values
+	//
+	int isBcd = rawTocDataWithBcdValues( data, dataLen );
+	if( isBcd == -1 ) {
+	  delete [] data;
+	  return false;
+	}
+
+	K3b::Msf sessionLeadOut;
+
+	for( unsigned int i = 0; i < (dataLen-4)/(unsigned int)sizeof(toc_raw_track_descriptor); ++i ) {
+	  if( tr[i].adr == 1 && tr[i].point <= 0x63 ) {
+	    // track
+	    K3bTrack track;
+	    track.m_session = tr[i].session_number;
+
+	    // :( We use 00:00:00 == 0 lba)
+	    if( isBcd )
+	      track.m_firstSector = K3b::Msf( K3bDevice::fromBcd(tr[i].p_min),
+					      K3bDevice::fromBcd(tr[i].p_sec),
+					      K3bDevice::fromBcd(tr[i].p_frame) ) - 150;
+	    else
+	      track.m_firstSector = K3b::Msf( tr[i].p_min, tr[i].p_sec, tr[i].p_frame ) - 150;
+
+	    track.m_type = ( tr[i].control & 0x4 ? Track::DATA : Track::AUDIO );
+	    track.m_mode = ( track.type() == Track::DATA ? getTrackDataMode(track) : Track::UNKNOWN );
+	    track.m_copyPermitted = ( tr[i].control & 0x2 );
+	    track.m_preEmphasis = ( tr[i].control & 0x1 );
+
+	    //
+	    // only do this within a session because otherwise we already set the last sector with the session leadout
+	    //
+	    if( !toc.isEmpty() )
+	      if( toc[toc.count()-1].session() == track.session() )
+		toc[toc.count()-1].m_lastSector = track.firstSector() - 1;
+
+	    toc.append(track);
+	  }
+	  else if( tr[i].point == 0xa2 ) {
+	    //
+	    // since the session is always reported before the tracks this is where we do this:
+	    // set the previous session's last tracks's last sector to the first sector of the
+	    // session leadout (which was reported before the tracks)
+	    //
+	    // This only happens on multisession CDs
+	    //
+	    if( !toc.isEmpty() )
+	      toc[toc.count()-1].m_lastSector = sessionLeadOut - 1;
+
+	    // this is save since the descriptors are reported in ascending order of the session number
+	    // :( We use 00:00:00 == 0 lba)
+	    if( isBcd )
+	      sessionLeadOut = K3b::Msf( K3bDevice::fromBcd(tr[i].p_min),
+					 K3bDevice::fromBcd(tr[i].p_sec),
+					 K3bDevice::fromBcd(tr[i].p_frame) ) - 150;
+	    else
+	      sessionLeadOut = K3b::Msf( tr[i].p_min, tr[i].p_sec, tr[i].p_frame ) - 150;
+	  }
+	}
+
+	k3bDebug() << blockDeviceName() << ": setting last sector of last track to " << (sessionLeadOut-1).lba() << endl;
+
+	// set the last track's last sector
+	if( !toc.isEmpty() )
+	  toc[toc.count()-1].m_lastSector = sessionLeadOut - 1;
+      }
+      else
+	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " empty raw toc." << endl;
+
+      delete [] data;
+    }
+  }
+
+  if( needToClose )
+    close();
+
+  return success;
+}
+
+
+int K3bDevice::Device::rawTocDataWithBcdValues( unsigned char* data, unsigned int dataLen ) const
+{
+  toc_raw_track_descriptor* tr = (toc_raw_track_descriptor*)&data[4];
+
+  bool notBcd = false;
+  bool notHex = false;
+
+  //
+  // in most cases this will already tell us if a drive does not provide bcd numbers
+  // (which should be all newer MMC drives)
+  //
+  for( unsigned int i = 0; i < (dataLen-4)/(unsigned int)sizeof(toc_raw_track_descriptor); ++i ) {
+    if( tr[i].adr == 1 && tr[i].point <= 0xa2) {
+      if( !K3bDevice::isValidBcd(tr[i].p_min) ||
+	  !K3bDevice::isValidBcd(tr[i].p_sec) ||
+	  !K3bDevice::isValidBcd(tr[i].p_frame) ) {
+	notBcd = true;
+	break;
+      }
+
+      // we only need to check sec and frame since min needs to be <= 99
+      // and bcd values are never bigger than 99.
+      else if( (int)K3bDevice::fromBcd(tr[i].p_sec) >= 60 ||
+	       (int)K3bDevice::fromBcd(tr[i].p_frame) >= 75 ) {
+	notBcd = true;
+	break;
+      }
+    }
+  }
+
+
+  //
+  // all values are valid bcd values but we still don't know for sure if they are really
+  // used as bcd. So we also check the HEX values.
+  //
+  for( unsigned int i = 0; i < (dataLen-4)/(unsigned int)sizeof(toc_raw_track_descriptor); ++i ) {
+    if( tr[i].adr == 1 && tr[i].point <= 0xa2 ) {
+      if( (int)tr[i].p_min > 99 ||
+	  (int)tr[i].p_sec >= 60 ||
+	  (int)tr[i].p_frame >= 75 ) {
+	notHex = true;
+	break;
+      }
+    }
+  }
+
+
+  //
+  // If all values are valid bcd and valid hex we check the start sectors of the tracks.
+  //
+  if( !notHex || !notBcd ) {
+    K3b::Msf sessionLeadOutHex, sessionLeadOutBcd;
+    K3b::Msf lastTrackHex, lastTrackBcd;
+
+    for( unsigned int i = 0; i < (dataLen-4)/(unsigned int)sizeof(toc_raw_track_descriptor); ++i ) {
+
+      if( tr[i].adr == 1 ) {
+	if( tr[i].point < 0x64 ) {
+
+	  // check hex values
+	  if( K3b::Msf( tr[i].p_min, tr[i].p_sec, tr[i].p_frame ) <
+	      lastTrackHex )
+	    notHex = true;
+
+	  // check bcd values
+	  if( K3b::Msf( K3bDevice::fromBcd(tr[i].p_min), K3bDevice::fromBcd(tr[i].p_sec), K3bDevice::fromBcd(tr[i].p_frame) ) <
+	      lastTrackBcd )
+	    notBcd = true;
+
+	  lastTrackBcd = K3b::Msf( K3bDevice::fromBcd(tr[i].p_min), K3bDevice::fromBcd(tr[i].p_sec), K3bDevice::fromBcd(tr[i].p_frame) );
+	  lastTrackHex = K3b::Msf( tr[i].p_min, tr[i].p_sec, tr[i].p_frame );
+	}
+	else if( tr[i].point == 0xa2 ) {
+	  if( sessionLeadOutHex < lastTrackHex )
+	    notHex = true;
+	  if( sessionLeadOutBcd < lastTrackBcd )
+	    notBcd = true;
+
+	  sessionLeadOutHex = K3b::Msf( tr[i].p_min, tr[i].p_sec, tr[i].p_frame );
+	  sessionLeadOutBcd = K3b::Msf( K3bDevice::fromBcd(tr[i].p_min), K3bDevice::fromBcd(tr[i].p_sec), K3bDevice::fromBcd(tr[i].p_frame) );
+	}
+      }
+    }
+
+    // check the last track
+    if( sessionLeadOutHex < lastTrackHex )
+      notHex = true;
+    if( sessionLeadOutBcd < lastTrackBcd )
+      notBcd = true;
+  }
+
+
+  if( !notBcd && !notHex ) {
+    k3bDebug() << "(K3bDevice::Device) need to compare raw toc to formatted toc. :(" << endl;
+    //
+    // All values are valid bcd and valid HEX values so we compare with the formatted toc.
+    // This slows us down a lot but in most cases this should not be reached anyway.
+    //
+    // TODO: also check the bcd values
+    //
+    K3bDevice::Toc formattedToc;
+    if( readFormattedToc( formattedToc, MEDIA_CD_ROM ) ) {
+      for( unsigned int i = 0; i < (dataLen-4)/(unsigned int)sizeof(toc_raw_track_descriptor); ++i ) {
+	if( tr[i].adr == 1 && tr[i].point < 0x64 ) {
+	  unsigned int track = (int)tr[i].point;
+
+	  // FIXME: do bcd drive also encode the track number in bcd? If so test it, too.
+
+	  if( track > formattedToc.count() ) {
+	    notHex = true;
+	    break;
+	  }
+
+	  K3b::Msf posHex( tr[i].p_min,
+			   tr[i].p_sec,
+			   tr[i].p_frame );
+	  K3b::Msf posBcd( K3bDevice::fromBcd(tr[i].p_min),
+			   K3bDevice::fromBcd(tr[i].p_sec),
+			   K3bDevice::fromBcd(tr[i].p_frame) );
+	  posHex -= 150;
+	  posBcd -= 150;
+	  if( posHex != formattedToc[track-1].firstSector() )
+	    notHex = true;
+	  if( posBcd != formattedToc[track-1].firstSector() )
+	    notBcd = true;
+	}
+      }
+    }
+  }
+
+  if( notBcd )
+    k3bDebug() << "(K3bDevice::Device) found invalid bcd values. No bcd toc." << endl;
+  if( notHex )
+    k3bDebug() << "(K3bDevice::Device) found invalid hex values. No hex toc." << endl;
+
+  if( notBcd == notHex ) {
+    k3bDebug() << "(K3bDevice::Device) unable to determine if hex (" << notHex << ") or bcd (" << notBcd << ")." << endl;
+    if( !notHex ) {
+      k3bDebug() << "Assuming hex encoding in favor of newer drives and the more reliable raw toc." << endl;
+      return 0;
+    }
+    return -1;
+  }
+  else if( notBcd )
+    return 0;
+  else
+    return 1;
+}
+
+
+K3bDevice::CdText K3bDevice::Device::readCdText() const
+{
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  K3bDevice::CdText textData;
+
+  if( open() ) {
+    unsigned char* data = 0;
+    unsigned int dataLen = 0;
+
+    if( readTocPmaAtip( &data, dataLen, 5, false, 0 ) ) {
+      textData.setRawPackData( data, dataLen );
+
+      delete [] data;
+    }
+
+    if( needToClose )
+      close();
+  }
+
+  return textData;
+}
+
+
+#ifdef Q_OS_LINUX
+// fallback
+bool K3bDevice::Device::readTocLinux( K3bDevice::Toc& toc ) const
+{
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  bool success = true;
+
+  toc.clear();
+
+  struct cdrom_tochdr tochdr;
+  struct cdrom_tocentry tocentry;
+
+  usageLock();
+  if( open() ) {
+    //
+    // CDROMREADTOCHDR ioctl returns:
+    // cdth_trk0: First Track Number
+    // cdth_trk1: Last Track Number
+    //
+    if( ::ioctl( d->deviceFd, CDROMREADTOCHDR, &tochdr ) ) {
+      k3bDebug() << "(K3bDevice::Device) could not get toc header !" << endl;
+      success = false;
+    }
+    else {
+      Track lastTrack;
+      for (int i = tochdr.cdth_trk0; i <= tochdr.cdth_trk1 + 1; i++) {
+        ::memset(&tocentry,0,sizeof (struct cdrom_tocentry));
+        // get Lead-Out Information too
+        tocentry.cdte_track = (i<=tochdr.cdth_trk1) ? i : CDROM_LEADOUT;
+        tocentry.cdte_format = CDROM_LBA;
+        //
+        // CDROMREADTOCENTRY ioctl returns:
+        // cdte_addr.lba: Start Sector Number (LBA Format requested)
+        // cdte_ctrl:     4 ctrl bits
+        //                   00x0b: 2 audio Channels(no pre-emphasis)
+        //                   00x1b: 2 audio Channels(pre-emphasis)
+        //                   10x0b: audio Channels(no pre-emphasis),reserved in cd-rw
+        //                   10x1b: audio Channels(pre-emphasis),reserved in cd-rw
+        //                   01x0b: data track, recorded uninterrupted
+        //                   01x1b: data track, recorded incremental
+        //                   11xxb: reserved
+        //                   xx0xb: digital copy prohibited
+        //                   xx1xb: digital copy permitted
+        // cdte_addr:     4 addr bits (type of Q-Subchannel data)
+        //                   0000b: no Information
+        //                   0001b: current position data
+        //                   0010b: MCN
+        //                   0011b: ISRC
+        //                   0100b-1111b:  reserved
+        // cdte_datamode:  0: Data Mode1
+        //                 1: CD-I
+        //                 2: CD-XA Mode2
+        //
+
+        if( ::ioctl( d->deviceFd, CDROMREADTOCENTRY, &tocentry ) ) {
+          k3bDebug() << "(K3bDevice::Device) error reading tocentry " << i << endl;
+	  success = false;
+	  break;
+	}
+
+        int startSec = tocentry.cdte_addr.lba;
+        int control  = tocentry.cdte_ctrl & 0x0f;
+        int mode     = tocentry.cdte_datamode;
+        if( i > tochdr.cdth_trk0 ) {
+	  Track track( lastTrack.firstSector(), startSec-1, lastTrack.type(), lastTrack.mode() );
+	  track.m_preEmphasis = control & 0x1;
+	  track.m_copyPermitted = control & 0x2;
+          toc.append( track );
+        }
+        int trackType = 0;
+        int trackMode = Track::UNKNOWN;
+        if( (control & 0x04 ) && (tocentry.cdte_track != CDROM_LEADOUT) ) {
+          trackType = Track::DATA;
+          if( mode == 1 )
+            trackMode = Track::MODE1;
+          else if( mode == 2 )
+            trackMode = Track::MODE2;
+
+          mode = getDataMode(startSec);
+          if( mode != Track::UNKNOWN )
+            trackMode = mode;
+        }
+	else
+          trackType = Track::AUDIO;
+
+        lastTrack = Track( startSec, startSec, trackType, trackMode );
+      }
+    }
+
+    if( needToClose )
+      close();
+  }
+  else
+    success = false;
+
+  usageUnlock();
+
+  return success;
+}
+#endif // Q_OS_LINUX
+
+
+bool K3bDevice::Device::fixupToc( K3bDevice::Toc& toc ) const
+{
+  bool success = false;
+
+  //
+  // This is a very lame method of fixing the TOC of an Advanced Audio CD
+  // (a CD with two sessions: one with audio tracks and one with the data track)
+  // If a drive does not support reading raw toc or reading track info we only
+  // get every track's first sector. But between sessions there is a gap which is used
+  // for ms stuff. In this case it's 11400 sectors in size. When ripping ausio we would
+  // include these 11400 sectors which would result in a strange ending audio file.
+  //
+  if( numSessions() > 1 || toc.contentType() == MIXED ) {
+    k3bDebug() << "(K3bDevice::Device) fixup multisession toc..." << endl;
+
+    //
+    // we need to update the last sector of every last track in every session
+    // for now we only update the track before the last session...
+    // This is the most often case: Advanced Audio CD
+    //
+
+    unsigned char* data = 0;
+    unsigned int dataLen = 0;
+    if( readTocPmaAtip( &data, dataLen, 1, false, 0 ) ) {
+
+      //
+      // data[6]    - first track number in last complete session
+      // data[8-11] - start address of first track in last session
+      //
+
+      toc[(unsigned int)data[6]-2].m_lastSector = from4Byte( &data[8] ) - 11400 - 1;
+
+      delete [] data;
+      success = true;
+    }
+    else
+      k3bDebug() << "(K3bDevice::Device) FIXUP TOC failed." << endl;
+  }
+
+  return success;
+}
+
+
+bool K3bDevice::Device::block( bool b ) const
+{
+  //
+  // For some reason the Scsi Command does not work here.
+  // So we use the ioctl on Linux systems
+  //
+#if defined(Q_OS_LINUX)
+    bool success = false;
+    bool needToClose = !isOpen();
+    usageLock();
+    if( open() ) {
+        success = ( ::ioctl( d->deviceFd, CDROM_LOCKDOOR, b ? 1 : 0 ) == 0 );
+        if( needToClose )
+            close();
+    }
+    usageUnlock();
+    if ( success )
+        return success;
+#elif defined(Q_OS_NETBSD)
+    bool success = false;
+    bool needToClose = !isOpen();
+    int arg = b ? 1 : 0;
+    usageLock();
+    if( open() ) {
+        success = ( ::ioctl( d->deviceFd, DIOCLOCK, &arg ) == 0 );
+        if( needToClose )
+            close();
+    }
+    usageUnlock();
+    if ( success )
+        return success;
+#endif
+
+    ScsiCommand cmd( this );
+    cmd[0] = MMC_PREVENT_ALLOW_MEDIUM_REMOVAL;
+    cmd[5] = 0; // Necessary to set the proper command length
+    if( b )
+        cmd[4] = 0x01;
+    int r = cmd.transport( TR_DIR_WRITE );
+
+    if( r )
+        k3bDebug() << "(K3bDevice::Device) MMC ALLOW MEDIA REMOVAL failed." << endl;
+
+    return ( r == 0 );
+}
+
+bool K3bDevice::Device::rewritable() const
+{
+  unsigned char* data = 0;
+  unsigned int dataLen = 0;
+
+  if( readDiscInformation( &data, dataLen ) ) {
+    disc_info_t* inf = (disc_info_t*)data;
+    bool e = inf->erasable;
+
+    delete [] data;
+
+    return e;
+  }
+  else
+    return false;
+}
+
+
+bool K3bDevice::Device::eject() const
+{
+#ifdef Q_OS_NETBSD
+    bool success = false;
+    bool needToClose = !isOpen();
+    int arg = 0;
+
+    usageLock();
+    if( open() ) {
+        if ( ::ioctl( d->deviceFd, DIOCEJECT, &arg ) >= 0)
+            success = true;
+        if( needToClose )
+            close();
+    }
+    usageUnlock();
+    if ( success )
+        return success;
+#elif defined(Q_OS_LINUX)
+    bool success = false;
+    bool needToClose = !isOpen();
+
+    usageLock();
+    if( open() ) {
+        if( ::ioctl( d->deviceFd, CDROMEJECT ) >= 0 )
+            success = true;
+        if( needToClose )
+            close();
+    }
+    usageUnlock();
+    if ( success )
+        return success;
+#endif
+
+    ScsiCommand cmd( this );
+    cmd[0] = MMC_PREVENT_ALLOW_MEDIUM_REMOVAL;
+    cmd[5] = 0; // Necessary to set the proper command length
+    cmd.transport();
+
+    cmd[0] = MMC_START_STOP_UNIT;
+    cmd[5] = 0; // Necessary to set the proper command length
+    cmd[4] = 0x1;      // Start unit
+    cmd.transport();
+
+    cmd[4] = 0x2;    // LoEj = 1, Start = 0
+
+    return !cmd.transport();
+}
+
+
+bool K3bDevice::Device::load() const
+{
+#ifdef Q_OS_NETBSD
+    bool success = false;
+    bool needToClose = !isOpen();
+    int arg = 0;
+
+    usageLock();
+    if( open() ) {
+        if ( ::ioctl( d->deviceFd, CDIOCCLOSE, &arg ) >= 0)
+            success = true;
+        if( needToClose )
+            close();
+    }
+    usageUnlock();
+    if ( success )
+        return success;
+#elif defined(Q_OS_LINUX)
+    bool success = false;
+    bool needToClose = !isOpen();
+
+    usageLock();
+    if( open() ) {
+        if( ::ioctl( d->deviceFd, CDROMCLOSETRAY ) >= 0 )
+            success = true;
+        if( needToClose )
+            close();
+    }
+    usageUnlock();
+    if ( success )
+        return success;
+#endif
+
+    ScsiCommand cmd( this );
+    cmd[0] = MMC_START_STOP_UNIT;
+    cmd[4] = 0x3;    // LoEj = 1, Start = 1
+    cmd[5] = 0;      // Necessary to set the proper command length
+    return !cmd.transport();
+}
+
+
+bool K3bDevice::Device::setAutoEjectEnabled( bool enabled ) const
+{
+  bool success = false;
+#ifdef Q_OS_LINUX
+
+  bool needToClose = !isOpen();
+  usageLock();
+  if ( open() ) {
+      success = ( ::ioctl( d->deviceFd, CDROMEJECT_SW, enabled ? 1 : 0 ) == 0 );
+      if ( needToClose ) {
+          close();
+      }
+  }
+  usageUnlock();
+#endif
+  return success;
+}
+
+
+void K3bDevice::Device::addDeviceNode( const QString& n )
+{
+  if( !d->allNodes.contains( n ) )
+    d->allNodes.append( n );
+}
+
+
+const QStringList& K3bDevice::Device::deviceNodes() const
+{
+  return d->allNodes;
+}
+
+
+K3bDevice::Device::Handle K3bDevice::Device::handle() const
+{
+#ifdef Q_OS_FREEBSD
+  return d->cam;
+#else
+  return d->deviceFd;
+#endif
+}
+
+
+bool K3bDevice::Device::open( bool write ) const
+{
+  if( d->openedReadWrite != write )
+    close();
+
+  QMutexLocker ml( &d->openCloseMutex );
+
+  d->openedReadWrite = write;
+
+#ifdef Q_OS_FREEBSD
+  if( !d->cam ) {
+    d->cam = cam_open_pass (m_passDevice.latin1(), O_RDWR,0 /* NULL */);
+    k3bDebug() << "(K3bDevice::openDevice) open device " << m_passDevice
+	      << ((d->cam)?" succeeded.":" failed.") << endl;
+  }
+
+  return (d->cam != 0);
+#endif
+#if defined(Q_OS_LINUX) || defined(Q_OS_NETBSD)
+  if( d->deviceFd == -1 )
+    d->deviceFd = openDevice( QFile::encodeName(devicename()), write );
+
+  return ( d->deviceFd != -1 );
+#endif
+}
+
+
+void K3bDevice::Device::close() const
+{
+  QMutexLocker ml( &d->openCloseMutex );
+
+#ifdef Q_OS_FREEBSD
+  if( d->cam ) {
+    cam_close_device(d->cam);
+    d->cam = 0;
+  }
+#endif
+#if defined(Q_OS_LINUX) || defined(Q_OS_NETBSD)
+  if( d->deviceFd != -1 ) {
+    ::close( d->deviceFd );
+    d->deviceFd = -1;
+  }
+#endif
+}
+
+
+bool K3bDevice::Device::isOpen() const
+{
+#ifdef Q_OS_FREEBSD
+  return d->cam;
+#endif
+#if defined(Q_OS_LINUX) || defined(Q_OS_NETBSD)
+  return ( d->deviceFd != -1 );
+#endif
+}
+
+
+int K3bDevice::Device::supportedProfiles() const
+{
+  return d->supportedProfiles;
+}
+
+
+int K3bDevice::Device::currentProfile() const
+{
+  unsigned char profileBuf[8];
+  ::memset( profileBuf, 0, 8 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_GET_CONFIGURATION;
+  cmd[1] = 1;
+  cmd[8] = 8;
+  cmd[9] = 0;      // Necessary to set the proper command length
+
+  if( cmd.transport( TR_DIR_READ, profileBuf, 8 ) ) {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+	       << " GET_CONFIGURATION failed." << endl;
+    return MEDIA_UNKNOWN;
+  }
+  else {
+    short profile = from2Byte( &profileBuf[6] );
+
+    //
+    // Plextor drives might not set a current profile
+    // In that case we get the list of all current profiles
+    // and simply use the first one in that list.
+    //
+    if( profile == 0x00 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		 << " current profile 0. Checking current profile list instead." << endl;
+      unsigned char* data;
+      unsigned int len = 0;
+      if( getFeature( &data, len, FEATURE_PROFILE_LIST ) ) {
+	int featureLen( data[11] );
+	for( int j = 0; j < featureLen; j+=4 ) {
+	  // use the first current profile we encounter
+	  if( data[12+j+2] & 0x1 ) {
+	    profile = from2Byte( &data[12+j] );
+	    break;
+	  }
+	}
+
+	delete[] data;
+      }
+    }
+
+    switch (profile) {
+    case 0x00: return MEDIA_NONE;
+    case 0x08: return MEDIA_CD_ROM;
+    case 0x09: return MEDIA_CD_R;
+    case 0x0A: return MEDIA_CD_RW;
+    case 0x10: return MEDIA_DVD_ROM;
+    case 0x11: return MEDIA_DVD_R_SEQ;
+    case 0x12: return MEDIA_DVD_RAM;
+    case 0x13: return MEDIA_DVD_RW_OVWR;
+    case 0x14: return MEDIA_DVD_RW_SEQ;
+    case 0x15: return MEDIA_DVD_R_DL_SEQ;
+    case 0x16: return MEDIA_DVD_R_DL_JUMP;
+    case 0x1A: return MEDIA_DVD_PLUS_RW;
+    case 0x1B: return MEDIA_DVD_PLUS_R;
+    case 0x2B: return MEDIA_DVD_PLUS_R_DL;
+    case 0x40: return MEDIA_BD_ROM;
+    case 0x41: {
+      if( featureCurrent( FEATURE_BD_PSEUDO_OVERWRITE ) == 1 )
+	return MEDIA_BD_R_SRM_POW;
+      else
+	return MEDIA_BD_R_SRM;
+    }
+    case 0x42: return MEDIA_BD_R_RRM;
+    case 0x43: return MEDIA_BD_RE;
+    case 0x50: return MEDIA_HD_DVD_ROM;
+    case 0x51: return MEDIA_HD_DVD_R;
+    case 0x52: return MEDIA_HD_DVD_RAM;
+    default: return MEDIA_UNKNOWN;
+    }
+  }
+}
+
+
+K3bDevice::DiskInfo K3bDevice::Device::diskInfo() const
+{
+  DiskInfo inf;
+
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  if( open() ) {
+
+    unsigned char* data = 0;
+    unsigned int dataLen = 0;
+
+    //
+    // The first thing to do should be: checking if a media is loaded
+    // We cannot rely on the profile here since at least some Plextor
+    // drives return the NO MEDIUM profile for CD media
+    //
+    if( !testUnitReady() ) {
+      // no disk or tray open
+      inf.m_diskState = STATE_NO_MEDIA;
+      inf.m_mediaType = MEDIA_NONE;
+      inf.m_currentProfile = MEDIA_NONE;
+    }
+    else
+      inf.m_currentProfile = currentProfile();
+
+    if( inf.diskState() != STATE_NO_MEDIA ) {
+
+      if( readDiscInformation( &data, dataLen ) ) {
+	disc_info_t* dInf = (disc_info_t*)data;
+	//
+	// Copy the needed values from the disk_info struct
+	//
+	switch( dInf->status ) {
+	case 0:
+	  inf.m_diskState = STATE_EMPTY;
+	  break;
+	case 1:
+	  inf.m_diskState = STATE_INCOMPLETE;
+	  break;
+	case 2:
+	  inf.m_diskState = STATE_COMPLETE;
+	  break;
+	default:
+	  inf.m_diskState = STATE_UNKNOWN;
+	  break;
+	}
+
+	switch( dInf->border ) {
+	case 0:
+	  inf.m_lastSessionState = STATE_EMPTY;
+	  break;
+	case 1:
+	  inf.m_lastSessionState = STATE_INCOMPLETE;
+	  break;
+	case 2:
+	  inf.m_lastSessionState = STATE_COMPLETE;
+	  break;
+	default:
+	  inf.m_lastSessionState = STATE_UNKNOWN;
+	  break;
+	}
+
+        switch( dInf->bg_f_status&0x3 ) {
+        case 0x0:
+            inf.m_bgFormatState = BG_FORMAT_NONE;
+            break;
+        case 0x1:
+            inf.m_bgFormatState = BG_FORMAT_INCOMPLETE;
+            break;
+        case 0x2:
+            inf.m_bgFormatState = BG_FORMAT_IN_PROGRESS;
+            break;
+        case 0x3:
+            inf.m_bgFormatState = BG_FORMAT_COMPLETE;
+            break;
+        }
+
+	inf.m_numTracks = (dInf->last_track_l & 0xff) | (dInf->last_track_m<<8 & 0xff00);
+	if( inf.diskState() == STATE_EMPTY )
+	  inf.m_numTracks = 0;
+
+	// FIXME: I am not sure if this is accurate. Better test the last track's RT field
+	else if( inf.diskState() == STATE_INCOMPLETE )
+	  inf.m_numTracks--;  // do not count the invisible track
+
+	inf.m_rewritable = dInf->erasable;
+
+	//
+	// This is the Last Possible Lead-Out Start Address in HMSF format
+	// This is only valid for CD-R(W) and DVD+R media.
+	// For complete media this shall be filled with 0xff
+	//
+	if( dInf->lead_out_m != 0xff &&
+	    dInf->lead_out_r != 0xff &&
+	    dInf->lead_out_s != 0xff &&
+	    dInf->lead_out_f != 0xff )
+	  inf.m_capacity = K3b::Msf( dInf->lead_out_m + dInf->lead_out_r*60,
+				     dInf->lead_out_s,
+				     dInf->lead_out_f ) - 150;
+
+	//
+	// This is the position where the next Session shall be recorded in HMSF format
+	// This is only valid for CD-R(W) and DVD+R media.
+	// For complete media this shall be filled with 0xff
+	//
+	if( dInf->lead_in_m != 0xff &&
+	    dInf->lead_in_r != 0xff &&
+	    dInf->lead_in_s != 0xff &&
+	    dInf->lead_in_f != 0xff )
+	  inf.m_usedCapacity = K3b::Msf( dInf->lead_in_m + dInf->lead_in_r*60,
+					 dInf->lead_in_s,
+					 dInf->lead_in_f ) - 4500;
+
+	delete [] data;
+      }
+      else {
+	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		   << " fabricating disk information for a stupid device." << endl;
+	Toc toc = readToc();
+	if( !toc.isEmpty() ) {
+	  inf.m_diskState = STATE_COMPLETE;
+	  inf.m_lastSessionState = STATE_COMPLETE;
+	  inf.m_numTracks = toc.count();
+	  inf.m_capacity = inf.m_usedCapacity = toc.length();
+	}
+      }
+
+
+      //
+      // The mediatype needs to be set
+      //
+      inf.m_mediaType = mediaType();
+
+      // At least some Plextor drives return profile NONE for CD media
+      // or CD_ROM for writable media
+      if( inf.m_mediaType & (MEDIA_UNKNOWN|MEDIA_NONE|MEDIA_CD_ROM) ) {
+	// probably it is a CD
+	if( inf.rewritable() )
+	  inf.m_mediaType = MEDIA_CD_RW;
+	else if( inf.empty() || inf.appendable() )
+	  inf.m_mediaType = MEDIA_CD_R;
+	else
+	  inf.m_mediaType = MEDIA_CD_ROM;
+      }
+
+      if( inf.m_mediaType & MEDIA_DVD_ALL ) {
+	if( readDvdStructure( &data, dataLen ) ) {
+	  // some debugging stuff
+	  K3b::Msf sda, eda, ea0;
+	  sda = ( data[4+5]<<16 | data[4+6] << 8 | data[4+7] );
+	  eda = ( data[4+9]<<16 | data[4+10] << 8 | data[4+11] );
+	  ea0 = ( data[4+13]<<16 | data[4+14] << 8 | data[4+15] );
+
+	  k3bDebug() << "First sec data area: " << sda.toString()
+		    << " (LBA " << QString::number(sda.lba())
+		    << ") (" << QString::number(sda.mode1Bytes()) << endl;
+	  k3bDebug() << "Last sec data area: " << eda.toString()
+		    << " (LBA " << QString::number(eda.lba())
+		    << ") (" << QString::number(eda.mode1Bytes()) << " Bytes)" << endl;
+	  k3bDebug() << "Last sec layer 1: " << ea0.toString()
+		    << " (LBA " << QString::number(ea0.lba())
+		    << ") (" << QString::number(ea0.mode1Bytes()) << " Bytes)" << endl;
+
+
+	  K3b::Msf da0 = ea0 - sda + 1;
+	  K3b::Msf da1 = eda - ea0;
+	  k3bDebug() << "Layer 1 length: " << da0.toString()
+		    << " (LBA " << QString::number(da0.lba())
+		    << ") (" << QString::number(da0.mode1Bytes()) << " Bytes)" << endl;
+	  k3bDebug() << "Layer 2 length: " << da1.toString()
+		    << " (LBA " << QString::number(da1.lba())
+		    << ") (" << QString::number(da1.mode1Bytes()) << " Bytes)" << endl;
+
+	  inf.m_numLayers = ((data[6]&0x60) == 0 ? 1 : 2);
+
+	  bool otp = (data[4+2] & 0xF);
+
+	  // ea0 is 0 if the medium does not use Opposite track path
+	  if( otp && ea0 > 0 )
+	    inf.m_firstLayerSize = da0;
+	  else
+	    inf.m_firstLayerSize = 0;
+
+	  delete [] data;
+	}
+	else {
+	  k3bDebug() << "(K3bDevice::Device) Unable to read DVD structure for num of layers." << endl;
+	  inf.m_numLayers = ( (inf.m_mediaType & MEDIA_WRITABLE_DVD_DL) ? 2 : 1 );
+	}
+      }
+
+
+      //
+      // Number of sessions for non-empty disks
+      //
+      if( inf.diskState() != STATE_EMPTY ) {
+	int sessions = numSessions();
+	if( sessions >= 0 )
+	  inf.m_numSessions = sessions;
+	else
+	  k3bDebug() << "(K3bDevice::Device) could not get session info via READ TOC/PMA/ATIP." << endl;
+      }
+      else
+	inf.m_numSessions = 0;
+
+      inf.m_mediaId = mediaId( inf.mediaType() );
+
+      //
+      // Now we determine the size:
+
+      // for all empty and appendable media READ FORMAT CAPACITIES should return the proper unformatted size
+      // for complete disks we may use the READ_CAPACITY command or the start sector from the leadout
+      //
+      int media = inf.mediaType();
+      //
+      // Use the profile if available because DVD-ROM units need to treat DVD+-R(W) media as DVD-ROM
+      // if supported at all
+      //
+      if( inf.currentProfile() == MEDIA_DVD_ROM )
+	media = MEDIA_DVD_ROM;
+
+      switch( media ) {
+      case MEDIA_CD_R:
+      case MEDIA_CD_RW:
+	if( inf.m_capacity == 0 ) {
+	  if( readTocPmaAtip( &data, dataLen, 0x4, true, 0 ) ) {
+
+	    struct atip_descriptor* atip = (struct atip_descriptor*)data;
+
+	    if( dataLen >= 11 ) {
+	      inf.m_capacity = K3b::Msf( atip->lead_out_m, atip->lead_out_s, atip->lead_out_f ) - 150;
+	      debugBitfield( &atip->lead_out_m, 3 );
+	      k3bDebug() << blockDeviceName() << ": ATIP capacity: " << inf.m_capacity.toString() << endl;
+	    }
+
+	    delete [] data;
+	  }
+	}
+
+	//
+	// for empty and appendable media capacity and usedCapacity should be filled in from
+	// diskinfo above. If not they are both still 0
+	//
+	if( inf.m_capacity != 0 &&
+	    ( inf.diskState() == STATE_EMPTY || inf.m_usedCapacity != 0 ) ) {
+	  // done.
+	  break;
+	}
+
+      default:
+      case MEDIA_CD_ROM:
+	if( inf.m_capacity > 0 && inf.m_usedCapacity == 0 )
+	  inf.m_usedCapacity = inf.m_capacity;
+
+	if( inf.m_usedCapacity == 0 ) {
+	  K3b::Msf readCap;
+	  if( readCapacity( readCap ) ) {
+	    k3bDebug() << "(K3bDevice::Device) READ CAPACITY: " << readCap.toString()
+		      << " other capacity: " << inf.m_capacity.toString() << endl;
+	    //
+	    // READ CAPACITY returns the last written sector
+	    // that means the size is actually readCap + 1
+	    //
+	    inf.m_usedCapacity = readCap + 1;
+	  }
+	  else {
+	    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		      << " Falling back to readToc for capacity." << endl;
+	    inf.m_usedCapacity = readToc().length();
+	  }
+	}
+
+      case MEDIA_DVD_ROM: {
+	K3b::Msf readCap;
+	if( readCapacity( readCap ) ) {
+	  k3bDebug() << "(K3bDevice::Device) READ CAPACITY: " << readCap.toString()
+		    << " other capacity: " << inf.m_capacity.toString() << endl;
+	  //
+	  // READ CAPACITY returns the last written sector
+	  // that means the size is actually readCap + 1
+	  //
+	  inf.m_usedCapacity = readCap + 1;
+	}
+	else {
+	  //
+	  // Only one track, use it's size
+	  //
+	  if( readTrackInformation( &data, dataLen, 0x1, 0x1 ) ) {
+	    track_info_t* trackInfo = (track_info_t*)data;
+	    inf.m_usedCapacity = from4Byte( trackInfo->track_size );
+	    delete [] data;
+	  }
+	  else
+	    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		      << "READ TRACK INFORMATION for DVD-ROM failed." << endl;
+	}
+
+	break;
+      }
+
+      case MEDIA_DVD_PLUS_R:
+      case MEDIA_DVD_PLUS_R_DL:
+	if( inf.appendable() || inf.empty() ) {
+	  //
+	  // get remaining space via the invisible track
+	  //
+	  if( readTrackInformation( &data, dataLen, 0x1, /*0xff*/ inf.numTracks()+1 ) ) {
+	    track_info_t* trackInfo = (track_info_t*)data;
+	    inf.m_usedCapacity = from4Byte( trackInfo->track_start );
+	    inf.m_capacity = from4Byte( trackInfo->track_start ) + from4Byte( trackInfo->track_size );
+	    delete [] data;
+	  }
+	}
+	else {
+	  if( readTrackInformation( &data, dataLen, 0x1, inf.numTracks() ) ) {
+	    track_info_t* trackInfo = (track_info_t*)data;
+	    inf.m_capacity = inf.m_usedCapacity
+	      = from4Byte( trackInfo->track_start ) + from4Byte( trackInfo->track_size );
+	    delete [] data;
+	  }
+	}
+	break;
+
+      case MEDIA_DVD_R:
+      case MEDIA_DVD_R_SEQ:
+      case MEDIA_DVD_R_DL:
+      case MEDIA_DVD_R_DL_JUMP:
+      case MEDIA_DVD_R_DL_SEQ:
+	//
+	// get data from the incomplete track (which is NOT the invisible track 0xff)
+	// This will fail in case the media is complete!
+	//
+	if( readTrackInformation( &data, dataLen, 0x1, inf.numTracks()+1 ) ) {
+	  track_info_t* trackInfo = (track_info_t*)data;
+	  inf.m_usedCapacity = from4Byte( trackInfo->track_start );
+	  inf.m_capacity = from4Byte( trackInfo->free_blocks ) + from4Byte( trackInfo->track_start );
+	  delete [] data;
+	}
+
+	//
+	// Get the "really" used space without border-out
+	//
+	if( !inf.empty() ) {
+	  K3b::Msf readCap;
+	  if( readCapacity( readCap ) ) {
+	    //
+	    // READ CAPACITY returns the last written sector
+	    // that means the size is actually readCap + 1
+	    //
+	    inf.m_usedCapacity = readCap + 1;
+	  }
+	  else
+	    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		      << " READ CAPACITY for DVD-R failed." << endl;
+	}
+
+	break;
+
+      case MEDIA_DVD_RW_OVWR:
+	inf.m_numSessions = 1;
+      case MEDIA_DVD_RW:
+      case MEDIA_DVD_RW_SEQ:
+	// only one track on a DVD-RW media
+	if( readTrackInformation( &data, dataLen, 0x1, 0x1 ) ) {
+	  track_info_t* trackInfo = (track_info_t*)data;
+	  inf.m_capacity = from4Byte( trackInfo->track_size );
+	  if( !inf.empty() ) {
+	    if( readFormatCapacity( 0x10, inf.m_capacity ) )
+	      k3bDebug() << blockDeviceName() << ": Format capacity 0x10: " << inf.m_capacity.toString() << endl;
+
+	    inf.m_usedCapacity = from4Byte( trackInfo->track_size );
+	  }
+
+	  delete [] data;
+	}
+	break;
+
+      case MEDIA_DVD_PLUS_RW: {
+	K3b::Msf currentMax;
+	int currentMaxFormat = 0;
+	if( readFormatCapacity( 0x26, inf.m_capacity, &currentMax, &currentMaxFormat ) ) {
+            if( currentMaxFormat == 0x1 ) { // unformatted or blank media
+                inf.m_usedCapacity = 0;
+                inf.m_capacity = currentMax;
+            }
+            else {
+                inf.m_usedCapacity = currentMax;
+                // Plextor drives tend to screw things up and report invalid values
+                // for the max format capacity of 1.4 GB DVD media
+                if ( inf.bgFormatState() == BG_FORMAT_COMPLETE ) {
+                    inf.m_capacity = currentMax;
+                }
+            }
+       	}
+	else
+	  k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		    << " READ FORMAT CAPACITIES for DVD+RW failed." << endl;
+
+	break;
+      }
+
+      case MEDIA_BD_R:
+      case MEDIA_BD_R_SRM:
+      case MEDIA_BD_R_SRM_POW:
+      case MEDIA_BD_R_RRM:
+      case MEDIA_BD_RE:
+	//
+	// get the invisible track's first sector
+	// or the next writable address of the last open track
+	//
+	if( readDiscInformation( &data, dataLen ) ) {
+	  int lastTrack = (int)( data[11]<<8 | data[6] );
+	  delete [] data;
+
+	  if( readTrackInformation( &data, dataLen, 1, lastTrack ) ) {
+
+	    // capacity: last track's start address + last track's size
+	    inf.m_capacity = from4Byte( data+8 ) + from4Byte( data+24 );
+
+	    if( data[6] & 0x80 )
+	      inf.m_usedCapacity = from4Byte( data+8 );
+	    else if( data[7] & 0x1 )
+	      inf.m_usedCapacity = from4Byte( data+12 );
+	    delete [] data;
+	  }
+	}
+	break;
+
+      case MEDIA_BD_ROM: {
+	K3b::Msf readCap;
+	if( readCapacity( readCap ) ) {
+	  //
+	  // READ CAPACITY returns the last written sector
+	  // that means the size is actually readCap + 1
+	  //
+	  inf.m_usedCapacity = readCap + 1;
+	}
+
+	break;
+      }
+      }
+    }
+
+    if( needToClose )
+      close();
+  }
+
+  return inf;
+}
+
+
+int K3bDevice::Device::mediaType() const
+{
+  int m = MEDIA_UNKNOWN;
+
+  if( testUnitReady() ) {
+
+    m = currentProfile();
+
+    if( m & (MEDIA_UNKNOWN|MEDIA_DVD_ROM|MEDIA_HD_DVD_ROM) ) {
+      //
+      // We prefere the mediatype as reported by the media since this way
+      // even ROM drives may report the correct type of writable media.
+      //
+
+      // 4 bytes header + 2048 bytes layer descriptor
+      unsigned char* data = 0;
+      unsigned int dataLen = 0;
+      if( readDvdStructure( &data, dataLen ) ) {
+	switch( data[4]&0xF0 ) {
+	case 0x00: m = MEDIA_DVD_ROM; break;
+	case 0x10: m = MEDIA_DVD_RAM; break;
+	case 0x20: m = MEDIA_DVD_R; break; // there seems to be no value for DVD-R DL, it reports DVD-R
+	case 0x30: m = MEDIA_DVD_RW; break;
+	case 0x40: m = MEDIA_HD_DVD_ROM; break;
+	case 0x50: m = MEDIA_HD_DVD_R; break;
+	case 0x60: m = MEDIA_HD_DVD_RAM; break;
+	case 0x90: m = MEDIA_DVD_PLUS_RW; break;
+	case 0xA0: m = MEDIA_DVD_PLUS_R; break;
+	case 0xE0: m = MEDIA_DVD_PLUS_R_DL; break;
+	default:
+	  k3bDebug() << "(K3bDevice::Device) unknown dvd media type: " << QString::number(data[4]&0xF0, 8) << endl;
+	  break; // unknown
+	}
+
+	delete [] data;
+      }
+    }
+
+    if( m & (MEDIA_UNKNOWN|MEDIA_BD_ROM) ) {
+      //
+      // We prefere the mediatype as reported by the media since this way
+      // even ROM drives may report the correct type of writable media.
+      //
+
+      unsigned char* data = 0;
+      unsigned int dataLen = 0;
+      if( readDiscStructure( &data, dataLen, 1, 0 ) ) {
+	if( dataLen > 4+12 &&
+	    data[4+8] == 'B' &&  data[4+9] == 'D' ) {
+	  switch( data[4+10] ) {
+	  case 'O': m = MEDIA_BD_ROM; break;
+	  case 'W': m = MEDIA_BD_RE; break;
+	  case 'R': m = MEDIA_BD_R; break;
+	  }
+	}
+
+	delete [] data;
+      }
+    }
+
+    //
+    // Only old CD or DVD devices do not report a current profile
+    // or report CD-ROM profile for all CD types
+    //
+    if( m & (MEDIA_UNKNOWN|MEDIA_CD_ROM) ) {
+      unsigned char* data = 0;
+      unsigned int dataLen = 0;
+      if( readTocPmaAtip( &data, dataLen, 4, false, 0 ) ) {
+	if( (data[6]>>6)&1 )
+	  m = MEDIA_CD_RW;
+	else
+	  m = MEDIA_CD_R;
+
+	delete [] data;
+      }
+      else
+	m = MEDIA_CD_ROM;
+    }
+  }
+
+  return m;
+}
+
+
+bool K3bDevice::Device::readSectorsRaw( unsigned char *buf, int start, int count ) const
+{
+  return readCd( buf, count*2352,
+		 0,      // all sector types
+		 false,  // no dap
+		 start,
+		 count,
+		 true, // SYNC
+		 true, // HEADER
+		 true, // SUBHEADER
+		 true, // USER DATA
+		 true, // EDC/ECC
+		 0,    // no c2 info
+		 0 );
+}
+
+
+
+void K3bDevice::Device::checkForJustLink()
+{
+  unsigned char* ricoh = 0;
+  unsigned int ricohLen = 0;
+  if( modeSense( &ricoh, ricohLen, 0x30 ) ) {
+
+    //
+    // 8 byte mode header + 6 byte page data
+    //
+
+    if( ricohLen >= 14 ) {
+      ricoh_mode_page_30* rp = (ricoh_mode_page_30*)(ricoh+8);
+      d->burnfree = rp->BUEFS;
+    }
+
+    delete [] ricoh;
+  }
+}
+
+
+void K3bDevice::Device::checkFeatures()
+{
+  unsigned char header[1024];
+  ::memset( header, 0, 1024 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_GET_CONFIGURATION;
+  cmd[1] = 2;
+  cmd[9] = 0;      // Necessary to set the proper command length
+
+
+  //
+  // CD writing features
+  //
+  cmd[2] = FEATURE_CD_MASTERING>>8;
+  cmd[3] = FEATURE_CD_MASTERING;
+  cmd[8] = 8+8;
+  if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 12 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "CD Mastering" << endl;
+#ifdef WORDS_BIGENDIAN
+      struct cd_mastering_feature {
+	unsigned char reserved1 : 1;
+	unsigned char BUF       : 1;  // Burnfree
+	unsigned char SAO       : 1;  // Session At Once writing
+	unsigned char raw_ms    : 1;  // Writing Multisession in Raw Writing Mode
+	unsigned char raw       : 1;  // Writing in WRITINGMODE_RAW mode
+	unsigned char testwrite : 1;  // Simulation write support
+	unsigned char cd_rw     : 1;  // CD-RW support
+	unsigned char rw_sub    : 1;  // Write R-W sub channels with user data
+	unsigned char max_cue_length[3];
+      };
+#else
+      struct cd_mastering_feature {
+	unsigned char rw_sub    : 1;  // Write R-W sub channels with user data
+	unsigned char cd_rw     : 1;  // CD-RW support
+	unsigned char testwrite : 1;  // Simulation write support
+	unsigned char raw       : 1;  // Writing in WRITINGMODE_RAW mode
+	unsigned char raw_ms    : 1;  // Writing Multisession in Raw Writing Mode
+	unsigned char SAO       : 1;  // Session At Once writing
+	unsigned char BUF       : 1;  // Burnfree
+	unsigned char reserved1 : 1;
+	unsigned char max_cue_length[3];
+      };
+#endif
+
+      struct cd_mastering_feature* p = (struct cd_mastering_feature*)&header[12];
+      if( p->BUF ) d->burnfree = true;
+      d->writeCapabilities |= MEDIA_CD_R;
+      if( p->cd_rw )
+	d->writeCapabilities |= MEDIA_CD_RW;
+//       if( p->WRITINGMODE_SAO ) m_writeModes |= WRITINGMODE_SAO;
+//       if( p->raw || p->raw_ms ) m_writeModes |= WRITINGMODE_RAW;  // WRITINGMODE_RAW16 always supported when raw is supported?
+    }
+  }
+
+  cmd[2] = FEATURE_CD_TRACK_AT_ONCE>>8;
+  cmd[3] = FEATURE_CD_TRACK_AT_ONCE;
+  cmd[8] = 8+8;
+  if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 12 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "CD Track At Once" << endl;
+#ifdef WORDS_BIGENDIAN
+      struct cd_track_at_once_feature {
+	unsigned char reserved1 : 1;
+	unsigned char BUF       : 1;  // Burnfree
+	unsigned char reserved2 : 1;
+	unsigned char rw_raw    : 1;  // Writing R-W subcode in Raw mode
+	unsigned char rw_pack   : 1;  // Writing R-W subcode in Packet mode
+	unsigned char testwrite : 1;  // Simulation write support
+	unsigned char cd_rw     : 1;  // CD-RW support
+	unsigned char rw_sub    : 1;  // Write R-W sub channels with user data
+	unsigned char reserved3;
+	unsigned char data_type[2];
+      };
+#else
+      struct cd_track_at_once_feature {
+	unsigned char rw_sub    : 1;  // Write R-W sub channels with user data
+	unsigned char cd_rw     : 1;  // CD-RW support
+	unsigned char testwrite : 1;  // Simulation write support
+	unsigned char rw_pack   : 1;  // Writing R-W subcode in Packet mode
+	unsigned char rw_raw    : 1;  // Writing R-W subcode in Raw mode
+	unsigned char reserved2 : 1;
+	unsigned char BUF       : 1;  // Burnfree
+	unsigned char reserved1 : 1;
+	unsigned char reserved3;
+	unsigned char data_type[2];
+      };
+#endif
+
+      struct cd_track_at_once_feature* p = (struct cd_track_at_once_feature*)&header[12];
+      m_writeModes |= WRITINGMODE_TAO;
+      if( p->BUF ) d->burnfree = true;
+      d->writeCapabilities |= MEDIA_CD_R;
+      if( p->cd_rw )
+	d->writeCapabilities |= MEDIA_CD_RW;
+
+      // is the following correct? What exactly does rw_sub tell us?
+//       if( m_writeModes & WRITINGMODE_RAW ) {
+// 	if( p->rw_raw ) m_writeModes |= WRITINGMODE_RAW_R96R;
+// 	if( p->rw_pack ) m_writeModes |= WRITINGMODE_RAW_R96P;
+//       }
+
+//       // check the data types for 1, 2, and 3 (raw16, raw96p, and raw96r)
+//        debugBitfield( p->data_type, 2 );
+//       if( m_writeModes & WRITINGMODE_RAW ) {
+// 	if( p->data_type[1] & 0x20 ) m_writeModes |= WRITINGMODE_RAW_R16;
+// 	if( p->data_type[1] & 0x40 ) m_writeModes |= WRITINGMODE_RAW_R96P;
+// 	if( p->data_type[1] & 0x80 ) m_writeModes |= WRITINGMODE_RAW_R96R;
+//       }
+    }
+  }
+
+  cmd[2] = FEATURE_CD_RW_MEDIA_WRITE_SUPPORT>>8;
+  cmd[3] = FEATURE_CD_RW_MEDIA_WRITE_SUPPORT;
+  cmd[8] = 8+8;
+  if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 12 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "CD-RW Media Write Support" << endl;
+      d->writeCapabilities |= (MEDIA_CD_R|MEDIA_CD_RW);
+    }
+  }
+
+
+  //
+  // DVD-ROM
+  //
+  // FIXME: since MMC5 the feature descr. is 8 bytes in length including a dvd dl read bit at byte 6
+  cmd[2] = FEATURE_DVD_READ>>8;
+  cmd[3] = FEATURE_DVD_READ;
+  cmd[8] = 8+8;
+  if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 12 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "DVD Read (MMC5)" << endl;
+      d->readCapabilities |= MEDIA_DVD_ROM;
+      if( header[8+6] & 0x1 )
+	d->readCapabilities |= MEDIA_WRITABLE_DVD_DL;
+    }
+  }
+  else {
+    // retry with pre-MMC5 length
+    cmd[8] = 8+4;
+    if( !cmd.transport( TR_DIR_READ, header, 12 ) ) {
+      unsigned int len = from4Byte( header );
+      if( len >= 8 ) {
+	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "DVD Read (pre-MMC5)" << endl;
+	d->readCapabilities |= MEDIA_DVD_ROM;
+      }
+    }
+  }
+
+  //
+  // DVD+R(W) writing features
+  //
+  cmd[2] = FEATURE_DVD_PLUS_R>>8;
+  cmd[3] = FEATURE_DVD_PLUS_R;
+  cmd[8] = 8+8;
+  if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 12 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "DVD+R" << endl;
+      d->readCapabilities |= MEDIA_DVD_PLUS_R;
+      if( header[12] & 0x1 )
+	d->writeCapabilities |= MEDIA_DVD_PLUS_R;
+    }
+  }
+
+  cmd[2] = FEATURE_DVD_PLUS_RW>>8;
+  cmd[3] = FEATURE_DVD_PLUS_RW;
+  cmd[8] = 8+8;
+  if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 12 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "DVD+RW" << endl;
+#ifdef WORDS_BIGENDIAN
+      struct dvd_plus_rw_feature {
+	unsigned char reserved1   : 7;
+	unsigned char write       : 1;
+	unsigned char reserved2   : 6;
+	unsigned char quick_start : 1;
+	unsigned char close_only  : 1;
+	// and some stuff we do not use here...
+      };
+#else
+      struct dvd_plus_rw_feature {
+	unsigned char write       : 1;
+	unsigned char reserved1   : 7;
+	unsigned char close_only  : 1;
+	unsigned char quick_start : 1;
+	unsigned char reserved2   : 6;
+	// and some stuff we do not use here...
+      };
+#endif
+
+      struct dvd_plus_rw_feature* p = (struct dvd_plus_rw_feature*)&header[12];
+      d->readCapabilities |= MEDIA_DVD_PLUS_RW;
+      if( p->write )
+	d->writeCapabilities |= MEDIA_DVD_PLUS_RW;
+    }
+  }
+
+
+  // some older DVD-ROM drives claim to support DVD+R DL
+  if( d->writeCapabilities & MEDIA_DVD_PLUS_R ) {
+    cmd[2] = FEATURE_DVD_PLUS_RW_DUAL_LAYER>>8;
+    cmd[3] = FEATURE_DVD_PLUS_RW_DUAL_LAYER;
+    cmd[8] = 8+8;
+    if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+      unsigned int len = from4Byte( header );
+      if( len >= 12 ) {
+	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "DVD+RW Double Layer" << endl;
+	d->readCapabilities |= MEDIA_DVD_PLUS_RW_DL;
+	if( header[12] & 0x1 )
+	  d->writeCapabilities |= MEDIA_DVD_PLUS_RW_DL;
+      }
+    }
+
+    cmd[2] = FEATURE_DVD_PLUS_R_DUAL_LAYER>>8;
+    cmd[3] = FEATURE_DVD_PLUS_R_DUAL_LAYER;
+    cmd[8] = 8+8;
+    if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+      unsigned int len = from4Byte( header );
+      if( len >= 12 ) {
+	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "DVD+R Double Layer" << endl;
+	d->readCapabilities |= MEDIA_DVD_PLUS_R_DL;
+	if( header[12] & 0x1 )
+	  d->writeCapabilities |= MEDIA_DVD_PLUS_R_DL;
+      }
+    }
+  }
+
+
+  //
+  // Blue Ray
+  //
+  // We do not care for the different BD classes and versions here
+  //
+  cmd[2] = FEATURE_BD_READ>>8;
+  cmd[3] = FEATURE_BD_READ;
+  cmd[8] = 8+32;
+  if( !cmd.transport( TR_DIR_READ, header, 40 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 36 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "BD Read" << endl;
+      if( header[8+8] || header[8+9] || header[8+10] || header[8+11] || header[8+12] || header[8+13] || header[8+14] || header[8+15] )
+	d->readCapabilities |= MEDIA_BD_RE;
+      if( header[8+16] || header[8+17] || header[8+18] || header[8+19] || header[8+20] || header[8+21] || header[8+22] || header[8+23] )
+	d->readCapabilities |= MEDIA_BD_R;
+      if( header[8+24] || header[8+25] || header[8+26] || header[8+27] || header[8+28] || header[8+29] || header[8+30] || header[8+31] )
+	d->readCapabilities |= MEDIA_BD_ROM;
+    }
+  }
+
+  cmd[2] = FEATURE_BD_WRITE>>8;
+  cmd[3] = FEATURE_BD_WRITE;
+  cmd[8] = 8+24;
+  if( !cmd.transport( TR_DIR_READ, header, 32 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 28 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "BD Write" << endl;
+      if( header[8+8] || header[8+9] || header[8+10] || header[8+11] || header[8+12] || header[8+13] || header[8+14] || header[8+15] )
+	d->writeCapabilities |= MEDIA_BD_RE;
+      if( header[8+16] || header[8+17] || header[8+18] || header[8+19] || header[8+20] || header[8+21] || header[8+22] || header[8+23] ) {
+	d->writeCapabilities |= MEDIA_BD_R;
+	m_writeModes |= WRITINGMODE_SRM;
+
+	cmd[2] = FEATURE_BD_PSEUDO_OVERWRITE>>8;
+	cmd[3] = FEATURE_BD_PSEUDO_OVERWRITE;
+	cmd[8] = 8+8;
+	if( !cmd.transport( TR_DIR_READ, header, 8+8 ) ) {
+	  unsigned int len = from4Byte( header );
+	  if( len >= 4+8 ) {
+	    m_writeModes |= WRITINGMODE_SRM_POW;
+	  }
+	}
+
+	cmd[2] = FEATURE_RANDOM_WRITABLE>>8;
+	cmd[3] = FEATURE_RANDOM_WRITABLE;
+	cmd[8] = 8+16;
+	if( !cmd.transport( TR_DIR_READ, header, 8+16 ) ) {
+	  unsigned int len = from4Byte( header );
+	  if( len >= 4+16 ) {
+	   m_writeModes |= WRITINGMODE_RRM;
+	  }
+	}
+      }
+    }
+  }
+
+
+
+  //
+  // DVD-R(W)
+  //
+  cmd[2] = FEATURE_DVD_R_RW_WRITE>>8;
+  cmd[3] = FEATURE_DVD_R_RW_WRITE;
+  cmd[8] = 16;
+  if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 12 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "DVD-R/-RW Write" << endl;
+#ifdef WORDS_BIGENDIAN
+      struct dvd_r_rw_write_feature {
+	unsigned char reserved1 : 1;
+	unsigned char BUF       : 1;  // Burnfree
+	unsigned char reserved2 : 2;
+	unsigned char RDL       : 1;
+	unsigned char testwrite : 1;  // Simulation write support
+	unsigned char dvd_rw    : 1;  // DVD-RW Writing
+	unsigned char reserved3 : 1;
+	unsigned char reserved4[3];
+      };
+#else
+      struct dvd_r_rw_write_feature {
+	unsigned char reserved3 : 1;
+	unsigned char dvd_rw    : 1;  // DVD-RW Writing
+	unsigned char testwrite : 1;  // Simulation write support
+	unsigned char RDL       : 1;
+	unsigned char reserved2 : 2;
+	unsigned char BUF       : 1;  // Burnfree
+	unsigned char reserved1 : 1;
+	unsigned char reserved4[3];
+      };
+#endif
+
+      struct dvd_r_rw_write_feature* p = (struct dvd_r_rw_write_feature*)&header[12];
+      if( p->BUF ) d->burnfree = true;
+      d->writeCapabilities |= (MEDIA_DVD_R|MEDIA_DVD_R_SEQ);
+      if( p->dvd_rw )
+	d->writeCapabilities |= (MEDIA_DVD_RW|MEDIA_DVD_RW_SEQ);
+      if( p->RDL )
+	d->writeCapabilities |= (MEDIA_DVD_R_DL|MEDIA_DVD_R_DL_SEQ);
+
+      m_dvdMinusTestwrite = p->testwrite;
+    }
+  }
+
+
+  //
+  // DVD-RW restricted overwrite check
+  //
+  cmd[2] = FEATURE_RIGID_RESTRICTED_OVERWRITE>>8;
+  cmd[3] = FEATURE_RIGID_RESTRICTED_OVERWRITE;
+  cmd[8] = 16;
+  if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 12 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "Rigid Restricted Overwrite" << endl;
+      m_writeModes |= WRITINGMODE_RES_OVWR;
+      d->writeCapabilities |= (MEDIA_DVD_RW|MEDIA_DVD_RW_OVWR);
+    }
+  }
+
+
+  //
+  // DVD-R Dual Layer Layer
+  //
+  cmd[2] = FEATURE_LAYER_JUMP_RECORDING>>8;
+  cmd[3] = FEATURE_LAYER_JUMP_RECORDING;
+  cmd[8] = 12;
+  if( !cmd.transport( TR_DIR_READ, header, 12 ) ) {
+    // Now the jump feature is longer than 4 bytes but we don't need the link sizes.
+    unsigned int len = from4Byte( header );
+    if( len >= 8 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "Layer Jump Recording" << endl;
+      d->writeCapabilities |= (MEDIA_DVD_R_DL|MEDIA_DVD_R_DL_JUMP);
+      m_writeModes |= WRITINGMODE_LAYER_JUMP;
+    }
+  }
+
+
+  //
+  // HD-DVD-ROM
+  //
+  cmd[2] = FEATURE_HD_DVD_READ>>8;
+  cmd[3] = FEATURE_HD_DVD_READ;
+  cmd[8] = 16;
+  if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 12 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "HD-DVD Read" << endl;
+      d->readCapabilities |= MEDIA_HD_DVD_ROM;
+      if( header[8+4] & 0x1 )
+	d->readCapabilities |= MEDIA_HD_DVD_R;
+      if( header[8+6] & 0x1 )
+	d->readCapabilities |= MEDIA_HD_DVD_RAM;
+    }
+  }
+
+
+  //
+  // HD-DVD-R(AM)
+  //
+  cmd[2] = FEATURE_HD_DVD_WRITE>>8;
+  cmd[3] = FEATURE_HD_DVD_WRITE;
+  cmd[8] = 16;
+  if( !cmd.transport( TR_DIR_READ, header, 16 ) ) {
+    unsigned int len = from4Byte( header );
+    if( len >= 12 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " feature: " << "HD-DVD Write" << endl;
+      if( header[8+4] & 0x1 )
+	d->writeCapabilities |= MEDIA_HD_DVD_R;
+      if( header[8+6] & 0x1 )
+	d->writeCapabilities |= MEDIA_HD_DVD_RAM;
+    }
+  }
+
+
+
+  //
+  // Get the profiles
+  //
+  // the max len of the returned data is 8 (header) + 4 (feature) + 255 (additional length)
+  //
+  cmd[2] = FEATURE_PROFILE_LIST>>8;
+  cmd[3] = FEATURE_PROFILE_LIST;
+  cmd[8] = 12; // get the number of returned profiles first
+  if( !cmd.transport( TR_DIR_READ, header, 12 ) ) {
+    unsigned int len = from4Byte( header ) + 4;
+    if( len >= 12 ) {
+      cmd[7] = len>>8;
+      cmd[8] = len;
+      if( !cmd.transport( TR_DIR_READ, header, len ) ) {
+	int featureLen( header[11] );
+	for( int j = 0; j < featureLen; j+=4 ) {
+	  short profile = from2Byte( &header[12+j] );
+
+	  switch (profile) {
+	  case 0x08:
+	    d->supportedProfiles |= MEDIA_CD_ROM;
+	    break;
+	  case 0x09:
+	    d->supportedProfiles |= MEDIA_CD_R;
+	    break;
+	  case 0x0A:
+	    d->supportedProfiles |= MEDIA_CD_RW;
+	    break;
+	  case 0x10:
+	    d->supportedProfiles |= MEDIA_DVD_ROM;
+	    // 	    d->readCapabilities |= MEDIA_DVD_ROM;
+	    break;
+	  case 0x11:
+	    d->supportedProfiles |= MEDIA_DVD_R_SEQ;
+	    // 	    d->writeCapabilities |= (MEDIA_DVD_R|MEDIA_DVD_R_SEQ);
+	    break;
+	  case 0x12:
+	    d->supportedProfiles |= MEDIA_DVD_RAM;
+//  	    d->readCapabilities |= (MEDIA_DVD_RAM|MEDIA_DVD_ROM);
+//  	    d->writeCapabilities |= MEDIA_DVD_RAM;
+	    break;
+	  case 0x13:
+	    d->supportedProfiles |= MEDIA_DVD_RW_OVWR;
+	    // 	    d->writeCapabilities |= (MEDIA_DVD_RW|MEDIA_DVD_RW_OVWR);
+	    break;
+	  case 0x14:
+	    d->supportedProfiles |= MEDIA_DVD_RW_SEQ;
+	    // 	    d->writeCapabilities |= (MEDIA_DVD_RW|MEDIA_DVD_R|MEDIA_DVD_RW_SEQ|MEDIA_DVD_R_SEQ);
+	    break;
+	  case 0x15:
+	    d->supportedProfiles |= MEDIA_DVD_R_DL_SEQ;
+	    // 	    d->writeCapabilities |= (MEDIA_DVD_R|MEDIA_DVD_R_DL|MEDIA_DVD_R_SEQ|MEDIA_DVD_R_DL_SEQ);
+	    break;
+	  case 0x16:
+	    d->supportedProfiles |= MEDIA_DVD_R_DL_JUMP;
+	    // 	    d->writeCapabilities |= (MEDIA_DVD_R|MEDIA_DVD_R_DL||MEDIA_DVD_R_DL_JUMP);
+	    break;
+	  case 0x1A:
+	    d->supportedProfiles |= MEDIA_DVD_PLUS_RW;
+	    // 	    d->writeCapabilities |= MEDIA_DVD_PLUS_RW;
+	    break;
+	  case 0x1B:
+	    d->supportedProfiles |= MEDIA_DVD_PLUS_R;
+	    // 	    d->writeCapabilities |= MEDIA_DVD_PLUS_R;
+	    break;
+	  case 0x2A:
+	    d->supportedProfiles |= MEDIA_DVD_PLUS_RW_DL;
+	    // 	    d->writeCapabilities |= MEDIA_DVD_PLUS_RW_DL;
+	    break;
+	  case 0x2B:
+	    d->supportedProfiles |= MEDIA_DVD_PLUS_R_DL;
+	    //	    d->writeCapabilities |= MEDIA_DVD_PLUS_R_DL;
+	    break;
+	  case 0x40:
+	    d->supportedProfiles |= MEDIA_BD_ROM;
+	    break;
+	  case 0x41:
+	    d->supportedProfiles |= MEDIA_BD_R_SRM;
+	    break;
+	  case 0x42:
+	    d->supportedProfiles |= MEDIA_BD_R_RRM;
+	    break;
+	  case 0x43:
+	    d->supportedProfiles |= MEDIA_BD_RE;
+	    break;
+	  case 0x50:
+	    d->supportedProfiles |= MEDIA_HD_DVD_ROM;
+	    break;
+	  case 0x51:
+	    d->supportedProfiles |= MEDIA_HD_DVD_R;
+	    break;
+	  case 0x52:
+	    d->supportedProfiles |= MEDIA_HD_DVD_RAM;
+	    break;
+	  default:
+	    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " unknown profile: "
+		      << profile << endl;
+	  }
+	}
+
+	// some older DVD-ROM drives claim to support DVD+R DL
+	if( !(d->supportedProfiles & MEDIA_DVD_PLUS_R) ) {
+	  // remove DVD+R DL capability
+	  //	  d->writeCapabilities &= ~MEDIA_DVD_PLUS_R_DL;
+	  d->supportedProfiles &= ~MEDIA_DVD_PLUS_R_DL;
+	}
+      }
+    }
+  }
+}
+
+
+void K3bDevice::Device::checkFor2AFeatures()
+{
+  unsigned char* mm_cap_buffer = 0;
+  unsigned int mm_cap_len = 0;
+
+  if( modeSense( &mm_cap_buffer, mm_cap_len, 0x2A ) ) {
+    mm_cap_page_2A* mm_p = (mm_cap_page_2A*)(mm_cap_buffer+8);
+    if( mm_p->BUF )
+      d->burnfree = true;
+
+    if( mm_p->cd_r_write )
+      d->writeCapabilities |= MEDIA_CD_R;
+    else
+      d->writeCapabilities &= ~MEDIA_CD_R;
+
+    if( mm_p->cd_rw_write )
+      d->writeCapabilities |= MEDIA_CD_RW;
+    else
+      d->writeCapabilities &= ~MEDIA_CD_RW;
+
+    if( mm_p->dvd_r_write )
+      d->writeCapabilities |= MEDIA_DVD_R;
+    else
+      d->writeCapabilities &= ~MEDIA_DVD_R;
+
+    if( mm_p->dvd_rom_read || mm_p->dvd_r_read )
+      d->readCapabilities |= MEDIA_DVD_ROM;
+
+    m_maxReadSpeed = from2Byte(mm_p->max_read_speed);
+    m_bufferSize = from2Byte( mm_p->buffer_size );
+
+    delete [] mm_cap_buffer;
+  }
+  else {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": read mode page 2A failed!" << endl;
+  }
+}
+
+
+void K3bDevice::Device::checkWritingModes()
+{
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  if( !open() )
+    return;
+
+  // header size is 8
+  unsigned char* buffer = 0;
+  unsigned int dataLen = 0;
+
+  if( !modeSense( &buffer, dataLen, 0x05 ) ) {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": modeSense 0x05 failed!" << endl
+	      << "(K3bDevice::Device) " << blockDeviceName() << ": Cannot check write modes." << endl;
+  }
+  else if( dataLen < 18 ) { // 8 bytes header + 10 bytes used modepage
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": Missing modepage 0x05 data." << endl
+	      << "(K3bDevice::Device) " << blockDeviceName() << ": Cannot check write modes." << endl;
+  }
+  else {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": dataLen: " << dataLen << endl;
+
+    wr_param_page_05* mp = (struct wr_param_page_05*)(buffer+8);
+
+    // reset some stuff to be on the safe side
+    mp->PS = 0;
+    mp->BUFE = 0;
+    mp->multi_session = 0;
+    mp->test_write = 0;
+    mp->LS_V = 0;
+    mp->copy = 0;
+    mp->fp = 0;
+    mp->host_appl_code= 0;
+    mp->session_format = 0;
+    mp->audio_pause_len[0] = 0;
+    mp->audio_pause_len[1] = 150;
+
+    // WRITINGMODE_TAO
+    mp->write_type = 0x01;  // Track-at-once
+    mp->track_mode = 4;     // MMC-4 says: 5, cdrecord uses 4 ?
+    mp->dbtype = 8;         // Mode 1
+
+    //    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": modeselect WRITINGMODE_TAO data: " << endl;
+    //    debugBitfield( buffer, dataLen );
+
+
+    //
+    // if a writer does not support WRITINGMODE_TAO it surely does not support WRITINGMODE_SAO or WRITINGMODE_RAW writing since WRITINGMODE_TAO is the minimal
+    // requirement
+    //
+
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": checking for TAO" << endl;
+    if( modeSelect( buffer, dataLen, 1, 0 ) ) {
+      m_writeModes |= WRITINGMODE_TAO;
+      d->writeCapabilities |= MEDIA_CD_R;
+
+      // WRITINGMODE_SAO
+      mp->write_type = 0x02; // Session-at-once
+
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": checking for SAO" << endl;
+      if( modeSelect( buffer, dataLen, 1, 0 ) )
+	m_writeModes |= WRITINGMODE_SAO;
+
+//       mp->dbtype = 1;        // Raw data with P and Q Sub-channel (2368 bytes)
+//       if( modeSelect( buffer, dataLen, 1, 0 ) ) {
+// 	m_writeModes |= WRITINGMODE_RAW_R16;
+//       }
+
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": checking for SAO_R96P" << endl;
+      mp->dbtype = 2;        // Raw data with P-W Sub-channel (2448 bytes)
+      if( modeSelect( buffer, dataLen, 1, 0 ) ) {
+	m_writeModes |= WRITINGMODE_SAO_R96P;
+      }
+
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": checking for SAO_R96R" << endl;
+      mp->dbtype = 3;        // Raw data with P-W raw Sub-channel (2448 bytes)
+      if( modeSelect( buffer, dataLen, 1, 0 ) ) {
+	m_writeModes |= WRITINGMODE_SAO_R96R;
+      }
+
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": checking for RAW_R16" << endl;
+      // WRITINGMODE_RAW
+      mp->write_type = 0x03; // WRITINGMODE_RAW
+      mp->dbtype = 1;        // Raw data with P and Q Sub-channel (2368 bytes)
+      if( modeSelect( buffer, dataLen, 1, 0 ) ) {
+	m_writeModes |= WRITINGMODE_RAW;
+	m_writeModes |= WRITINGMODE_RAW_R16;
+      }
+
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": checking for RAW_R96P" << endl;
+      mp->dbtype = 2;        // Raw data with P-W Sub-channel (2448 bytes)
+      if( modeSelect( buffer, dataLen, 1, 0 ) ) {
+	m_writeModes |= WRITINGMODE_RAW;
+	m_writeModes |= WRITINGMODE_RAW_R96P;
+      }
+
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": checking for RAW_R96R" << endl;
+      mp->dbtype = 3;        // Raw data with P-W raw Sub-channel (2448 bytes)
+      if( modeSelect( buffer, dataLen, 1, 0 ) ) {
+	m_writeModes |= WRITINGMODE_RAW;
+	m_writeModes |= WRITINGMODE_RAW_R96R;
+      }
+    }
+    else {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": modeSelect with WRITINGMODE_TAO failed. No writer" << endl;
+    }
+
+
+    delete [] buffer;
+  }
+
+  if( needToClose )
+    close();
+}
+
+
+int K3bDevice::Device::determineMaximalWriteSpeed() const
+{
+  int ret = 0;
+  unsigned char* data = 0;
+  unsigned int dataLen = 0;
+
+  if( mediaType() & MEDIA_CD_ALL ) {
+    if( modeSense( &data, dataLen, 0x2A ) ) {
+      mm_cap_page_2A* mm = (mm_cap_page_2A*)&data[8];
+
+      // MMC1 used byte 18 and 19 for the max write speed
+      if( dataLen > 19 )
+	ret = from2Byte( mm->max_write_speed );
+
+      delete [] data;
+
+      if( ret > 0 )
+	return ret;
+    }
+  }
+
+  QValueList<int> list = determineSupportedWriteSpeeds();
+  if( !list.isEmpty() ) {
+    for( QValueList<int>::const_iterator it = list.constBegin(); it != list.constEnd(); ++it )
+      ret = QMAX( ret, *it );
+  }
+
+  if( ret > 0 )
+    return ret;
+  else
+    return m_maxWriteSpeed;
+}
+
+
+QValueList<int> K3bDevice::Device::determineSupportedWriteSpeeds() const
+{
+  QValueList<int> ret;
+
+  if( burner() ) {
+    //
+    // Tests with all my drives resulted in 2A for CD and GET PERFORMANCE for DVD media
+    // as the valid method of speed detection.
+    //
+    if( mediaType() & MEDIA_CD_ALL ) {
+      if( !getSupportedWriteSpeedsVia2A( ret, false ) )
+	getSupportedWriteSpeedsViaGP( ret, false );
+
+      // restrict to max speed, although deprecated in MMC3 is still used everywhere and
+      // cdrecord also uses it as the max writing speed.
+      int max = 0;
+      unsigned char* data = 0;
+      unsigned int dataLen = 0;
+      if( modeSense( &data, dataLen, 0x2A ) ) {
+	mm_cap_page_2A* mm = (mm_cap_page_2A*)&data[8];
+
+	// MMC1 used byte 18 and 19 for the max write speed
+	if( dataLen > 19 )
+	  max = from2Byte( mm->max_write_speed );
+
+	delete [] data;
+
+	if( max > 0 ) {
+	  while( !ret.isEmpty() && ret.last() > max ) {
+	    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		       << " writing speed " << ret.last() << " higher than max " << max << endl;
+	    ret.pop_back();
+	  }
+	}
+      }
+    }
+    else {
+      if( !getSupportedWriteSpeedsViaGP( ret, true ) )
+	getSupportedWriteSpeedsVia2A( ret, true );
+    }
+  }
+
+  return ret;
+}
+
+
+bool K3bDevice::Device::getSupportedWriteSpeedsVia2A( QValueList<int>& list, bool dvd ) const
+{
+  unsigned char* data = 0;
+  unsigned int dataLen = 0;
+  if( modeSense( &data, dataLen, 0x2A ) ) {
+    mm_cap_page_2A* mm = (mm_cap_page_2A*)&data[8];
+
+    if( dataLen > 32 ) {
+      // we have descriptors
+      unsigned int numDesc = from2Byte( mm->num_wr_speed_des );
+
+      // Some CDs writer returns the number of bytes that contain
+      // the descriptors rather than the number of descriptors
+      // Ensure number of descriptors claimed actually fits in the data
+      // returned by the mode sense command.
+      if( numDesc > ((dataLen - 32 - 8) / 4) )
+	numDesc = (dataLen - 32 - 8) / 4;
+
+      cd_wr_speed_performance* wr = (cd_wr_speed_performance*)mm->wr_speed_des;
+
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		<< ":  Number of supported write speeds via 2A: "
+		<< numDesc << endl;
+
+
+      for( unsigned int i = 0; i < numDesc; ++i ) {
+	int s = (int)from2Byte( wr[i].wr_speed_supp );
+	//
+	// some DVD writers report CD writing speeds here
+	// If that is the case we cannot rely on the reported speeds
+	// and need to use the values gained from GET PERFORMANCE.
+	//
+	if( dvd && s < 1352 ) {
+	  k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		    << " Invalid DVD speed: " << s << " KB/s" << endl;
+	  list.clear();
+	  break;
+	}
+	else {
+	  k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		    << " : " << s << " KB/s" << endl;
+
+	  if( dvd )
+	    s = fixupDvdWritingSpeed( s );
+
+	  // sort the list
+	  QValueList<int>::iterator it = list.begin();
+	  while( it != list.end() && *it < s )
+	    ++it;
+	  list.insert( it, s );
+	}
+      }
+    }
+
+    delete [] data;
+  }
+
+  return !list.isEmpty();
+}
+
+
+bool K3bDevice::Device::getSupportedWriteSpeedsViaGP( QValueList<int>& list, bool dvd ) const
+{
+  unsigned char* data = 0;
+  unsigned int dataLen = 0;
+  if( getPerformance( &data, dataLen, 0x3, 0x0 ) ) {
+    int numDesc = (dataLen - 8)/16;
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+	      << ":  Number of supported write speeds via GET PERFORMANCE: "
+	      << numDesc << endl;
+
+    for( int i = 0; i < numDesc; ++i ) {
+      int s = from4Byte( &data[20+i*16] );
+
+      // Looks as if the code below does not make sense with most drives
+//       if( !( data[4+i*16] & 0x2 ) ) {
+// 	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+// 		   << " No write speed: " << s << " KB/s" << endl;
+// 	continue;
+//       }
+
+      if( dvd && s < 1352 ) {
+	//
+	// Does this ever happen?
+	//
+	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		  << " Invalid DVD speed: " << s << " KB/s" << endl;
+      }
+      else {
+	k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+		  << " : " << s << " KB/s" << endl;
+
+	if( dvd )
+	  s = fixupDvdWritingSpeed( s );
+
+	QValueList<int>::iterator it = list.begin();
+	while( it != list.end() && *it < s )
+	  ++it;
+	// the speed might already have been found in the 2a modepage
+	if( it == list.end() || *it != s )
+	  list.insert( it, s );
+      }
+    }
+
+    delete [] data;
+  }
+
+  return !list.isEmpty();
+}
+
+
+int K3bDevice::Device::getIndex( unsigned long lba ) const
+{
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  if( !open() )
+    return -1;
+
+  int ret = -1;
+
+  //
+  // first try readCd
+  //
+  unsigned char readData[16];
+  ::memset( readData, 0, 16 );
+
+  //
+  // The index is found in the Mode-1 Q which occupies at least 9 out of 10 successive CD frames
+  // It can be indentified by ADR == 1
+  //
+  // So if the current sector does not provide Mode-1 Q subchannel we try the previous.
+  //
+
+  if( readCd( readData,
+	      16,
+	      1, // CD-DA
+	      0, // no DAP
+	      lba,
+	      1,
+	      false,
+	      false,
+	      false,
+	      false,
+	      false,
+	      0,
+	      2 // Q-Subchannel
+	      ) ) {
+    // byte 0: 4 bits CONTROL (MSB) + 4 bits ADR (LSB)
+    if( (readData[0]&0x0f) == 0x1 )
+      ret = readData[2];
+
+    // search previous sector for Mode1 Q Subchannel
+    else if( readCd( readData,
+	      16,
+	      1, // CD-DA
+	      0, // no DAP
+	      lba-1,
+	      1,
+	      false,
+	      false,
+	      false,
+	      false,
+	      false,
+	      0,
+	      2 // Q-Subchannel
+	      ) ) {
+      if( (readData[0]&0x0f) == 0x1 )
+	ret = readData[2];
+      else
+	ret = -2;
+    }
+  }
+
+  else {
+    k3bDebug() << "(K3bDevice::Device::getIndex) readCd failed. Trying seek." << endl;
+
+    unsigned char* data = 0;
+    unsigned int dataLen = 0;
+    if( seek( lba ) && readSubChannel( &data, dataLen, 1, 0 ) ) {
+      // byte 5: 4 bits ADR (MSB) + 4 bits CONTROL (LSB)
+      if( dataLen > 7 && (data[5]>>4 & 0x0F) == 0x1 ) {
+	ret = data[7];
+      }
+      else if( seek( lba-1 ) && readSubChannel( &data, dataLen, 1, 0 ) ) {
+	if( dataLen > 7 && (data[5]>>4 & 0x0F) == 0x1 )
+	  ret = data[7];
+	else
+	  ret = -2;
+      }
+
+      delete [] data;
+    }
+    else
+      k3bDebug() << "(K3bDevice::Device::getIndex) seek or readSubChannel failed." << endl;
+  }
+
+  if( needToClose )
+    close();
+
+  return ret;
+}
+
+
+bool K3bDevice::Device::searchIndex0( unsigned long startSec,
+				      unsigned long endSec,
+				      long& pregapStart ) const
+{
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  if( !open() )
+    return false;
+
+  bool ret = false;
+
+  int lastIndex = getIndex( endSec );
+  if( lastIndex == 0 ) {
+    // there is a pregap
+    // let's find the position where the index turns to 0
+    // we jump in 1 sec steps backwards until we find an index > 0
+    unsigned long sector = endSec;
+    while( lastIndex == 0 && sector > startSec ) {
+      sector -= 75;
+      if( sector < startSec )
+	sector = startSec;
+      lastIndex = getIndex(sector);
+    }
+
+    if( lastIndex == 0 ) {
+      k3bDebug() << "(K3bDevice::Device) warning: no index != 0 found." << endl;
+    }
+    else {
+      // search forward to the first index = 0
+      while( getIndex( sector ) != 0 && sector < endSec )
+	sector++;
+
+      pregapStart = sector;
+      ret = true;
+    }
+  }
+  else if( lastIndex > 0 ) {
+    // no pregap
+    pregapStart = -1;
+    ret = true;
+  }
+
+  if( needToClose )
+    close();
+
+  return ret;
+}
+
+
+bool K3bDevice::Device::indexScan( K3bDevice::Toc& toc ) const
+{
+  // if the device is already opened we do not close it
+  // to allow fast multiple method calls in a row
+  bool needToClose = !isOpen();
+
+  if( !open() )
+    return false;
+
+  bool ret = true;
+
+  for( Toc::iterator it = toc.begin(); it != toc.end(); ++it ) {
+    Track& track = *it;
+    if( track.type() == Track::AUDIO ) {
+      track.m_indices.clear();
+      long index0 = -1;
+      if( searchIndex0( track.firstSector().lba(), track.lastSector().lba(), index0 ) ) {
+	k3bDebug() << "(K3bDevice::Device) found index 0: " << index0 << endl;
+      }
+      if( index0 > 0 )
+	track.m_index0 = K3b::Msf( index0 - track.firstSector().lba() );
+      else
+	track.m_index0 = 0;
+
+      if( index0 > 0 )
+	searchIndexTransitions( track.firstSector().lba(), index0-1, track );
+      else
+	searchIndexTransitions( track.firstSector().lba(), track.lastSector().lba(), track );
+    }
+  }
+
+  if( needToClose )
+    close();
+
+  return ret;
+}
+
+
+void K3bDevice::Device::searchIndexTransitions( long start, long end, K3bDevice::Track& track ) const
+{
+    k3bDebug() << "(K3bDevice::Device) searching for index transitions between "
+               << start << " and " << end << endl;
+    int startIndex = getIndex( start );
+    int endIndex = getIndex( end );
+
+    if( startIndex < 0 || endIndex < 0 ) {
+        k3bDebug() << "(K3bDevice::Device) could not retrieve index values." << endl;
+    }
+    else {
+        k3bDebug() << "(K3bDevice::Device) indices: " << start << " - " << startIndex
+                   << " and " << end << " - " << endIndex << endl;
+
+        if( startIndex != endIndex ) {
+            if( start+1 == end ) {
+                k3bDebug() << "(K3bDevice::Device) found index transition: " << endIndex << " " << end << endl;
+                track.m_indices.resize( endIndex );
+                // we save the index relative to the first sector
+                track.m_indices[endIndex-1] = K3b::Msf( end ) - track.firstSector();
+            }
+            else {
+                searchIndexTransitions( start, start+(end-start)/2, track );
+                searchIndexTransitions( start+(end-start)/2, end, track );
+            }
+        }
+    }
+}
+
+
+int K3bDevice::Device::copyrightProtectionSystemType() const
+{
+  unsigned char* dvdheader = 0;
+  unsigned int dataLen = 0;
+  if( readDvdStructure( &dvdheader, dataLen, 0x1 ) ) {
+    int ret = -1;
+    if( dataLen >= 6 )
+      ret = dvdheader[4];
+    delete [] dvdheader;
+    return ret;
+  }
+  else
+    return -1;
+}
+
+
+bool K3bDevice::Device::getNextWritableAdress( unsigned int& lastSessionStart, unsigned int& nextWritableAdress ) const
+{
+  bool success = false;
+
+  // FIXME: add CD media handling
+  int m = mediaType();
+  if( m & MEDIA_DVD_ALL ) {
+    // DVD+RW always returns complete
+    if( m & (K3bDevice::MEDIA_DVD_PLUS_RW|K3bDevice::MEDIA_DVD_RW_OVWR) )
+      return false;
+
+    unsigned char* data = 0;
+    unsigned int dataLen = 0;
+
+    if( readDiscInformation( &data, dataLen ) ) {
+      disc_info_t* inf = (disc_info_t*)data;
+
+      //
+      // The state of the last session has to be "empty" (0x0) or "incomplete" (0x1)
+      // The procedure here is taken from the dvd+rw-tools
+      //
+      if( !(inf->border & 0x2) ) {
+	// the incomplete track number is the first track in the last session (the empty session)
+	int nextTrack = inf->first_track_l|inf->first_track_m<<8;
+
+	unsigned char* trackData = 0;
+	unsigned int trackDataLen = 0;
+
+	// Read start address of the incomplete track
+	if( readTrackInformation( &trackData, trackDataLen, 0x1, nextTrack ) ) {
+	  nextWritableAdress = from4Byte( &trackData[8] );
+	  delete [] trackData;
+
+	  // Read start address of the first track in the last session
+	  if( readTocPmaAtip( &trackData, trackDataLen, 0x1, false, 0x0  ) ) {
+	    lastSessionStart = from4Byte( &trackData[8] );
+	    delete [] trackData;
+	    success = true;
+	  }
+	}
+      }
+    }
+
+    delete [] data;
+  }
+
+  return success;
+}
+
+
+int K3bDevice::Device::nextWritableAddress() const
+{
+    unsigned char* data = 0;
+    unsigned int dataLen = 0;
+    int nwa = -1;
+
+    if( readDiscInformation( &data, dataLen ) ) {
+        disc_info_t* inf = (disc_info_t*)data;
+
+        //
+        // The state of the last session has to be "empty" (0x0) or "incomplete" (0x1)
+        // The procedure here is taken from the dvd+rw-tools and wodim
+        //
+        if( !(inf->border & 0x2) ) {
+            // the incomplete track number is the first track in the last session (the empty session)
+            int nextTrack = inf->first_track_l|inf->first_track_m<<8;
+
+            unsigned char* trackData = 0;
+            unsigned int trackDataLen = 0;
+
+            // Read start address of the incomplete track
+            if( readTrackInformation( &trackData, trackDataLen, 0x1, nextTrack ) ) {
+                nwa = from4Byte( &trackData[8] );
+                delete [] trackData;
+            }
+
+            // Read start address of the invisible track
+            else if ( readTrackInformation( &trackData, trackDataLen, 0x1, 0xff ) ) {
+                nwa = from4Byte( &trackData[8] );
+                delete [] trackData;
+            }
+        }
+
+        delete [] data;
+    }
+
+    return nwa;
+}
+
+
+QCString K3bDevice::Device::mediaId( int mediaType ) const
+{
+  QCString id;
+
+  if( mediaType & MEDIA_CD_ALL ) {
+    // FIXME:
+  }
+
+  else if( mediaType & MEDIA_DVD_MINUS_ALL ) {
+    unsigned char* data = 0;
+    unsigned int dataLen = 0;
+    if( readDvdStructure( &data, dataLen, 0x0E ) ) {
+      if( data[4+16] == 3 && data[4+24] == 4 ) {
+	id.sprintf( "%6.6s%-6.6s", data+4+17, data+4+25 );
+      }
+      delete [] data;
+    }
+  }
+
+  else if( mediaType & MEDIA_DVD_PLUS_ALL ) {
+    unsigned char* data = 0;
+    unsigned int dataLen = 0;
+    if( readDvdStructure( &data, dataLen, 0x11 ) ||
+	readDvdStructure( &data, dataLen, 0x0 ) ) {
+      id.sprintf( "%8.8s/%3.3s", data+23, data+31 );
+      delete [] data;
+    }
+  }
+
+  else if( mediaType & MEDIA_BD_ALL ) {
+    unsigned char* data = 0;
+    unsigned int dataLen = 0;
+    if( readDiscStructure( &data, dataLen, 1, 0 ) ) {
+      if( data[4+0] == 'D' && data[4+1] == 'I' )
+	id.sprintf ("%6.6s/%-3.3s", data+4+100, data+4+106 );
+      delete [] data;
+    }
+  }
+
+  return id;
+}
+
+
+// int K3bDevice::Device::ioctl( int request, ... ) const
+// {
+//     int r = -1;
+// #if defined(Q_OS_LINUX) || defined(Q_OS_NETBSD)
+//     d->mutex.lock();
+
+//     va_list ap;
+//     va_start( ap, request );
+//     r = ::ioctl( d->deviceFd, request, ap );
+//     va_end( ap );
+
+//     d->mutex.unlock();
+// #endif
+//     return r;
+// }
+
+
+void K3bDevice::Device::usageLock() const
+{
+    d->mutex.lock();
+}
+
+
+void K3bDevice::Device::usageUnlock() const
+{
+    d->mutex.unlock();
+}
diff --git a/libk3bdevice/k3bdevice.h b/libk3bdevice/k3bdevice.h
new file mode 100644
index 0000000..1dcd863
--- /dev/null
+++ b/libk3bdevice/k3bdevice.h
@@ -0,0 +1,836 @@
+/*
+ *
+ * $Id: k3bdevice.h 679274 2007-06-23 13:23:58Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#ifndef K3BDEVICE_H
+#define K3BDEVICE_H
+
+#include <qstringlist.h>
+#include <qvaluelist.h>
+#include <qglobal.h>
+
+#include <k3bdevicetypes.h>
+#include <k3bdiskinfo.h>
+#include <k3bcdtext.h>
+#include <k3bmsf.h>
+#include <k3bdevice_export.h>
+
+#ifdef Q_OS_FREEBSD
+struct cam_device;
+#endif
+
+namespace K3bDevice
+{
+  class Toc;
+
+  /**
+   * \brief The main class representing a device.
+   *
+   * Devices are constructed by the DeviceManager.
+   *
+   * All methods except for open and close in Device are thread-safe which basicly means that
+   * no two commands are sent to the device at the same time.
+   */
+  // FIXME: all methods are const which makes no sense at all!
+  class LIBK3BDEVICE_EXPORT Device
+    {
+    public:
+#ifdef Q_OS_FREEBSD
+      typedef struct cam_device* Handle;
+#else
+    // file descriptor
+      typedef int Handle;
+#endif
+
+      /**
+       * The available cdrdao drivers
+       * \deprecated This will be moved to libk3b
+       */
+      static const char* cdrdao_drivers[];
+
+      // FIXME: make this protected
+      ~Device();
+
+      /**
+       * The interface type.
+       *
+       * \return K3bDevice::SCSI or K3bDevice::IDE.
+       */
+      Interface interfaceType() const;
+
+      /**
+       * \deprecated use readCapabilities() and writeCapabilities()
+       * The device type.
+       *
+       * @return A bitwise or of K3bDevice::DeviceType.
+       */
+      int type() const;
+
+      /**
+       * The mediatypes this device is able to read.
+       *
+       * \return A bitwise or of K3bDevice::MediaType
+       */
+      int readCapabilities() const;
+
+      /**
+       * The media types this device is able to write.
+       *
+       * \return A bitwise or of K3bDevice::MediaType
+       */      
+      int writeCapabilities() const;
+
+      /**
+       * \return Vendor string as reported by the device's firmware.
+       */
+      const QString& vendor() const { return m_vendor; }
+
+      /**
+       * \return Description string as reported by the device's firmware.
+       */
+      const QString& description() const { return m_description; }
+
+      /**
+       * \return Version string as reported by the device's firmware.
+       */
+      const QString& version() const { return m_version; }
+
+      /**
+       * Shortcut for \code writesCd() || writesDvd() \endcode
+       *
+       * \return true if the device is able to burn media.
+       */
+      bool burner() const;
+
+      /**
+       * Shortcut for \code type() & DEVICE_CD_R \endcode
+       *
+       * \return true if the device is able to burn CD-R media.
+       */
+      bool writesCd() const;
+
+      /**
+       * Shortcut for \code type() & DEVICE_CD_RW \endcode
+       *
+       * \return true if the device is able to burn CD-RW media.
+       */
+      bool writesCdrw() const;
+
+      /**
+       * Shortcut for \code writesDvdMinus() || writesDvdPlus() \endcode
+       *
+       * \return true if the device is able to burn DVD media.
+       */
+      bool writesDvd() const;
+
+
+      /**
+       * Shortcut for \code type() & (DEVICE_DVD_PLUS_R|DEVICE_DVD_PLUS_RW) \endcode
+       *
+       * \return true if the device is able to burn DVD+R or DVD+RW media.
+       */
+      bool writesDvdPlus() const;
+
+      /**
+       * Shortcut for \code type() & (DEVICE_DVD_R|DEVICE_DVD_RW) \endcode
+       *
+       * \return true if the device is able to burn DVD-R or DVD-RW media.
+       */
+      bool writesDvdMinus() const;
+
+      /**
+       * Shortcut for \code type() & DEVICE_DVD_ROM \endcode
+       *
+       * \return true if the device is able to read DVD media.
+       */
+      bool readsDvd() const;
+
+      /**
+       * @deprecated Use burnfree()
+       */
+      bool burnproof() const;
+
+      /**
+       * @return true is the device is a writer and supports buffer underrun free recording (BURNFREE)
+       */
+      bool burnfree() const;
+
+      /**
+       * Shortcut for \code writingModes() & WRITINGMODE_SAO \endcode
+       *
+       * \deprecated use supportsWritingMode()
+       */
+      bool dao() const;
+
+      /**
+       * Check if the device supports a certain writing mode.
+       *
+       * \return true if the device supports the requested writing mode or false otherwise.
+       */
+      bool supportsWritingMode( WritingMode mode ) const { return (m_writeModes & mode); }
+
+      /**
+       * Shortcut for 
+       * \code
+       *  writingModes() & (WRITINGMODE_RAW|WRITINGMODE_RAW_R16|WRITINGMODE_RAW_R96P|WRITINGMODE_RAW_R96R)
+       * \endcode
+       */
+      bool supportsRawWriting() const;
+
+      /**
+       * @return true if the device is a DVD-R(W) writer which supports test writing.
+       */
+      bool dvdMinusTestwrite() const { return m_dvdMinusTestwrite; }
+
+      int maxReadSpeed() const { return m_maxReadSpeed; }
+      int currentWriteSpeed() const { return m_currentWriteSpeed; }
+
+      /**
+       * Size of the device's internal writing buffer.
+       *
+       * \return The size of the buffer in KB.
+       */
+      int bufferSize() const { return m_bufferSize; }
+
+      /**
+       * @return the corresponding device name.
+       */
+      const QString& devicename() const;
+
+      /**
+       * for SCSI devices this should be something like /dev/scd0 or /dev/sr0
+       * for IDE device this should be something like /dev/hdb1
+       */
+      const QString& blockDeviceName() const { return m_blockDevice; }
+
+      /**
+       * This is only valid for SCSI devices. Without devfs it's something
+       * like /dev/sg0. Otherwise something like /dev/scsi/host0/bus0/target0/lun0/generic.
+       *
+       * This is not needed in K3b at all. But cdrecord and cdrdao use the sg devices and
+       * we need it to fixup it's permissions in K3bSetup.
+       */
+      const QString& genericDevice() const { return m_genericDevice; }
+
+      /**
+       * \return All device nodes for this drive.
+       */
+      const QStringList& deviceNodes() const;
+
+      /**
+       * \see K3bDevice::Device::deviceNodes()
+       */
+      void addDeviceNode( const QString& );
+
+      /**
+       * Makes only sense to use with scsi devices
+       * @return a string for use with the cdrtools
+       * @deprecated
+       */
+      QString busTargetLun() const;
+
+      int scsiBus() const { return m_bus; }
+      int scsiId() const { return m_target; }
+      int scsiLun() const { return m_lun; }
+
+      int maxWriteSpeed() const { return m_maxWriteSpeed; }
+
+      /**
+       * \deprecated the cdrdao driver has no place in this library. It will be removed.
+       */
+      const QString& cdrdaoDriver() const { return m_cdrdaoDriver; }
+
+      /**
+       * returns: 0 auto (no cdrdao-driver selected)
+       *          1 yes
+       *          2 no
+       *
+       * \deprecated cdrdao specific stuff has no place in this library. It will be removed.
+       */
+      int cdTextCapable() const;
+
+      /**
+       * internal K3b value.
+       * \deprecated This should not be handled here.
+       */
+      void setCurrentWriteSpeed( int s ) { m_currentWriteSpeed = s; }
+
+      /**
+       * Use this if the speed was not detected correctly.
+       */
+      void setMaxReadSpeed( int s ) { m_maxReadSpeed = s; }
+
+      /**
+       * Use this if the speed was not detected correctly.
+       */
+      void setMaxWriteSpeed( int s ) { m_maxWriteSpeed = s; }
+
+      /**
+       * Use this if cdrdao is not able to autodetect the nessessary driver.
+       * \deprecated the cdrdao driver has no place in this library. It will be removed.
+       */
+      void setCdrdaoDriver( const QString& d ) { m_cdrdaoDriver = d; }
+
+      /**
+       * Only used if the cdrdao-driver is NOT set to "auto".
+       * In that case it must be manually set because there
+       * is no way to autosense the cd-text capability.
+       *
+       * \deprecated the cdrdao driver has no place in this library. It will be removed.
+       */
+      void setCdTextCapability( bool );
+
+      /**
+       * checks if unit is ready (medium inserted and ready for command)
+       *
+       * Refers to the MMC command: TEST UNIT READY
+       */
+      bool testUnitReady() const;
+
+      /**
+       * checks if disk is empty, returns @p K3bDevice::State
+       */
+      int isEmpty() const;
+
+      /**
+       * @return true if inserted media is rewritable.
+       */
+      bool rewritable() const;
+
+      /**
+       * Check if the inserted media is a DVD.
+       *
+       * \return true if the inserted media is a DVD.
+       */
+      bool isDVD() const;
+
+      /**
+       * @return The number of sessions on the media.
+       */
+      int numSessions() const;
+
+      /**
+       * @return The toc of the media or an empty (invalid) K3bDevice::Toc if 
+       *         no or an empty media is inserted.
+       */
+      Toc readToc() const;
+
+      /**
+       * Append ISRC and MCN to the TOC if found
+       * This has been moved to a separate method since it can take a very long time
+       * to scan for all ISRCs.
+       */
+      void readIsrcMcn( Toc& toc ) const;
+
+      /**
+       * Read the CD-TEXT of an audio or mixed-mode CD.
+       *
+       * \return A CdText object filled with the CD-TEXT values or an empty one in case of
+       *         pure data media or if the CD does not contain CD-TEXT.
+       */
+      CdText readCdText() const;
+
+      /**
+       * @return The K3bDevice::Track::DataMode of the track.
+       * @see K3bDevice::Track
+       */
+      int getTrackDataMode( const Track& track ) const;
+
+      /**
+       * @return the mode of a data track. K3bDevice::Track::MODE1, K3bDevice::Track::MODE2, 
+       *         K3bDevice::Track::XA_FORM1, or K3bDevice::Track::XA_FORM2.
+       */
+      int getDataMode( const K3b::Msf& sector ) const;
+
+      /**
+       * block or unblock the drive's tray
+       * \return true on success and false on error.
+       * \see eject()
+       */
+      bool block( bool ) const;
+
+      /**
+       * Eject the media.
+       * \return true on success and false on error.
+       * \see load()
+       */
+      bool eject() const;
+
+      /**
+       * Load the media.
+       * @return true on success and false on error.
+       */
+      bool load() const;
+
+      /**
+       * Enable or disable auto-ejecting. For now this is a no-op on non-Linux systems.
+       * \param enabled if true auto-ejecting will be enabled, otherwise disabled.
+       * \return true if the operation was successful, false otherwise
+       */
+      bool setAutoEjectEnabled( bool enabled ) const;
+
+      /**
+       * The supported writing modes.
+       *
+       * \return A bitwise or of K3bDevice::WritingMode or 0 in case of a read-only device.
+       */
+      int writingModes() const { return m_writeModes; }
+
+      bool readSectorsRaw(unsigned char *buf, int start, int count) const;
+
+      /**
+       * Get a list of supported profiles. See enumeration MediaType.
+       */
+      int supportedProfiles() const;
+
+      /**
+       * Tries to get the current profile from the drive.
+       * @returns -1 on error (command failed or unknown profile)
+       *          MediaType otherwise (MEDIA_NONE means: no current profile)
+       */
+      int currentProfile() const;
+
+      /**
+       * Check if a certain feature is current.
+       * \see k3bdevicetypes.h for feature constants.
+       * \return 1 if the feature is current, 0 if not, -1 on error
+       */
+      int featureCurrent( unsigned int feature ) const;
+
+      /**
+       * This is the method to use!
+       */
+      DiskInfo diskInfo() const;
+
+      /**
+       * Refers to MMC command READ CAPACITY
+       */
+      bool readCapacity( K3b::Msf& ) const;
+
+      /**
+       * Refers to MMC command READ FORMAT CAPACITY
+       *
+       * @param wantedFormat The requested format type.
+       * @param result If true is returned this contains the requested value.
+       * @param currentMax If not 0 this will be filled with the Current/Maximum Descriptor value.
+       * @param currentMax If not 0 this will be filled with the Current/Maximum Format Type.
+       */
+      bool readFormatCapacity( int wantedFormat, K3b::Msf& result,
+			       K3b::Msf* currentMax = 0, int* currentMaxFormat = 0 ) const;
+
+      /**
+       * Determine the type of the currently mounted medium
+       *
+       * @returns K3bDevice::MediaType
+       */
+      int mediaType() const;
+
+      /**
+       * Returnes the list of supported writing speeds as reported by
+       * mode page 2Ah.
+       *
+       * This only works with MMC3 compliant drives.
+       */
+      QValueList<int> determineSupportedWriteSpeeds() const;
+
+      /**
+       * @returnes the speed in kb/s or 0 on failure.
+       */
+      int determineMaximalWriteSpeed() const;
+
+      /**
+       * Open the device for access via a file descriptor.
+       * @return true on success or if the device is already open.
+       * @see close()
+       *
+       * Be aware that this method is not thread-safe.
+       */
+      bool open( bool write = false ) const;
+
+      /**
+       * Close the files descriptor.
+       * @see open()
+       *
+       * Be aware that this method is not thread-safe.
+       */
+      void close() const;
+
+      /**
+       * @return true if the device was successfully opened via @p open()
+       */
+      bool isOpen() const;
+
+      /**
+       * fd on linux, cam on bsd
+       */
+      Handle handle() const;
+
+      /**
+       * \return \li -1 on error (no DVD)
+       *         \li 1 (CSS/CPPM)
+       *         \li 2 (CPRM) if scrambled
+       *         \li 0 otherwise
+       */
+      int copyrightProtectionSystemType() const;
+
+      // MMC commands
+
+      /**
+       * SET SPEED command
+       *
+       * @param readingSpeed The preferred reading speed (0x0000-0xFFFE). 0xFFFF requests
+       *                     fot the logical unit to select the optimal speed.
+       * @param writingSpeed The preferred writing speed (0x0000-0xFFFE). 0xFFFF requests
+       *                     fot the logical unit to select the optimal speed.
+       * @param cav Is the speed pure CAV?
+       */
+      bool setSpeed( unsigned int readingSpeed,
+		     unsigned int writingSpeed,
+		     bool cav = false ) const;
+
+      /**
+       * if true is returned dataLen specifies the actual length of *data which needs to be
+       * deleted after using.
+       */
+      bool readDiscInformation( unsigned char** data, unsigned int& dataLen ) const;
+
+      /**
+       * @param pf If false all fields in the descriptor data is vendor specific. Default should be true.
+       */
+      bool modeSelect( unsigned char* page, unsigned int pageLen, bool pf, bool sp ) const;
+
+      /**
+       * if true is returned pageLen specifies the actual length of *pageData which needs to be
+       * deleted after using.
+       */
+      bool modeSense( unsigned char** pageData, unsigned int& pageLen, int page ) const;
+
+      /**
+       * if true is returned dataLen specifies the actual length of *data which needs to be
+       * deleted after using.
+       */
+      bool readTocPmaAtip( unsigned char** data, unsigned int& dataLen, int format, bool msf, int track ) const;
+
+      /**
+       * @param type specifies what value means:
+       *        \li 00b - value refers to a logical block address
+       *        \li 01b - value refers to a track number where 0 will treat the lead-in as if it
+       *                  were a logical track and ffh will read the invisible or incomplete track.
+       *        \li 10b - value refers to a session number
+       *
+       */
+      bool readTrackInformation( unsigned char** data, unsigned int& dataLen, int type, int value ) const;
+
+      /**
+       * if true is returned dataLen specifies the actual length of *data which needs to be
+       * deleted after using.
+       */
+      bool readDiscStructure( unsigned char** data, unsigned int& dataLen, 
+			      unsigned int mediaType = 0x0,
+			      unsigned int format = 0x0,
+			      unsigned int layer = 0x0,
+			      unsigned long adress = 0,
+			      unsigned int agid = 0x0 ) const;
+
+      /**
+       * In MMC5 readDvdStructure was renamed to readDiscStructure. This method does the same
+       * like the above.
+       */
+      bool readDvdStructure( unsigned char** data, unsigned int& dataLen, 
+			     unsigned int format = 0x0,
+			     unsigned int layer = 0x0,
+			     unsigned long adress = 0,
+			     unsigned int agid = 0x0 ) const;
+
+      /**
+       * if true is returned dataLen specifies the actual length of *data which needs to be
+       * deleted after using.
+       */
+      bool mechanismStatus( unsigned char** data, unsigned int& dataLen ) const;
+
+      /**
+       * Read a single feature.
+       * data will be filled with the feature header and the descriptor
+       */
+      bool getFeature( unsigned char** data, unsigned int& dataLen, unsigned int feature ) const;
+
+
+      /**
+       * if true is returned dataLen specifies the actual length of *data which needs to be
+       * deleted after using.
+       */
+      bool getPerformance( unsigned char** data, unsigned int& dataLen,
+			   unsigned int type,
+			   unsigned int dataType,
+			   unsigned int lba = 0 ) const;
+
+      /**
+       * @param sectorType: \li 000b - all types
+       *                    \li 001b - CD-DA
+       *                    \li 010b - Mode 1
+       *                    \li 011b - Mode 2 formless
+       *                    \li 100b - Mode 2 form 1
+       *                    \li 101b - Mode 2 form 2
+       *
+       * @param startAdress Lba 0 is mapped to msf 00:00:00 so this method uses
+       *                    startAdress+150 as the starting msf.
+       *
+       * @param endAdress This is the ending address which is NOT included in the read operation.
+       *                  Lba 0 is mapped to msf 00:00:00 so this method uses
+       *                  endAdress+150 as the ending msf.
+       *
+       * @param c2:         \li 00b  - No error info
+       *                    \li 01b  - 294 bytes, one bit for every byte of the 2352 bytes
+       *                    \li 10b  - 296 bytes, xor of all c2 bits, zero pad bit, 294 c2 bits
+       *
+       * @param subChannel: \li 000b - No Sub-channel data
+       *                    \li 001b - RAW P-W Sub-channel (96 bytes)
+       *                    \li 010b - Formatted Q Sub-channel (16 bytes)
+       *                    \li 100b - Corrected and de-interleaved R-W Sub-channel (96 bytes)
+       */
+      bool readCdMsf( unsigned char* data,
+		      unsigned int dataLen,
+		      int sectorType,
+		      bool dap,
+		      const K3b::Msf& startAdress,
+		      const K3b::Msf& endAdress,
+		      bool sync,
+		      bool header,
+		      bool subHeader,
+		      bool userData,
+		      bool edcEcc,
+		      int c2,
+		      int subChannel ) const;
+
+      /**
+       * @param sectorType: \li 000b - all types
+       *                    \li 001b - CD-DA
+       *                    \li 010b - Mode 1
+       *                    \li 011b - Mode 2 formless
+       *                    \li 100b - Mode 2 form 1
+       *                    \li 101b - Mode 2 form 2
+       *
+       * @param c2:         \li 00b  - No error info
+       *                    \li 01b  - 294 bytes, one bit for every byte of the 2352 bytes
+       *                    \li 10b  - 296 bytes, xor of all c2 bits, zero pad bit, 294 c2 bits
+       *
+       * @param subChannel: \li 000b - No Sub-channel data
+       *                    \li 001b - RAW P-W Sub-channel (96 bytes)
+       *                    \li 010b - Formatted Q Sub-channel (16 bytes)
+       *                    \li 100b - Corrected and de-interleaved R-W Sub-channel (96 bytes)
+       */
+      bool readCd( unsigned char* data,
+		   unsigned int dataLen,
+		   int sectorType,
+		   bool dap,
+		   unsigned long startAdress,
+		   unsigned long length,
+		   bool sync,
+		   bool header,
+		   bool subHeader,
+		   bool userData,
+		   bool edcEcc,
+		   int c2,
+		   int subChannel ) const;
+
+      bool read10( unsigned char* data,
+		   unsigned int dataLen,
+		   unsigned long startAdress,
+		   unsigned int length,
+		   bool fua = false ) const;
+
+      bool read12( unsigned char* data,
+		   unsigned int dataLen,
+		   unsigned long startAdress,
+		   unsigned long length,
+		   bool streaming = false,
+		   bool fua = false ) const;
+
+      /**
+       * @param subchannelParam: 01h - CD current position
+       *                         02h - Media Catalog number (UPC/bar code)
+       *                         03h - ISRC
+       * @param trackNumber only valid if subchannelParam == 03h
+       */
+      bool readSubChannel( unsigned char** data,
+			   unsigned int& dataLen,
+			   unsigned int subchannelParam,
+			   unsigned int trackNumber ) const;
+
+      bool readIsrc( unsigned int track, QCString& isrc ) const;
+
+      bool readMcn( QCString& mcn ) const;
+
+      /**
+       * MMC command Read Buffer Capacity
+       *
+       * \return \see K3bScsiCommand::transport()
+       */
+      int readBufferCapacity( long long& bufferLength, long long& bufferAvail ) const;
+
+      /**
+       * @returns the index number on success
+       *          -1 on general error
+       *          and -2 if there is no index info in that frame
+       */
+      int getIndex( unsigned long lba ) const;
+
+      bool searchIndex0( unsigned long startSec, unsigned long endSec, long& pregapStart ) const;
+
+      /**
+       * For now this just searches index 0 for all tracks and sets
+       * the value in the tracks.
+       * In the future this should scan for all indices.
+       */
+      bool indexScan( K3bDevice::Toc& toc ) const;
+
+      /**
+       * Seek to the specified sector.
+       */
+      bool seek( unsigned long lba ) const;
+
+      bool getNextWritableAdress( unsigned int& lastSessionStart, unsigned int& nextWritableAdress ) const;
+
+      /**
+       * Retrieve the next writable address from the currently mounted writable medium.
+       * \return The next writable address if the medium is empty or appendable or -1
+       * if an error occured.
+       */
+      int nextWritableAddress() const;
+
+      /**
+       * Locks the device for usage. This means that no MMC command can be performed
+       * until usageUnlock is called.
+       *
+       * Locking a device is useful when an external application or library is called
+       * that opens the device itself.
+       *
+       * \sa usageUnlock
+       */
+      void usageLock() const;
+
+      /**
+       * Unlock the device after a call to usageLock.
+       */
+      void usageUnlock() const;
+
+      /**
+       * Thread-safe ioctl call for this device for Linux and Net-BSD systems.
+       * Be aware that so far this does not include opening the device
+       */
+//      int ioctl( int request, ... ) const;
+
+    protected:
+      bool furtherInit();
+
+#ifdef Q_OS_LINUX
+      /**
+       * Fallback method that uses the evil cdrom.h stuff
+       */
+      bool readTocLinux( Toc& ) const;
+#endif
+
+      /**
+       * The preferred toc reading method for all CDs. Also reads session info.
+       * undefined for DVDs.
+       */
+      bool readRawToc( Toc& ) const;
+      bool readFormattedToc( Toc&, int mediaType ) const;
+
+      /**
+       * Fixes the last block on CD-Extra disks. This is needed if the readRawToc failed since
+       * in that case the first sector of the last session's first track is used as the previous
+       * session's last track's last sector which is wrong. There is a 11400 block session lead-in
+       * between them. This method fixes this only for the last session and only on linux.
+       */
+      bool fixupToc( Toc& ) const;
+
+    private:
+      /**
+       * A Device can only be constructed the the DeviceManager.
+       */
+      Device( const QString& devname );
+
+      /**
+       * Determines the device's capabilities. This needs to be called once before
+       * using the device.
+       *
+       * Should only be used by the DeviceManager.
+       *
+       * @param checkWritingModes if true the CD writing modes will be checked using 
+       *                          MMC_MODE_SELECT.
+       */
+      bool init( bool checkWritingModes = true );
+
+      void searchIndexTransitions( long start, long end, K3bDevice::Track& track ) const;
+      void checkWritingModes();
+      void checkFeatures();
+      void checkForJustLink();
+      void checkFor2AFeatures();
+      void checkForAncientWriters();
+
+      /**
+       * Internal method which checks if the raw toc data has bcd values or hex.
+       * @return 0 if hex, 1 if bcd, -1 if none
+       */
+      int rawTocDataWithBcdValues( unsigned char* data, unsigned int dataLen ) const;
+
+      bool getSupportedWriteSpeedsVia2A( QValueList<int>& list, bool dvd ) const;
+      bool getSupportedWriteSpeedsViaGP( QValueList<int>& list, bool dvd ) const;
+
+      QCString mediaId( int mediaType ) const;
+
+      QString m_vendor;
+      QString m_description;
+      QString m_version;
+      QString m_cdrdaoDriver;
+      int m_cdTextCapable;
+      int m_maxReadSpeed;
+      int m_maxWriteSpeed;
+      int m_currentWriteSpeed;
+
+      bool m_dvdMinusTestwrite;
+
+      // only needed for scsi devices
+      int m_bus;
+      int m_target;
+      int m_lun;
+
+      int m_bufferSize;
+
+      int m_writeModes;
+
+      // only needed on FreeBSD
+      QString m_passDevice;
+      QString m_blockDevice;
+      QString m_genericDevice;
+
+      class Private;
+      Private* d;
+      friend class DeviceManager;
+    };
+
+#if defined(Q_OS_LINUX) || defined(Q_OS_NETBSD)
+  /**
+   * This should always be used to open a device since it
+   * uses the resmgr
+   *
+   * @internal
+   */
+  int openDevice( const char* name, bool write = false );
+#endif
+}
+
+#endif
diff --git a/libk3bdevice/k3bdevice_export.h b/libk3bdevice/k3bdevice_export.h
new file mode 100644
index 0000000..6c43716
--- /dev/null
+++ b/libk3bdevice/k3bdevice_export.h
@@ -0,0 +1,33 @@
+/* 
+ *
+ * $Id: sourceheader 511311 2006-02-19 14:51:05Z trueg $
+ * Copyright (c) 2005 Laurent Montel <montel@kde.org>
+ * Copyright (C) 2005-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#ifndef _K3BDEVICE_EXPORT_H_
+#define _K3BDEVICE_EXPORT_H_
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef __KDE_HAVE_GCC_VISIBILITY
+#define LIBK3BDEVICE_NO_EXPORT __attribute__ ((visibility("hidden")))
+#define LIBK3BDEVICE_EXPORT __attribute__ ((visibility("default")))
+#else
+#define LIBK3BDEVICE_NO_EXPORT
+#define LIBK3BDEVICE_EXPORT
+#endif
+
+#endif
+
diff --git a/libk3bdevice/k3bdevice_mmc.cpp b/libk3bdevice/k3bdevice_mmc.cpp
new file mode 100644
index 0000000..77db530
--- /dev/null
+++ b/libk3bdevice/k3bdevice_mmc.cpp
@@ -0,0 +1,947 @@
+/*
+ *
+ * $Id: k3bdevice_mmc.cpp 690628 2007-07-21 16:05:08Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+/**
+This file contains all the MMC command implementations of the K3b device class
+to make the code more readable.
+**/
+
+
+#include "k3bdevice.h"
+#include "k3bscsicommand.h"
+#include "k3bdeviceglobals.h"
+#include "k3bdebug.h"
+
+#include <string.h>
+
+
+bool K3bDevice::Device::testUnitReady() const
+{
+  ScsiCommand cmd( this );
+  cmd.enableErrorMessages( false );
+  cmd[0] = MMC_TEST_UNIT_READY;
+  cmd[5] = 0; // Necessary to set the proper command length
+  return( cmd.transport() == 0 );
+}
+
+
+bool K3bDevice::Device::getFeature( unsigned char** data, unsigned int& dataLen, unsigned int feature ) const
+{
+  unsigned char header[2048];
+  ::memset( header, 0, 2048 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_GET_CONFIGURATION;
+  cmd[1] = 2;      // read only specified feature
+  cmd[2] = feature>>8;
+  cmd[3] = feature;
+  cmd[8] = 8;      // we only read the data length first
+  cmd[9] = 0;      // Necessary to set the proper command length
+
+  // we only read the data length first
+  dataLen = 8;
+  if( cmd.transport( TR_DIR_READ, header, 8 ) )
+    dataLen = from4Byte( header ) + 4;
+  else
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": GET CONFIGURATION length det failed." << endl;
+
+  //
+  // Some buggy firmwares do not return the size of the available data
+  // but the returned data or something invalid altogether.
+  // So we simply use the maximum possible value to be on the safe side
+  // with these buggy drives.
+  // We cannot use this as default since many firmwares fail with a too high data length.
+  //
+  if( (dataLen-8) % 8 || dataLen <= 8 )
+    dataLen = 0xFFFF;
+
+  // again with real length
+  *data = new unsigned char[dataLen];
+  ::memset( *data, 0, dataLen );
+
+  cmd[7] = dataLen>>8;
+  cmd[8] = dataLen;
+  if( cmd.transport( TR_DIR_READ, *data, dataLen ) == 0 ) {
+    dataLen = QMIN( dataLen, from4Byte( *data ) + 4 );
+    return true;
+  }
+  else {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": GET CONFIGURATION with real length "
+	      << dataLen << " failed." << endl;
+    delete [] *data;
+  }
+
+  return false;
+}
+
+
+int K3bDevice::Device::featureCurrent( unsigned int feature ) const
+{
+  unsigned char* data = 0;
+  unsigned int dataLen = 0;
+  if( getFeature( &data, dataLen, feature ) ) {
+    int ret = -1;
+    if( dataLen >= 11 )
+      ret = ( data[8+2]&1 ? 1 : 0 );  // check the current flag
+
+    delete [] data;
+
+    return ret;
+  }
+  else
+    return -1;
+}
+
+
+bool K3bDevice::Device::readIsrc( unsigned int track, QCString& isrc ) const
+{
+  unsigned char* data = 0;
+  unsigned int dataLen = 0;
+
+  if( readSubChannel( &data, dataLen, 0x3, track ) ) {
+    bool isrcValid = false;
+
+    if( dataLen >= 8+18 ) {
+      isrcValid = (data[8+4]>>7 & 0x1);
+
+      if( isrcValid ) {
+	isrc = QCString( reinterpret_cast<char*>(data[8+5]), 13 );
+
+	// TODO: check the range of the chars
+
+      }
+    }
+
+    delete [] data;
+
+    return isrcValid;
+  }
+  else
+    return false;
+}
+
+
+bool K3bDevice::Device::readMcn( QCString& mcn ) const
+{
+  unsigned char* data = 0;
+  unsigned int dataLen = 0;
+
+  if( readSubChannel( &data, dataLen, 0x2, 0 ) ) {
+    bool mcnValid = false;
+
+    if( dataLen >= 8+18 ) {
+      mcnValid = (data[8+4]>>7 & 0x1);
+
+      if( mcnValid )
+	mcn = QCString( reinterpret_cast<char*>(data[8+5]), 14 );
+    }
+
+    delete [] data;
+
+    return mcnValid;
+  }
+  else
+    return false;
+}
+
+
+bool K3bDevice::Device::getPerformance( unsigned char** data, unsigned int& dataLen,
+					unsigned int type,
+					unsigned int dataType,
+					unsigned int lba ) const
+{
+  unsigned int descLen = 0;
+  switch( type ) {
+  case 0x0:
+    descLen = 16;
+    break;
+  case 0x1:
+    descLen = 8;
+    break;
+  case 0x2:
+    descLen = 2048;
+    break;
+  case 0x3:
+    descLen = 16;
+    break;
+  case 0x4:
+    descLen = 8;
+    break;
+  case 0x5:
+    descLen = 8; // FIXME: ??
+    break;
+  }
+
+  unsigned char header[8];
+  ::memset( header, 0, 8 );
+  dataLen = 8;
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_GET_PERFORMANCE;
+  cmd[1] = dataType;
+  cmd[2] = lba >> 24;
+  cmd[3] = lba >> 16;
+  cmd[4] = lba >> 8;
+  cmd[5] = lba;
+  cmd[9] = 1;      // first we read one descriptor
+  cmd[10] = type;
+  cmd[11] = 0;     // Necessary to set the proper command length
+  if( cmd.transport( TR_DIR_READ, header, 8 ) ) {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+	      << ": GET PERFORMANCE length det failed." << endl;
+    return false;
+  }
+
+  dataLen = from4Byte( header ) + 4;
+
+  k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+             << ": GET PERFORMANCE dataLen = " << dataLen << endl;
+
+  if( (dataLen-8) % descLen ||
+      dataLen <= 8 ||
+      dataLen > 2048 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+                 << ": GET PERFORMANCE reports bogus dataLen: " << dataLen << endl;
+      return false;
+  }
+
+  *data = new unsigned char[dataLen];
+  ::memset( *data, 0, dataLen );
+
+  unsigned int numDesc = (dataLen-8)/descLen;
+
+  cmd[8] = numDesc>>8;
+  cmd[9] = numDesc;
+  if( cmd.transport( TR_DIR_READ, *data, dataLen ) == 0 ) {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+                 << ": GET PERFORMANCE successful with reported length: " << from4Byte( *data ) << endl;
+      dataLen = QMIN( dataLen, from4Byte( *data ) + 4 );
+      return true;
+  }
+  else {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+	      << ": GET PERFORMANCE with real length "
+	      << dataLen << " failed." << endl;
+    delete [] *data;
+    return false;
+  }
+}
+
+
+bool K3bDevice::Device::setSpeed( unsigned int readingSpeed,
+				  unsigned int writingSpeed,
+				  bool cav ) const
+{
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_SET_SPEED;
+  cmd[1] = ( cav ? 0x1 : 0x0 );
+  cmd[2] = readingSpeed >> 8;
+  cmd[3] = readingSpeed;
+  cmd[4] = writingSpeed >> 8;
+  cmd[5] = writingSpeed;
+  cmd[11] = 0;      // Necessary to set the proper command length
+  return ( cmd.transport( TR_DIR_WRITE ) == 0 );
+}
+
+
+bool K3bDevice::Device::seek( unsigned long lba ) const
+{
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_SEEK_10;
+  cmd[2] = lba>>24;
+  cmd[3] = lba>>16;
+  cmd[4] = lba>>8;
+  cmd[5] = lba;
+  cmd[9] = 0;      // Necessary to set the proper command length
+  return !cmd.transport();
+}
+
+
+bool K3bDevice::Device::readTrackInformation( unsigned char** data, unsigned int& dataLen, int type, int value ) const
+{
+  unsigned char header[2048];
+  ::memset( header, 0, 2048 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_TRACK_INFORMATION;
+  cmd[9] = 0;      // Necessary to set the proper command length
+
+  switch( type ) {
+  case 0:
+  case 1:
+  case 2:
+    cmd[1] = type & 0x3;
+    cmd[2] = value>>24;
+    cmd[3] = value>>16;
+    cmd[4] = value>>8;
+    cmd[5] = value;
+    break;
+  default:
+    k3bDebug() << "(K3bDevice::readTrackInformation) wrong type parameter: " << type << endl;
+    return false;
+  }
+
+  // first we read the header
+  dataLen = 4;
+  cmd[8] = 4;
+  if( cmd.transport( TR_DIR_READ, header, 4 ) == 0 )
+    dataLen = from2Byte( header ) + 2;
+  else
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ TRACK INFORMATION length det failed." << endl;
+
+  //
+  // Some buggy firmwares do not return the size of the available data
+  // but the returned data.
+  // So we try to determine the correct size based on the medium type
+  // DVD+R:  40 (MMC4)
+  // DVD-DL: 48 (MMC5)
+  // CD:     36 (MMC2)
+  //
+  if( dataLen <= 4 ) {
+    int m = mediaType();
+    if( m & (MEDIA_DVD_R_DL|MEDIA_DVD_R_DL_SEQ|MEDIA_DVD_R_DL_JUMP) )
+      dataLen = 48;
+    else if( m & (MEDIA_DVD_PLUS_R|MEDIA_DVD_PLUS_R_DL) )
+      dataLen = 40;
+    else
+      dataLen = 36;
+  }
+
+  // again with real length
+  *data = new unsigned char[dataLen];
+  ::memset( *data, 0, dataLen );
+
+  cmd[7] = dataLen>>8;
+  cmd[8] = dataLen;
+  if( cmd.transport( TR_DIR_READ, *data, dataLen ) == 0 ) {
+    dataLen = QMIN( dataLen, from2Byte( *data ) + 2u );
+    return true;
+  }
+  else {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ TRACK INFORMATION with real length "
+	      << dataLen << " failed." << endl;
+    delete [] *data;
+  }
+
+  return false;
+}
+
+
+
+bool K3bDevice::Device::read10( unsigned char* data,
+				unsigned int dataLen,
+				unsigned long startAdress,
+				unsigned int length,
+				bool fua ) const
+{
+  ::memset( data, 0, dataLen );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_10;
+  cmd[1] = ( fua ? 0x8 : 0x0 );
+  cmd[2] = startAdress>>24;
+  cmd[3] = startAdress>>16;
+  cmd[4] = startAdress>>8;
+  cmd[5] = startAdress;
+  cmd[7] = length>>8;
+  cmd[8] = length;
+  cmd[9] = 0;      // Necessary to set the proper command length
+
+  if( cmd.transport( TR_DIR_READ, data, dataLen ) ) {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ 10 failed!" << endl;
+    return false;
+  }
+  else
+    return true;
+}
+
+
+bool K3bDevice::Device::read12( unsigned char* data,
+				unsigned int dataLen,
+				unsigned long startAdress,
+				unsigned long length,
+				bool streaming,
+				bool fua ) const
+{
+  ::memset( data, 0, dataLen );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_12;
+  cmd[1] = ( fua ? 0x8 : 0x0 );
+  cmd[2] = startAdress>>24;
+  cmd[3] = startAdress>>16;
+  cmd[4] = startAdress>>8;
+  cmd[5] = startAdress;
+  cmd[6] = length>>24;
+  cmd[7] = length>>16;
+  cmd[8] = length>>8;
+  cmd[9] = length;
+  cmd[10] = (streaming ? 0x80 : 0 );
+  cmd[11] = 0;      // Necessary to set the proper command length
+
+  if( cmd.transport( TR_DIR_READ, data, dataLen ) ) {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ 12 failed!" << endl;
+    return false;
+  }
+  else
+    return true;
+}
+
+
+bool K3bDevice::Device::readCd( unsigned char* data,
+				unsigned int dataLen,
+				int sectorType,
+				bool dap,
+				unsigned long startAdress,
+				unsigned long length,
+				bool sync,
+				bool header,
+				bool subHeader,
+				bool userData,
+				bool edcEcc,
+				int c2,
+				int subChannel ) const
+{
+  ::memset( data, 0, dataLen );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_CD;
+  cmd[1] = (sectorType<<2 & 0x1c) | ( dap ? 0x2 : 0x0 );
+  cmd[2] = startAdress>>24;
+  cmd[3] = startAdress>>16;
+  cmd[4] = startAdress>>8;
+  cmd[5] = startAdress;
+  cmd[6] = length>>16;
+  cmd[7] = length>>8;
+  cmd[8] = length;
+  cmd[9] = ( ( sync      ? 0x80 : 0x0 ) |
+	     ( subHeader ? 0x40 : 0x0 ) |
+	     ( header    ? 0x20 : 0x0 ) |
+	     ( userData  ? 0x10 : 0x0 ) |
+	     ( edcEcc    ? 0x8  : 0x0 ) |
+	     ( c2<<1 & 0x6 ) );
+  cmd[10] = subChannel & 0x7;
+  cmd[11] = 0;      // Necessary to set the proper command length
+
+  if( cmd.transport( TR_DIR_READ, data, dataLen ) ) {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ CD failed!" << endl;
+    return false;
+  }
+  else {
+    return true;
+  }
+}
+
+
+bool K3bDevice::Device::readCdMsf( unsigned char* data,
+				   unsigned int dataLen,
+				   int sectorType,
+				   bool dap,
+				   const K3b::Msf& startAdress,
+				   const K3b::Msf& endAdress,
+				   bool sync,
+				   bool header,
+				   bool subHeader,
+				   bool userData,
+				   bool edcEcc,
+				   int c2,
+				   int subChannel ) const
+{
+  ::memset( data, 0, dataLen );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_CD_MSF;
+  cmd[1] = (sectorType<<2 & 0x1c) | ( dap ? 0x2 : 0x0 );
+  cmd[3] = (startAdress+150).minutes();
+  cmd[4] = (startAdress+150).seconds();
+  cmd[5] = (startAdress+150).frames();
+  cmd[6] = (endAdress+150).minutes();
+  cmd[7] = (endAdress+150).seconds();
+  cmd[8] = (endAdress+150).frames();
+  cmd[9] = ( ( sync      ? 0x80 : 0x0 ) |
+	     ( subHeader ? 0x40 : 0x0 ) |
+	     ( header    ? 0x20 : 0x0 ) |
+	     ( userData  ? 0x10 : 0x0 ) |
+	     ( edcEcc    ? 0x8  : 0x0 ) |
+	     ( c2<<1 & 0x6 ) );
+  cmd[10] = subChannel & 0x7;
+  cmd[11] = 0;      // Necessary to set the proper command length
+
+  if( cmd.transport( TR_DIR_READ, data, dataLen ) ) {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ CD MSF failed!" << endl;
+    return false;
+  }
+  else
+    return true;
+}
+
+
+bool K3bDevice::Device::readSubChannel( unsigned char** data, unsigned int& dataLen,
+					unsigned int subchannelParam,
+					unsigned int trackNumber ) const
+{
+  unsigned char header[2048];
+  ::memset( header, 0, 2048 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_SUB_CHANNEL;
+  cmd[2] = 0x40;    // SUBQ
+  cmd[3] = subchannelParam;
+  cmd[6] = trackNumber;   // only used when subchannelParam == 03h (ISRC)
+  cmd[8] = 4;
+  cmd[9] = 0;      // Necessary to set the proper command length
+
+  // first we read the header
+  dataLen = 4;
+  if( cmd.transport( TR_DIR_READ, header, 4 ) == 0 )
+    dataLen = from2Byte( &header[2] ) + 4;
+  else
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ SUB-CHANNEL length det failed." << endl;
+
+  //
+  // Some buggy firmwares do not return the size of the available data
+  // but the returned data. So we simply use the maximum possible value to be on the safe side
+  // with these buggy drives.
+  // We cannot use this as default since many firmwares fail with a too high data length.
+  //
+  if( dataLen <= 4 )
+    dataLen = 0xFFFF;
+
+  // again with real length
+  *data = new unsigned char[dataLen];
+  ::memset( *data, 0, dataLen );
+
+  cmd[7] = dataLen>>8;
+  cmd[8] = dataLen;
+  if( cmd.transport( TR_DIR_READ, *data, dataLen ) == 0 ) {
+    dataLen = QMIN( dataLen, from2Byte( (*data)+2 ) + 4u );
+    return true;
+  }
+  else {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ SUB-CHANNEL with real length "
+	      << dataLen << " failed." << endl;
+    delete [] *data;
+  }
+
+  return false;
+}
+
+
+bool K3bDevice::Device::readTocPmaAtip( unsigned char** data, unsigned int& dataLen, int format, bool time, int track ) const
+{
+  unsigned int descLen = 0;
+
+  switch( format ) {
+  case 0x0:
+    descLen = 8;
+    break;
+  case 0x1:
+    descLen = 8;
+    break;
+  case 0x2:
+    descLen = 11;
+    break;
+  case 0x3:
+    descLen = 11;
+    break;
+  case 0x4:
+    descLen = 4; // MMC2: 24 and MMC4: 28, so we use the highest common factor
+    break;
+  case 0x5:
+    descLen = 18;
+    break;
+  }
+
+  unsigned char header[2048];
+  ::memset( header, 0, 2048 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_TOC_PMA_ATIP;
+  cmd[1] = ( time ? 0x2 : 0x0 );
+  cmd[2] = format & 0x0F;
+  cmd[6] = track;
+  cmd[8] = 4;
+  cmd[9] = 0;      // Necessary to set the proper command length
+
+  // we only read the header
+  dataLen = 4;
+  if( cmd.transport( TR_DIR_READ, header, 4 ) == 0 )
+    dataLen = from2Byte( header ) + 2;
+  else
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ TOC/PMA/ATIP length det failed." << endl;
+
+  //
+  // Some buggy firmwares return an invalid size here
+  // So we simply use the maximum possible value to be on the safe side
+  // with these buggy drives.
+  // We cannot use this as default since many firmwares fail with a too high data length.
+  //
+  if( (dataLen-4) % descLen || dataLen < 4+descLen ) {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ TOC/PMA/ATIP invalid length returned: " << dataLen << endl;
+    dataLen = 0xFFFF;
+  }
+
+  //
+  // Not all drives like uneven numbers
+  //
+  if( dataLen%2 )
+    ++dataLen;
+
+  // again with real length
+  *data = new unsigned char[dataLen];
+  ::memset( *data, 0, dataLen );
+
+  cmd[7] = dataLen>>8;
+  cmd[8] = dataLen;
+  if( cmd.transport( TR_DIR_READ, *data, dataLen ) == 0 ) {
+    dataLen = QMIN( dataLen, from2Byte( *data ) + 2u );
+    if( (dataLen-4) % descLen || dataLen < 4+descLen ) {
+        // useless length
+        delete [] *data;
+        return false;
+    }
+    else
+        return true;
+  }
+  else {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ TOC/PMA/ATIP format "
+	      << format << " with real length "
+	      << dataLen << " failed." << endl;
+    delete [] *data;
+  }
+
+  return false;
+}
+
+
+bool K3bDevice::Device::mechanismStatus( unsigned char** data, unsigned int& dataLen ) const
+{
+  unsigned char header[2048];
+  ::memset( header, 0, 2048 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_MECHANISM_STATUS;
+  cmd[9] = 8;
+  cmd[11] = 0;    // Necessary to set the proper command length
+
+  // first we read the header
+  dataLen = 8;
+  if( cmd.transport( TR_DIR_READ, header, 8 ) == 0 )
+    dataLen = from4Byte( &header[6] ) + 8;
+  else
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": MECHANISM STATUS length det failed." << endl;
+
+  //
+  // Some buggy firmwares do not return the size of the available data
+  // but the returned data or something invalid altogether.
+  // So we simply use the maximum possible value to be on the safe side
+  // with these buggy drives.
+  // We cannot use this as default since many firmwares fail with a too high data length.
+  //
+  if( (dataLen-8) % 4 || dataLen <= 8 )
+    dataLen = 0xFFFF;
+
+  k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": MECHANISM STATUS "
+	    << (int)header[5] << " slots." << endl;
+
+  // again with real length
+  *data = new unsigned char[dataLen];
+  ::memset( *data, 0, dataLen );
+
+  cmd[8] = dataLen>>8;
+  cmd[9] = dataLen;
+  if( cmd.transport( TR_DIR_READ, *data, dataLen ) == 0 ) {
+    dataLen = QMIN( dataLen, from4Byte( (*data)+6 ) + 8 );
+    return true;
+  }
+  else {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": MECHANISM STATUS with real length "
+	      << dataLen << " failed." << endl;
+    delete [] *data;
+  }
+
+  return false;
+}
+
+
+
+bool K3bDevice::Device::modeSense( unsigned char** pageData, unsigned int& pageLen, int page ) const
+{
+  unsigned char header[2048];
+  ::memset( header, 0, 2048 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_MODE_SENSE;
+  cmd[1] = 0x8;        // Disable Block Descriptors
+  cmd[2] = page & 0x3F;
+  cmd[8] = 8;
+  cmd[9] = 0;           // Necessary to set the proper command length
+
+  // first we determine the data length
+  pageLen = 8;
+  if( cmd.transport( TR_DIR_READ, header, 8 ) == 0 )
+    pageLen = from2Byte( header ) + 2;
+  else
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": MODE SENSE length det failed." << endl;
+
+  //
+  // Some buggy firmwares do not return the size of the available data
+  // but the returned data. So we simply use the maximum possible value to be on the safe side
+  // with these buggy drives.
+  // We cannot use this as default since many firmwares fail with a too high data length.
+  //
+  if( pageLen == 8 )
+    pageLen = 0xFFFF;
+
+  // again with real length
+  *pageData = new unsigned char[pageLen];
+  ::memset( *pageData, 0, pageLen );
+
+  cmd[7] = pageLen>>8;
+  cmd[8] = pageLen;
+  if( cmd.transport( TR_DIR_READ, *pageData, pageLen ) == 0 ) {
+    pageLen = QMIN( pageLen, from2Byte( *pageData ) + 2u );
+    return true;
+  }
+  else {
+    delete [] *pageData;
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": MODE SENSE with real length "
+	      << pageLen << " failed." << endl;
+  }
+
+  return false;
+}
+
+
+bool K3bDevice::Device::modeSelect( unsigned char* page, unsigned int pageLen, bool pf, bool sp ) const
+{
+  page[0] = 0;
+  page[1] = 0;
+  page[4] = 0;
+  page[5] = 0;
+
+  // we do not support Block Descriptors here
+  page[6] = 0;
+  page[7] = 0;
+
+  // PS bit reserved
+  page[8] &= 0x3F;
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_MODE_SELECT;
+  cmd[1] = ( sp ? 1 : 0 ) | ( pf ? 0x10 : 0 );
+  cmd[7] = pageLen>>8;
+  cmd[8] = pageLen;
+  cmd[9] = 0;
+  return( cmd.transport( TR_DIR_WRITE, page, pageLen ) == 0 );
+}
+
+
+// does only make sense for complete media
+bool K3bDevice::Device::readCapacity( K3b::Msf& r ) const
+{
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_CAPACITY;
+  cmd[9] = 0;      // Necessary to set the proper command length
+  unsigned char buf[8];
+  ::memset( buf, 0, 8 );
+  if( cmd.transport( TR_DIR_READ, buf, 8 ) == 0 ) {
+    r = from4Byte( buf );
+    return true;
+  }
+  else
+    return false;
+}
+
+
+bool K3bDevice::Device::readFormatCapacity( int wantedFormat, K3b::Msf& r,
+					    K3b::Msf* currentMax, int* currentMaxFormat ) const
+{
+  bool success = false;
+
+  // the maximal length as stated in MMC4
+  static const unsigned int maxLen = 4 + (8*32);
+
+  unsigned char buffer[maxLen];
+  ::memset( buffer, 0, maxLen );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_FORMAT_CAPACITIES;
+  cmd[7] = maxLen >> 8;
+  cmd[8] = maxLen & 0xFF;
+  cmd[9] = 0;      // Necessary to set the proper command length
+  if( cmd.transport( TR_DIR_READ, buffer, maxLen ) == 0 ) {
+
+    unsigned int realLength = buffer[3] + 4;
+
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " READ FORMAT CAPACITY: Current/Max "
+	      << (int)(buffer[8]&0x3) << " " << from4Byte( &buffer[4] ) << endl;
+
+    if( currentMax )
+      *currentMax = from4Byte( &buffer[4] );
+    if( currentMaxFormat )
+      *currentMaxFormat = (int)(buffer[8]&0x3);
+
+    //
+    // Descriptor Type:
+    // 0 - reserved
+    // 1 - unformatted :)
+    // 2 - formatted. Here we get the used capacity (lead-in to last lead-out/border-out)
+    // 3 - No media present
+    //
+    for( unsigned int i = 12; i < realLength-4; i+=8 ) {
+      int format = (int)((buffer[i+4]>>2)&0x3f);
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << " READ FORMAT CAPACITY: "
+		<< format << " " << from4Byte( &buffer[i] )
+		<< " " << (int)( buffer[i+5] << 16 & 0xFF0000 |
+				 buffer[i+6] << 8  & 0xFF00 |
+				 buffer[i+7]       & 0xFF ) << endl;
+
+      if( format == wantedFormat ) {
+	// found the descriptor
+	r = QMAX( (int)from4Byte( &buffer[i] ), r.lba() );
+	success = true;
+      }
+    }
+  }
+
+  return success;
+}
+
+
+bool K3bDevice::Device::readDiscInformation( unsigned char** data, unsigned int& dataLen ) const
+{
+  unsigned char header[2];
+  ::memset( header, 0, 2 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_DISC_INFORMATION;
+  cmd[8] = 2;
+  cmd[9] = 0;      // Necessary to set the proper command length
+
+  if( cmd.transport( TR_DIR_READ, header, 2 ) == 0 )
+    dataLen = from2Byte( header ) + 2;
+  else
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+	       << ": READ DISC INFORMATION length det failed" << endl;
+
+  if( dataLen < 32 ) {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName()
+	       << ": Device reports bogus disc information length of " << dataLen << endl;
+    dataLen = 32;
+  }
+
+  *data = new unsigned char[dataLen];
+  ::memset( *data, 0, dataLen );
+
+  cmd[7] = dataLen>>8;
+  cmd[8] = dataLen;
+  if( cmd.transport( TR_DIR_READ, *data, dataLen ) == 0 ) {
+    dataLen = QMIN( dataLen, from2Byte( *data ) + 2u );
+    return true;
+  }
+  else {
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ DISC INFORMATION with real length "
+	      << dataLen << " failed." << endl;
+    delete [] *data;
+  }
+
+  return false;
+}
+
+
+bool K3bDevice::Device::readDvdStructure( unsigned char** data, unsigned int& dataLen,
+					  unsigned int format,
+					  unsigned int layer,
+					  unsigned long adress,
+					  unsigned int agid ) const
+{
+  return readDiscStructure( data, dataLen, 0x0, format, layer, adress, agid );
+}
+
+
+bool K3bDevice::Device::readDiscStructure( unsigned char** data, unsigned int& dataLen,
+					   unsigned int mediaType,
+					   unsigned int format,
+					   unsigned int layer,
+					   unsigned long adress,
+					   unsigned int agid ) const
+{
+  unsigned char header[4];
+  ::memset( header, 0, 4 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_DVD_STRUCTURE;
+  cmd[1] = mediaType & 0xF;
+  cmd[2] = adress>>24;
+  cmd[3] = adress>>16;
+  cmd[4] = adress>>8;
+  cmd[5] = adress;
+  cmd[6] = layer;
+  cmd[7] = format;
+  cmd[10] = (agid<<6);
+  cmd[11] = 0;      // Necessary to set the proper command length
+
+  cmd[9] = 4;
+  if( cmd.transport( TR_DIR_READ, header, 4 ) == 0 ) {
+    // again with real length
+    dataLen = from2Byte( header ) + 2;
+
+    *data = new unsigned char[dataLen];
+    ::memset( *data, 0, dataLen );
+
+    cmd[8] = dataLen>>8;
+    cmd[9] = dataLen;
+    if( cmd.transport( TR_DIR_READ, *data, dataLen ) == 0 ) {
+      dataLen = QMIN( dataLen, from2Byte( *data ) + 2u );
+      return true;
+    }
+    else {
+      k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ DVD STRUCTURE with real length failed." << endl;
+      delete [] *data;
+    }
+  }
+  else
+    k3bDebug() << "(K3bDevice::Device) " << blockDeviceName() << ": READ DVD STRUCTURE length det failed" << endl;
+
+  return false;
+}
+
+
+int K3bDevice::Device::readBufferCapacity( long long& bufferLength, long long& bufferAvail ) const
+{
+  unsigned char data[12];
+  ::memset( data, 0, 12 );
+
+  ScsiCommand cmd( this );
+  cmd[0] = MMC_READ_BUFFER_CAPACITY;
+  cmd[8] = 12;
+  cmd[9] = 0;      // Necessary to set the proper command length
+  int r = cmd.transport( TR_DIR_READ, data, 12 );
+  if( r )
+    return r;
+
+  unsigned int dataLength = from2Byte( data );
+
+  if( dataLength >= 10 ) {
+    bufferLength = from4Byte( &data[4] );
+    bufferAvail = from4Byte( &data[8] );
+  }
+  else {
+    bufferAvail = bufferLength = 0;
+  }
+
+  return 0;
+}
diff --git a/libk3bdevice/k3bdeviceglobals.cpp b/libk3bdevice/k3bdeviceglobals.cpp
new file mode 100644
index 0000000..c778130
--- /dev/null
+++ b/libk3bdevice/k3bdeviceglobals.cpp
@@ -0,0 +1,247 @@
+/* 
+ *
+ * $Id: k3bdeviceglobals.cpp 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include "k3bdeviceglobals.h"
+#include "k3bdiskinfo.h"
+#include "k3bdevice.h"
+
+#include <klocale.h>
+#include <k3bdebug.h>
+
+#include <qstringlist.h>
+
+
+QString K3bDevice::deviceTypeString( int t )
+{
+  QStringList s;
+  if( t & K3bDevice::DEVICE_CD_R )
+    s += i18n("CD-R");
+  if( t & K3bDevice::DEVICE_CD_RW )
+    s += i18n("CD-RW");
+  if( t & K3bDevice::DEVICE_CD_ROM )
+    s += i18n("CD-ROM");
+  if( t & K3bDevice::DEVICE_DVD_ROM )
+    s += i18n("DVD-ROM");
+  if( t & K3bDevice::DEVICE_DVD_RAM )
+    s += i18n("DVD-RAM");
+  if( t & K3bDevice::DEVICE_DVD_R )
+    s += i18n("DVD-R");
+  if( t & K3bDevice::DEVICE_DVD_RW )
+    s += i18n("DVD-RW");
+  if( t & K3bDevice::DEVICE_DVD_R_DL )
+    s += i18n("DVD-R DL");
+  if( t & DEVICE_HD_DVD_ROM )
+    s += i18n("HD DVD-ROM");
+  if( t & DEVICE_HD_DVD_R )
+    s += i18n("HD DVD-R");
+  if( t & DEVICE_HD_DVD_RAM )
+    s += i18n("HD DVD-RAM");
+  if( t & DEVICE_BD_ROM )
+    s += i18n("BD-ROM");
+  if( t & DEVICE_BD_R )
+    s += i18n("BD-R");
+  if( t & DEVICE_BD_RE )
+    s += i18n("BD-RE");
+  if( t & K3bDevice::DEVICE_DVD_PLUS_R )
+    s += i18n("DVD+R");
+  if( t & K3bDevice::DEVICE_DVD_PLUS_RW )
+    s += i18n("DVD+RW");
+  if( t & K3bDevice::DEVICE_DVD_PLUS_R_DL )
+    s += i18n("DVD+R DL");
+
+  if( s.isEmpty() )
+    return i18n("Error");
+  else
+    return s.join( ", " );
+}
+
+
+QString K3bDevice::writingModeString( int m )
+{
+  QStringList s;
+  if( m & K3bDevice::WRITINGMODE_SAO )
+    s += i18n("SAO");
+  if( m & K3bDevice::WRITINGMODE_TAO )
+    s += i18n("TAO");
+  if( m & K3bDevice::WRITINGMODE_RAW )
+    s += i18n("RAW");
+  if( m & K3bDevice::WRITINGMODE_SAO_R96P )
+    s += i18n("SAO/R96P");
+  if( m & K3bDevice::WRITINGMODE_SAO_R96R )
+    s += i18n("SAO/R96R");
+  if( m & K3bDevice::WRITINGMODE_RAW_R16 )
+    s += i18n("RAW/R16");
+  if( m & K3bDevice::WRITINGMODE_RAW_R96P )
+    s += i18n("RAW/R96P");
+  if( m & K3bDevice::WRITINGMODE_RAW_R96R )
+    s += i18n("RAW/R96R");
+  if( m & K3bDevice::WRITINGMODE_INCR_SEQ )
+    s += i18n("Incremental Sequential");
+  if( m & K3bDevice::WRITINGMODE_RES_OVWR )
+    s += i18n("Restricted Overwrite");
+  if( m & K3bDevice::WRITINGMODE_LAYER_JUMP )
+    s += i18n("Layer Jump");
+
+  if( m & K3bDevice::WRITINGMODE_RRM )
+    s += i18n("Random Recording");
+  if( m & K3bDevice::WRITINGMODE_SRM )
+    s += i18n("Sequential Recording");
+  if( m & K3bDevice::WRITINGMODE_SRM_POW )
+    s += i18n("Sequential Recording + POW");
+
+  if( s.isEmpty() )
+    return i18n("None");
+  else
+    return s.join( ", " );
+}
+
+
+QString K3bDevice::mediaTypeString( int m, bool simple )
+{
+  if( m == K3bDevice::MEDIA_UNKNOWN )
+    return i18n("Unknown");
+
+  QStringList s;
+  if( m & MEDIA_NONE )
+    s += i18n("No media");
+  if( m & MEDIA_DVD_ROM )
+    s += i18n("DVD-ROM");
+  if( m & MEDIA_DVD_R || 
+      (simple && (m & MEDIA_DVD_R_SEQ)) )
+    s += i18n("DVD-R");
+  if( m & MEDIA_DVD_R_SEQ && !simple )
+    s += i18n("DVD-R Sequential");
+  if( m & MEDIA_DVD_R_DL ||
+      (simple && (m & (MEDIA_DVD_R_DL_SEQ|MEDIA_DVD_R_DL_JUMP))) )
+    s += i18n("DVD-R Dual Layer");
+  if( m & MEDIA_DVD_R_DL_SEQ && !simple )
+    s += i18n("DVD-R Dual Layer Sequential");
+  if( m & MEDIA_DVD_R_DL_JUMP && !simple )
+    s += i18n("DVD-R Dual Layer Jump");
+  if( m & MEDIA_DVD_RAM )
+    s += i18n("DVD-RAM");
+  if( m & MEDIA_DVD_RW ||
+      (simple && (m & (MEDIA_DVD_RW_OVWR|MEDIA_DVD_RW_SEQ))) )
+    s += i18n("DVD-RW");
+  if( m & MEDIA_DVD_RW_OVWR && !simple )
+    s += i18n("DVD-RW Restricted Overwrite");
+  if( m & MEDIA_DVD_RW_SEQ && !simple )
+    s += i18n("DVD-RW Sequential");
+  if( m & MEDIA_DVD_PLUS_RW )
+    s += i18n("DVD+RW");
+  if( m & MEDIA_DVD_PLUS_R )
+    s += i18n("DVD+R");
+  if( m & MEDIA_DVD_PLUS_RW_DL )
+    s += i18n("DVD+RW Dual Layer");
+  if( m & MEDIA_DVD_PLUS_R_DL )
+    s += i18n("DVD+R Dual Layer");
+  if( m & MEDIA_CD_ROM )
+    s += i18n("CD-ROM");
+  if( m & MEDIA_CD_R )
+    s += i18n("CD-R");
+  if( m & MEDIA_CD_RW )
+    s += i18n("CD-RW");
+  if( m & MEDIA_HD_DVD_ROM )
+    s += i18n("HD DVD-ROM");
+  if( m & MEDIA_HD_DVD_R )
+    s += i18n("HD DVD-R");
+  if( m & MEDIA_HD_DVD_RAM )
+    s += i18n("HD DVD-RAM");
+  if( m & MEDIA_BD_ROM )
+    s += i18n("BD-ROM");
+  if( m & MEDIA_BD_R ||
+      (simple && (m & (MEDIA_BD_R_SRM|MEDIA_BD_R_RRM))) )
+    s += i18n("BD-R");
+  if( m & MEDIA_BD_R_SRM && !simple )
+    s += i18n("BD-R Sequential (SRM)");
+  if( m & MEDIA_BD_R_SRM_POW && !simple )
+    s += i18n("BD-R Sequential Pseudo Overwrite (SRM+POW)");
+  if( m & MEDIA_BD_R_RRM && !simple )
+    s += i18n("BD-R Random (RRM)");
+  if( m & MEDIA_BD_RE )
+    s += i18n("BD-RE");
+
+  if( s.isEmpty() )
+    return i18n("Error");
+  else
+    return s.join( ", " );
+}
+
+
+void K3bDevice::debugBitfield( unsigned char* data, long len )
+{
+  for( int i = 0; i < len; ++i ) {
+    QString index, bitString;
+    index.sprintf( "%4i", i );
+    for( int bp = 7; bp >= 0; --bp )
+      bitString[7-bp] = ( data[i] & (1<<bp) ? '1' : '0' );
+    k3bDebug() << index << " - " << bitString << " - " << (int)data[i] << endl;
+  }
+}
+
+
+K3bDevice::uint16 K3bDevice::from2Byte( unsigned char* d )
+{
+  return ( d[0] << 8 & 0xFF00 |
+	   d[1]      & 0xFF );
+}
+
+
+K3bDevice::uint32 K3bDevice::from4Byte( unsigned char* d )
+{
+  return ( d[0] << 24 & 0xFF000000 |
+	   d[1] << 16 & 0xFF0000 |
+	   d[2] << 8  & 0xFF00 |
+	   d[3]       & 0xFF );
+}
+
+
+char K3bDevice::fromBcd( const char& i )
+{
+  return (i & 0x0f) + 10 * ( (i >> 4) & 0x0f );
+}
+
+
+char K3bDevice::toBcd( const char& i )
+{
+  return ( i % 10 ) | ( ( (( i / 10 ) % 10) << 4 ) & 0xf0 );
+}
+
+
+bool K3bDevice::isValidBcd( const char& i )
+{
+  return ( i & 0x0f ) <= 0x09 && ( i & 0xf0 ) <= 0x90;
+}
+
+
+int K3bDevice::determineMaxReadingBufferSize( K3bDevice::Device* dev, const K3b::Msf& firstSector )
+{
+  //
+  // As long as we do not know how to determine the max read buffer properly we simply determine it
+  // by trying. :)
+  //
+
+  int bufferSizeSectors = 128;
+  unsigned char buffer[2048*128];
+  while( !dev->read10( buffer, 2048*bufferSizeSectors, firstSector.lba(), bufferSizeSectors ) ) {
+    k3bDebug() << "(K3bDataTrackReader) determine max read sectors: "
+	      << bufferSizeSectors << " too high." << endl;
+    bufferSizeSectors--;
+  }
+  k3bDebug() << "(K3bDataTrackReader) determine max read sectors: " 
+	    << bufferSizeSectors << " is max." << endl;
+
+  return bufferSizeSectors;
+}
diff --git a/libk3bdevice/k3bdeviceglobals.h b/libk3bdevice/k3bdeviceglobals.h
new file mode 100644
index 0000000..5e167ad
--- /dev/null
+++ b/libk3bdevice/k3bdeviceglobals.h
@@ -0,0 +1,54 @@
+/* 
+ *
+ * $Id: k3bdeviceglobals.h 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#ifndef _K3B_DEVICE_GLOBALS_H_
+#define _K3B_DEVICE_GLOBALS_H_
+
+#include <qstring.h>
+#include <k3bmsf.h>
+#include "k3bdevice_export.h"
+
+namespace K3bDevice 
+{
+  typedef Q_UINT8 uint8;
+  typedef Q_UINT16 uint16;
+  typedef Q_UINT32 uint32;
+
+  class Device;
+
+  LIBK3BDEVICE_EXPORT QString deviceTypeString( int );
+  LIBK3BDEVICE_EXPORT QString writingModeString( int );
+  /**
+   * @param simplyfied if true the formatting state of DVD media is left out.
+   */
+  LIBK3BDEVICE_EXPORT QString mediaTypeString( int, bool simplyfied = false );
+  LIBK3BDEVICE_EXPORT void debugBitfield( unsigned char* data, long len );
+
+  LIBK3BDEVICE_EXPORT uint16 from2Byte( unsigned char* );
+  LIBK3BDEVICE_EXPORT uint32 from4Byte( unsigned char* );
+  
+  LIBK3BDEVICE_EXPORT char fromBcd( const char& );
+  LIBK3BDEVICE_EXPORT char toBcd( const char& );
+  LIBK3BDEVICE_EXPORT bool isValidBcd( const char& );
+
+  /**
+   * @return the maximum nuber of sectors that can be read from device @p dev starting
+   * at sector @p firstSector.
+   */
+  int determineMaxReadingBufferSize( Device* dev, const K3b::Msf& firstSector );
+}
+
+#endif
diff --git a/libk3bdevice/k3bdevicemanager.cpp b/libk3bdevice/k3bdevicemanager.cpp
new file mode 100644
index 0000000..b7c04d0
--- /dev/null
+++ b/libk3bdevice/k3bdevicemanager.cpp
@@ -0,0 +1,903 @@
+/*
+ *
+ * $Id: k3bdevicemanager.cpp 676188 2007-06-16 08:55:00Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include <config.h>
+
+#include "k3bdevicemanager.h"
+#include "k3bdevice.h"
+#include "k3bdeviceglobals.h"
+#include "k3bscsicommand.h"
+#include "k3bmmc.h"
+#include "k3bdebug.h"
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qptrlist.h>
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qregexp.h>
+
+#include <kprocess.h>
+#include <kapplication.h>
+#include <kconfig.h>
+#include <ktempfile.h>
+
+#include <iostream>
+#include <limits.h>
+#include <assert.h>
+
+#ifdef Q_OS_FREEBSD
+#include <sys/param.h>
+#include <sys/ucred.h>
+#include <osreldate.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+
+#ifdef HAVE_RESMGR
+#include <resmgr.h>
+#endif
+
+#ifdef Q_OS_LINUX
+
+/* Fix definitions for 2.5 kernels */
+#include <linux/version.h>
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,70)
+typedef unsigned char u8;
+#endif
+
+#undef __STRICT_ANSI__
+#include <asm/types.h>
+#define __STRICT_ANSI__
+
+#include <scsi/scsi.h>
+#include <linux/major.h>
+
+
+#ifndef SCSI_DISK_MAJOR
+#define SCSI_DISK_MAJOR(M) ((M) == SCSI_DISK0_MAJOR || \
+  ((M) >= SCSI_DISK1_MAJOR && (M) <= SCSI_DISK7_MAJOR) || \
+  ((M) >= SCSI_DISK8_MAJOR && (M) <= SCSI_DISK15_MAJOR))
+#endif
+
+#ifndef SCSI_BLK_MAJOR
+#define SCSI_BLK_MAJOR(M) \
+  (SCSI_DISK_MAJOR(M)   \
+   || (M) == SCSI_CDROM_MAJOR)
+#endif
+
+#ifndef SCSI_GENERIC_MAJOR
+#define SCSI_GENERIC_MAJOR 21
+#endif
+
+#endif // Q_OS_LINUX
+
+
+#ifdef Q_OS_FREEBSD
+#include <cam/cam.h>
+#include <cam/scsi/scsi_pass.h>
+#include <camlib.h>
+#endif
+
+#ifdef Q_OS_NETBSD
+#include <sys/scsiio.h>
+#endif
+
+
+
+class K3bDevice::DeviceManager::Private
+{
+public:
+  QPtrList<K3bDevice::Device> allDevices;
+  QPtrList<K3bDevice::Device> cdReader;
+  QPtrList<K3bDevice::Device> cdWriter;
+  QPtrList<K3bDevice::Device> dvdReader;
+  QPtrList<K3bDevice::Device> dvdWriter;
+  QPtrList<K3bDevice::Device> bdReader;
+  QPtrList<K3bDevice::Device> bdWriter;
+
+  bool checkWritingModes;
+};
+
+
+
+K3bDevice::DeviceManager::DeviceManager( QObject* parent, const char* name )
+  : QObject( parent, name )
+{
+  d = new Private;
+}
+
+
+K3bDevice::DeviceManager::~DeviceManager()
+{
+  d->allDevices.setAutoDelete( true );
+  delete d;
+}
+
+
+void K3bDevice::DeviceManager::setCheckWritingModes( bool b )
+{
+  d->checkWritingModes = b;
+}
+
+
+K3bDevice::Device* K3bDevice::DeviceManager::deviceByName( const QString& name )
+{
+  return findDevice( name );
+}
+
+
+K3bDevice::Device* K3bDevice::DeviceManager::findDevice( int bus, int id, int lun )
+{
+  QPtrListIterator<K3bDevice::Device> it( d->allDevices );
+  while( it.current() )
+  {
+    if( it.current()->scsiBus() == bus &&
+        it.current()->scsiId() == id &&
+        it.current()->scsiLun() == lun )
+      return it.current();
+
+    ++it;
+  }
+
+  return 0;
+}
+
+
+K3bDevice::Device* K3bDevice::DeviceManager::findDevice( const QString& devicename )
+{
+  if( devicename.isEmpty() ) {
+    k3bDebug() << "(K3bDevice::DeviceManager) request for empty device!" << endl;
+    return 0;
+  }
+  QPtrListIterator<K3bDevice::Device> it( d->allDevices );
+  while( it.current() ) {
+    if( it.current()->deviceNodes().contains(devicename) )
+      return it.current();
+
+    ++it;
+  }
+
+  return 0;
+}
+
+
+const QPtrList<K3bDevice::Device>& K3bDevice::DeviceManager::cdWriter() const
+{
+  return d->cdWriter;
+}
+
+const QPtrList<K3bDevice::Device>& K3bDevice::DeviceManager::cdReader() const
+{
+  return d->cdReader;
+}
+
+const QPtrList<K3bDevice::Device>& K3bDevice::DeviceManager::dvdWriter() const
+{
+  return d->dvdWriter;
+}
+
+const QPtrList<K3bDevice::Device>& K3bDevice::DeviceManager::dvdReader() const
+{
+  return d->dvdReader;
+}
+
+const QPtrList<K3bDevice::Device>& K3bDevice::DeviceManager::blueRayReader() const
+{
+  return d->bdReader;
+}
+
+const QPtrList<K3bDevice::Device>& K3bDevice::DeviceManager::blueRayWriters() const
+{
+  return d->bdWriter;
+}
+
+const QPtrList<K3bDevice::Device>& K3bDevice::DeviceManager::burningDevices() const
+{
+  return cdWriter();
+}
+
+
+const QPtrList<K3bDevice::Device>& K3bDevice::DeviceManager::readingDevices() const
+{
+  return cdReader();
+}
+
+
+const QPtrList<K3bDevice::Device>& K3bDevice::DeviceManager::allDevices() const
+{
+  return d->allDevices;
+}
+
+
+int K3bDevice::DeviceManager::scanBus()
+{
+  unsigned int numDevs = d->allDevices.count();
+
+#ifdef Q_OS_LINUX
+  LinuxDeviceScan();
+#endif
+#ifdef Q_OS_FREEBSD
+  BSDDeviceScan();
+#endif
+#ifdef Q_OS_NETBSD
+  NetBSDDeviceScan();
+#endif
+
+  return d->allDevices.count() - numDevs;
+}
+
+
+void K3bDevice::DeviceManager::LinuxDeviceScan()
+{
+#ifdef HAVE_RESMGR
+  //
+  // Resmgr device scan
+  //
+  char** resmgrDevices = rsm_list_devices( 0 );
+  if( resmgrDevices ) {
+    for( int i = 0; resmgrDevices[i]; ++i ) {
+      addDevice( resmgrDevices[i] );
+      free( resmgrDevices[i] );
+    }
+
+    free( resmgrDevices );
+  }
+#endif
+
+  QFile info("/proc/sys/dev/cdrom/info");
+  QString line,devstring;
+  if( info.open(IO_ReadOnly) ) {
+    info.readLine(line,80); // CD-ROM information, Id: cdrom.c 3.12 2000/10/18
+    info.readLine(line,80); //
+
+    QRegExp re("[\t\n:]+");
+    while( info.readLine( line, 80 ) > 0 ) {
+      if( line.contains("drive name") > 0 ) {
+	int i = 1;
+	QString dev;
+	while( !(dev = line.section(re, i, i)).isEmpty() ) {
+	  if( addDevice( QString("/dev/%1").arg(dev) ) ) {
+	    devstring += dev + "|";
+	  }
+	  // according to the LINUX ALLOCATED DEVICES document (http://www.lanana.org/docs/device-list/),
+	  // the official device names for SCSI-CDROM's (block major 11) are /dev/sr*, the
+	  // prefix /dev/scd instead of /dev/sr has been used as well, and might make more sense.
+	  // Since there should be one and only one device node (and maybe several symbolic links) for
+	  // each physical device the next line should be better
+	  //      else if ( dev.startsWith("sr") )
+	  if ( dev.startsWith("sr") ) {
+	    if( addDevice(QString("/dev/%1").arg(dev.replace(QRegExp("r"),"cd"))) )
+	      devstring += dev + "|";
+	  }
+	  ++i;
+	}
+      }
+      break;
+    }
+    info.close();
+  }
+  else {
+    kdError() << "(K3bDevice::DeviceManager) could not open /proc/sys/dev/cdrom/info" << endl;
+  }
+
+  //
+  // Scan the generic devices if we have scsi devices
+  //
+  k3bDebug() << "(K3bDevice::DeviceManager) SCANNING FOR GENERIC DEVICES." << endl;
+  for( int i = 0; i < 16; i++ ) {
+    QString sgDev = resolveSymLink( QString("/dev/sg%1").arg(i) );
+    int bus = -1, id = -1, lun = -1;
+    if( determineBusIdLun( sgDev, bus, id, lun ) ) {
+      if( Device* dev = findDevice( bus, id, lun ) ) {
+	dev->m_genericDevice = sgDev;
+      }
+    }
+  }
+  // FIXME: also scan /dev/scsi/hostX.... for devfs without symlinks
+}
+
+
+void K3bDevice::DeviceManager::NetBSDDeviceScan()
+{
+  // Generate entries for /dev/cd* devices
+  // Note: As there are only 10 possible /dev/(r)cd devices,
+  // only these will be found.
+
+  int   i;
+
+  // Whole disk mask (According to cd(4), the AMD64, i386 and BeBox ports use
+  // 'd' as whole-disk partition, the rest uses 'c'.)
+
+#if defined(__i386__) || defined (__amd64__) || defined (__bebox__)
+  static const char slicename = 'd';
+#else
+  static const char slicename = 'c';
+#endif
+
+  char devicename[11]; // /dev/rcdXd + trailing zero
+
+  for (i = 0; i < 10; i++ ) // cd(4) claims there are max. 10 CD devices.
+  {
+    snprintf(devicename,11,"/dev/rcd%d%c",i, slicename);
+    addDevice(QString(devicename));
+  }
+}
+
+
+void K3bDevice::DeviceManager::BSDDeviceScan()
+{
+  // Unfortunately uses lots of FBSD-specific data structures
+#ifndef Q_OS_FREEBSD
+  // bool bsdspecificcode = false;
+  // assert(bsdspecificcode);
+#endif
+
+#ifdef Q_OS_FREEBSD
+  union ccb ccb;
+  int fd;
+  int need_close = 0;
+  int skip_device = 0;
+  int bus, target, lun;
+  QString dev1, dev2;
+
+  if ((fd = open(XPT_DEVICE, O_RDWR)) == -1)
+    {
+      k3bDebug() << "couldn't open %s " << XPT_DEVICE << endl;
+      return;
+    }
+
+  memset(&ccb, 0, sizeof(ccb));
+
+  ccb.ccb_h.func_code = XPT_DEV_MATCH;
+  char buffer[100*sizeof(struct dev_match_result)];
+  ccb.cdm.match_buf_len = 100*sizeof(struct dev_match_result);
+  ccb.cdm.matches = (struct dev_match_result *)buffer;
+  ccb.cdm.num_matches = 0;
+  ccb.cdm.num_patterns = 0;
+  ccb.cdm.pattern_buf_len = 0;
+  do {
+    if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
+      k3bDebug() << "(BSDDeviceScan) error sending CAMIOCOMMAND ioctl: " << errno << endl;
+      break;
+    }
+
+    if ((ccb.ccb_h.status != CAM_REQ_CMP)
+	|| ((ccb.cdm.status != CAM_DEV_MATCH_LAST) && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
+      k3bDebug() << "(BSDDeviceScan) got CAM error " << ccb.ccb_h.status << ", CDM error %d" << ccb.cdm.status << endl;
+      break;
+    }
+    k3bDebug() << "(BSDDeviceScan) number of matches " << (int)ccb.cdm.num_matches << endl;
+    for (int i = 0; i < (int)ccb.cdm.num_matches; i++) {
+      switch (ccb.cdm.matches[i].type) {
+      case DEV_MATCH_DEVICE: {
+	struct device_match_result *dev_result = &ccb.cdm.matches[i].result.device_result;
+
+	if (dev_result->flags & DEV_RESULT_UNCONFIGURED)
+	  {
+	    skip_device = 1;
+	    break;
+	  }
+	else
+	  skip_device = 0;
+	if (need_close)
+	  {
+	    QString pass = dev1;
+	    QString dev = "/dev/" + dev2;
+	    if (dev2.startsWith("pass"))
+	      {
+		pass = dev2;
+		dev = "/dev/" + dev1;
+	      }
+#if __FreeBSD_version < 500100
+	    dev += "c";
+#endif
+	    if (!dev1.isEmpty() && !dev2.isEmpty() && dev.startsWith("/dev/cd"))
+	    {
+	      Device* device = new Device(dev.latin1());
+	      device->m_bus = bus;
+	      device->m_target = target;
+	      device->m_lun = lun;
+	      device->m_passDevice = "/dev/" + pass;
+	      k3bDebug() << "(BSDDeviceScan) add device " << dev << ":" << bus << ":" << target << ":" << lun << endl;
+	      addDevice(device);
+	    }
+	    need_close = 0;
+	    dev1="";
+	    dev2="";
+	  }
+	bus = dev_result->path_id;
+	target = dev_result->target_id;
+	lun = dev_result->target_lun;
+
+	need_close = 1;
+
+	break;
+      }
+      case DEV_MATCH_PERIPH: {
+	struct periph_match_result *periph_result = &ccb.cdm.matches[i].result.periph_result;
+
+	if (skip_device != 0)
+	  break;
+
+	if (need_close > 1)
+	  dev1 = periph_result->periph_name + QString::number(periph_result->unit_number);
+	else
+	  dev2 = periph_result->periph_name + QString::number(periph_result->unit_number);
+
+	need_close++;
+	break;
+      }
+      case DEV_MATCH_BUS : {
+	// bool cannotmatchbus = false;
+	// assert(cannotmatchbus);
+	break;
+      }
+      }
+    }
+
+  } while ((ccb.ccb_h.status == CAM_REQ_CMP)
+	   && (ccb.cdm.status == CAM_DEV_MATCH_MORE));
+
+  if (need_close)
+    {
+      QString pass = dev1;
+      QString dev = "/dev/" + dev2;
+      if (dev2.startsWith("pass"))
+	{
+	  pass = dev2;
+	  dev = "/dev/" + dev1;
+	}
+#if __FreeBSD_version < 500100
+      dev += "c";
+#endif
+      if (!dev1.isEmpty() && !dev2.isEmpty() && dev.startsWith("/dev/cd"))
+      {
+        Device* device = new Device(dev.latin1());
+        device->m_bus = bus;
+        device->m_target = target;
+        device->m_lun = lun;
+        device->m_passDevice = "/dev/" + pass;
+        k3bDebug() << "(BSDDeviceScan) add device " << dev << ":" << bus << ":" << target << ":" << lun << endl;
+        addDevice(device);
+      }
+    }
+  close(fd);
+#endif
+}
+
+
+void K3bDevice::DeviceManager::printDevices()
+{
+  k3bDebug() << "Devices:" << endl
+	    << "------------------------------" << endl;
+  QPtrListIterator<Device> it( allDevices() );
+  for( ; *it; ++it ) {
+    Device* dev = *it;
+    k3bDebug() << "Blockdevice:    " << dev->blockDeviceName() << endl
+	      << "Generic device: " << dev->genericDevice() << endl
+	      << "Vendor:         " << dev->vendor() << endl
+	      << "Description:    " << dev->description() << endl
+	      << "Version:        " << dev->version() << endl
+	      << "Write speed:    " << dev->maxWriteSpeed() << endl
+	      << "Profiles:       " << mediaTypeString( dev->supportedProfiles() ) << endl
+	      << "Read Cap:       " << mediaTypeString( dev->readCapabilities() ) << endl
+	      << "Write Cap:      " << mediaTypeString( dev->writeCapabilities() ) << endl
+	      << "Writing modes:  " << writingModeString( dev->writingModes() ) << endl
+	      << "Reader aliases: " << dev->deviceNodes().join(", ") << endl
+	      << "------------------------------" << endl;
+  }
+}
+
+
+void K3bDevice::DeviceManager::clear()
+{
+  // clear current devices
+  d->cdReader.clear();
+  d->cdWriter.clear();
+  d->dvdReader.clear();
+  d->dvdWriter.clear();
+  d->bdReader.clear();
+  d->bdWriter.clear();
+
+  // to make sure no one crashes lets keep the devices around until the changed
+  // signals return
+  QPtrList<K3bDevice::Device> tmp = d->allDevices;
+  tmp.setAutoDelete( true );
+
+  d->allDevices.clear();
+
+  emit changed( this );
+  emit changed();
+}
+
+
+bool K3bDevice::DeviceManager::readConfig( KConfig* c )
+{
+  //
+  // New configuration format since K3b 0.11.94
+  // for details see saveConfig()
+  //
+
+  if( !c->hasGroup( "Devices" ) )
+    return false;
+
+  c->setGroup( "Devices" );
+
+  QStringList deviceSearchPath = c->readListEntry( "device_search_path" );
+  for( QStringList::const_iterator it = deviceSearchPath.constBegin();
+       it != deviceSearchPath.constEnd(); ++it )
+    addDevice( *it );
+
+  //
+  // Iterate over all devices and check if we have a config entry
+  //
+  for( QPtrListIterator<K3bDevice::Device> it( d->allDevices ); *it; ++it ) {
+    K3bDevice::Device* dev = *it;
+
+    QString configEntryName = dev->vendor() + " " + dev->description();
+    QStringList list = c->readListEntry( configEntryName );
+    if( !list.isEmpty() ) {
+      k3bDebug() << "(K3bDevice::DeviceManager) found config entry for devicetype: " << configEntryName << endl;
+
+      dev->setMaxReadSpeed( list[0].toInt() );
+      if( list.count() > 1 )
+	dev->setMaxWriteSpeed( list[1].toInt() );
+      if( list.count() > 2 )
+	dev->setCdrdaoDriver( list[2] );
+      if( list.count() > 3 )
+	dev->setCdTextCapability( list[3] == "yes" );
+    }
+  }
+
+  return true;
+}
+
+
+bool K3bDevice::DeviceManager::saveConfig( KConfig* c )
+{
+  //
+  // New configuration format since K3b 0.11.94
+  //
+  // We save a device search path which contains all device nodes
+  // where devices could be found including the old search path.
+  // This way also for example a manually added USB device will be
+  // found between sessions.
+  // Then we do not save the device settings (writing speed, cdrdao driver)
+  // for every single device but for every device type.
+  // This also makes sure device settings are kept between sessions
+  //
+
+  c->setGroup( "Devices" );
+  QStringList deviceSearchPath = c->readListEntry( "device_search_path" );
+  // remove duplicate entries (caused by buggy old implementations)
+  QStringList saveDeviceSearchPath;
+  for( QStringList::const_iterator it = deviceSearchPath.constBegin(); it != deviceSearchPath.constEnd(); ++it )
+    if( !saveDeviceSearchPath.contains( *it ) )
+      saveDeviceSearchPath.append( *it );
+
+  for( QPtrListIterator<K3bDevice::Device> it( d->allDevices ); *it; ++it ) {
+    K3bDevice::Device* dev = *it;
+
+    // update device search path
+    if( !saveDeviceSearchPath.contains( dev->blockDeviceName() ) )
+      saveDeviceSearchPath.append( dev->blockDeviceName() );
+
+    // save the device type settings
+    QString configEntryName = dev->vendor() + " " + dev->description();
+    QStringList list;
+    list << QString::number(dev->maxReadSpeed())
+	 << QString::number(dev->maxWriteSpeed())
+	 << dev->cdrdaoDriver();
+
+    if( dev->cdrdaoDriver() != "auto" )
+      list << ( dev->cdTextCapable() == 1 ? "yes" : "no" );
+    else
+      list << "auto";
+
+    c->writeEntry( configEntryName, list );
+  }
+
+  c->writeEntry( "device_search_path", saveDeviceSearchPath );
+
+  c->sync();
+
+  return true;
+}
+
+
+bool K3bDevice::DeviceManager::testForCdrom( const QString& devicename )
+{
+#ifdef Q_OS_FREEBSD
+  Q_UNUSED(devicename);
+  return true;
+#endif
+#if defined(Q_OS_LINUX) || defined(Q_OS_NETBSD)
+  bool ret = false;
+  int cdromfd = K3bDevice::openDevice( devicename.ascii() );
+  if (cdromfd < 0) {
+    k3bDebug() << "could not open device " << devicename << " (" << strerror(errno) << ")" << endl;
+    return ret;
+  }
+
+  // stat the device
+  struct stat cdromStat;
+  if( ::fstat( cdromfd, &cdromStat ) )
+    return false;
+
+  if( !S_ISBLK( cdromStat.st_mode) ) {
+    k3bDebug() << devicename << " is no block device" << endl;
+  }
+  else {
+    k3bDebug() << devicename << " is block device (" << (int)(cdromStat.st_rdev & 0xFF) << ")" << endl;
+#if defined(Q_OS_NETBSD)
+  }
+  {
+#endif
+    // inquiry
+    // use a 36 bytes buffer since not all devices return the full inquiry struct
+    unsigned char buf[36];
+    struct inquiry* inq = (struct inquiry*)buf;
+    ::memset( buf, 0, sizeof(buf) );
+
+    ScsiCommand cmd( cdromfd );
+    cmd[0] = MMC_INQUIRY;
+    cmd[4] = sizeof(buf);
+    cmd[5] = 0;
+
+    if( cmd.transport( TR_DIR_READ, buf, sizeof(buf) ) ) {
+      k3bDebug() << "(K3bDevice::Device) Unable to do inquiry. " << devicename << " is not a cdrom device" << endl;
+    }
+    else if( (inq->p_device_type&0x1f) != 0x5 ) {
+      k3bDebug() << devicename << " seems not to be a cdrom device: " << strerror(errno) << endl;
+    }
+    else {
+      ret = true;
+      k3bDebug() << devicename << " seems to be cdrom" << endl;
+    }
+  }
+
+  ::close( cdromfd );
+  return ret;
+#endif
+}
+
+K3bDevice::Device* K3bDevice::DeviceManager::addDevice( const QString& devicename )
+{
+#ifdef Q_OS_FREEBSD
+  return 0;
+#endif
+
+  K3bDevice::Device* device = 0;
+
+  // resolve all symlinks
+  QString resolved = resolveSymLink( devicename );
+  k3bDebug() << devicename << " resolved to " << resolved << endl;
+
+  if ( K3bDevice::Device* oldDev = findDevice(resolved) ) {
+    k3bDebug() << "(K3bDevice::DeviceManager) dev " << resolved  << " already found" << endl;
+    oldDev->addDeviceNode( devicename );
+    return 0;
+  }
+
+  if( !testForCdrom(resolved) ) {
+#ifdef HAVE_RESMGR
+    // With resmgr we might only be able to open the symlink name.
+    if( testForCdrom(devicename) ) {
+      resolved = devicename;
+    }
+    else {
+      return 0;
+    }
+#else
+    return 0;
+#endif
+  }
+
+  int bus = -1, target = -1, lun = -1;
+  bool scsi = determineBusIdLun( resolved, bus, target, lun );
+  if(scsi) {
+    if ( K3bDevice::Device* oldDev = findDevice(bus, target, lun) ) {
+      k3bDebug() << "(K3bDevice::DeviceManager) dev " << resolved  << " already found" << endl;
+      oldDev->addDeviceNode( devicename );
+      return 0;
+    }
+  }
+
+  device = new K3bDevice::Device(resolved);
+  if( scsi ) {
+    device->m_bus = bus;
+    device->m_target = target;
+    device->m_lun = lun;
+  }
+
+  return addDevice(device);
+}
+
+
+K3bDevice::Device* K3bDevice::DeviceManager::addDevice( K3bDevice::Device* device )
+{
+  const QString devicename = device->devicename();
+
+  if( !device->init() ) {
+    k3bDebug() << "Could not initialize device " << devicename << endl;
+    delete device;
+    return 0;
+  }
+
+  if( device ) {
+    d->allDevices.append( device );
+
+    // not every drive is able to read CDs
+    // there are some 1st generation DVD writer that cannot
+    if( device->type() & K3bDevice::DEVICE_CD_ROM )
+      d->cdReader.append( device );
+    if( device->readsDvd() )
+      d->dvdReader.append( device );
+    if( device->writesCd() )
+      d->cdWriter.append( device );
+    if( device->writesDvd() )
+      d->dvdWriter.append( device );
+    if( device->readCapabilities() & MEDIA_BD_ALL )
+      d->bdReader.append( device );
+    if( device->writeCapabilities() & MEDIA_BD_ALL )
+      d->bdWriter.append( device );
+
+    if( device->writesCd() ) {
+      // default to max write speed
+      k3bDebug() << "(K3bDevice::DeviceManager) setting current write speed of device "
+		<< device->blockDeviceName()
+		<< " to " << device->maxWriteSpeed() << endl;
+      device->setCurrentWriteSpeed( device->maxWriteSpeed() );
+    }
+
+    emit changed( this );
+    emit changed();
+  }
+
+  return device;
+}
+
+
+void K3bDevice::DeviceManager::removeDevice( const QString& dev )
+{
+  if( Device* device = findDevice( dev ) ) {
+    d->cdReader.removeRef( device );
+    d->dvdReader.removeRef( device );
+    d->bdReader.removeRef( device );
+    d->cdWriter.removeRef( device );
+    d->dvdWriter.removeRef( device );
+    d->bdWriter.removeRef( device );
+    d->allDevices.removeRef( device );
+
+    emit changed( this );
+    emit changed();
+
+    delete device;
+  }
+}
+
+
+bool K3bDevice::DeviceManager::determineBusIdLun( const QString& dev, int& bus, int& id, int& lun )
+{
+#ifdef Q_OS_FREEBSD
+  Q_UNUSED(dev);
+  Q_UNUSED(bus);
+  Q_UNUSED(id);
+  Q_UNUSED(lun);
+  return false;
+  /* NOTREACHED */
+#endif
+
+#ifdef Q_OS_NETBSD
+  int cdromfd = K3bDevice::openDevice ( dev.ascii() );
+  if (cdromfd < 0) {
+    int local_errno = errno; // For all we know, k3bDebug() destroys errno
+    k3bDebug() << "could not open device " << dev << " (" << strerror(local_errno) << ")" << endl;
+    return false;
+  }
+
+  struct scsi_addr my_addr;
+
+  if (::ioctl(cdromfd, SCIOCIDENTIFY, &my_addr))
+  {
+    int local_errno = errno; // For all we know, k3bDebug() destroys errno
+    k3bDebug() << "ioctl(SCIOCIDENTIFY) failed on device " << dev << " (" << strerror(local_errno) << ")" << endl;
+
+    ::close(cdromfd);
+    return false;
+  }
+
+  if (my_addr.type == TYPE_ATAPI)
+  {
+    // XXX Re-map atapibus, so it doesn't conflict with "real" scsi
+    // busses
+
+    bus = 15;
+    id  = my_addr.addr.atapi.drive + 2 * my_addr.addr.atapi.atbus;
+    lun = 0;
+  }
+  else
+  {
+    bus = my_addr.addr.scsi.scbus;
+    id  = my_addr.addr.scsi.target;
+    lun = my_addr.addr.scsi.lun;
+  }
+
+  ::close(cdromfd);
+
+  return true;
+#endif
+
+#ifdef Q_OS_LINUX
+  int ret = false;
+  int cdromfd = K3bDevice::openDevice( dev.ascii() );
+  if (cdromfd < 0) {
+    return false;
+  }
+
+  struct stat cdromStat;
+  if ( ::fstat( cdromfd, &cdromStat ) )
+      return false;
+
+  if( SCSI_BLK_MAJOR( cdromStat.st_rdev>>8 ) ||
+      SCSI_GENERIC_MAJOR == (cdromStat.st_rdev>>8) ) {
+    struct ScsiIdLun
+    {
+      int id;
+      int lun;
+    };
+    ScsiIdLun idLun;
+
+    // in kernel 2.2 SCSI_IOCTL_GET_IDLUN does not contain the bus id
+    if ( (::ioctl( cdromfd, SCSI_IOCTL_GET_IDLUN, &idLun ) < 0) ||
+         (::ioctl( cdromfd, SCSI_IOCTL_GET_BUS_NUMBER, &bus ) < 0) ) {
+      k3bDebug() << "Need a filename that resolves to a SCSI device" << endl;
+      ret = false;
+    }
+    else {
+      id  = idLun.id & 0xff;
+      lun = (idLun.id >> 8) & 0xff;
+      k3bDebug() << "bus: " << bus << ", id: " << id << ", lun: " << lun << endl;
+      ret = true;
+    }
+  }
+
+  ::close(cdromfd);
+  return ret;
+#endif
+}
+
+
+QString K3bDevice::DeviceManager::resolveSymLink( const QString& path )
+{
+  char resolved[PATH_MAX];
+  if( !realpath( QFile::encodeName(path), resolved ) )
+  {
+    k3bDebug() << "Could not resolve " << path << endl;
+    return path;
+  }
+
+  return QString::fromLatin1( resolved );
+}
+
+
+#include "k3bdevicemanager.moc"
diff --git a/libk3bdevice/k3bdevicemanager.h b/libk3bdevice/k3bdevicemanager.h
new file mode 100644
index 0000000..4656538
--- /dev/null
+++ b/libk3bdevice/k3bdevicemanager.h
@@ -0,0 +1,247 @@
+/*
+ *
+ * $Id: k3bdevicemanager.h 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#ifndef K3BDEVICEMANAGER_H
+#define K3BDEVICEMANAGER_H
+
+#include <qobject.h>
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qmemarray.h>
+#include <qptrlist.h>
+
+#include "k3bdevice_export.h"
+#include <kdebug.h>
+
+class KProcess;
+class KConfig;
+class K3bExternalBin;
+
+
+namespace K3bDevice {
+
+  class Device;
+
+  /**
+   * \brief Manages all devices.
+   *
+   * Searches the system for devices and maintains lists of them.
+   *
+   * <b>Basic usage:</b>
+   * \code
+   *   K3bDevice::DeviceManager* manager = new K3bDevice::DeviceManager( this );
+   *   manager->scanBus();
+   *   K3bDevice::Device* dev = manager->findDevice( "/dev/cdrom" );
+   * \endcode
+   */
+  class LIBK3BDEVICE_EXPORT DeviceManager : public QObject
+    {
+      Q_OBJECT
+
+    public:
+      /**
+       * Creates a new DeviceManager
+       */
+      DeviceManager( QObject* parent = 0, const char* name = 0 );
+      virtual ~DeviceManager();
+
+      /**
+       * By default the DeviceManager makes the Devices check their writing modes.
+       * This includes commands to be sent which require writing permissions on the
+       * devices and might take some time.
+       *
+       * So if you don't need the information about the writing modes use this method
+       * to speed up the device detection procedure.
+       *
+       * Be aware that this only refers to CD writing modes. If you only want to handle
+       * DVD devices it's always save to set this to false.
+       */
+      void setCheckWritingModes( bool b );
+
+      /**
+       * \deprecated use findDevice( const QString& )
+       */
+      Device* deviceByName( const QString& );
+
+      /**
+       * Search an SCSI device by SCSI bus, id, and lun.
+       *
+       * \note This method does not initialize new devices.
+       *       Devices cannot be found until they have been added via addDevice(const QString&)
+       *       or scanBus().
+       *
+       * \return The corresponding device or 0 if there is no such device.
+       */
+      Device* findDevice( int bus, int id, int lun );
+
+      /**
+       * Search a device by blockdevice name.
+       *
+       * \note This method does not initialize new devices.
+       *       Devices cannot be found until they have been added via addDevice(const QString&)
+       *       or scanBus().
+       *
+       * \return The corresponding device or 0 if there is no such device.
+       */
+      Device* findDevice( const QString& devicename );
+
+      /**
+       * Before getting the devices do a @ref scanBus().
+       * \return List of all cd writer devices.
+       * \deprecated use cdWriter()
+       */
+      const QPtrList<Device>& burningDevices() const;
+
+      /**
+       * \return List of all reader devices without writer devices.
+       * \deprecated use cdReader()
+       **/
+      const QPtrList<Device>& readingDevices() const;
+
+      /**
+       * Before getting the devices do a @ref scanBus() or add 
+       * devices via addDevice( const QString& ).
+       *
+       * \return List of all devices.
+       */
+      const QPtrList<Device>& allDevices() const;
+
+      /**
+       * Before getting the devices do a @ref scanBus() or add 
+       * devices via addDevice( const QString& ).
+       *
+       * \return List of all cd writer devices.
+       */
+      const QPtrList<Device>& cdWriter() const;
+
+      /**
+       * Before getting the devices do a @ref scanBus() or add 
+       * devices via addDevice( const QString& ).
+       *
+       * \return List of all cd reader devices.
+       */
+      const QPtrList<Device>& cdReader() const;
+
+      /**
+       * Before getting the devices do a @ref scanBus() or add 
+       * devices via addDevice( const QString& ).
+       *
+       * \return List of all DVD writer devices.
+       */
+      const QPtrList<Device>& dvdWriter() const;
+
+      /**
+       * Before getting the devices do a @ref scanBus() or add 
+       * devices via addDevice( const QString& ).
+       *
+       * \return List of all DVD reader devices.
+       */
+      const QPtrList<Device>& dvdReader() const;
+
+      /**
+       * Before getting the devices do a @ref scanBus() or add 
+       * devices via addDevice( const QString& ).
+       *
+       * \return List of all Blue Ray reader devices.
+       */
+      const QPtrList<Device>& blueRayReader() const;
+
+      /**
+       * Before getting the devices do a @ref scanBus() or add 
+       * devices via addDevice( const QString& ).
+       *
+       * \return List of all Blue Ray writer devices.
+       */
+      const QPtrList<Device>& blueRayWriters() const;
+
+      /**
+       * Reads the device information from the config file.
+       */
+      virtual bool readConfig( KConfig* );
+
+      virtual bool saveConfig( KConfig* );
+
+
+    public slots:
+      /**
+       * Writes a list of all devices to stderr.
+       */
+      void printDevices();
+
+      /**
+       * Scan the system for devices. Call this to initialize all devices.
+       * 
+       * If the system uses the HAL device deamon it is possible to use
+       * HalConnection instead of calling this method.
+       *
+       * \return Number of found devices.
+       **/
+      virtual int scanBus();
+
+      /**
+       * Clears the writers and readers list of devices.
+       */
+      virtual void clear();
+
+      /**
+       * Add a new device.
+       *
+       * \param dev Name of a block device or link to a block device. If the 
+       *            corresponding device has already been detected it will simply
+       *            be returned. Otherwise if a device is found it will be initialized
+       *            and added to the internal lists (meaning it can be accessed through
+       *            emthods like cdReader()).
+       *
+       * Called by scanBus()
+       *
+       * \return The device if it could be found or 0 otherwise.
+       */
+      virtual Device* addDevice( const QString& dev );
+
+      /**
+       * Remove a device from the device manager. Basicly this method
+       * only makes sense in combination with the HalConnection. Connect
+       * it to the deviceRemoved signal.
+       */
+      virtual void removeDevice( const QString& dev );
+
+    signals:
+      /**
+       * Emitted if the device configuration changed, i.e. a device was added or removed.
+       */
+      void changed( K3bDevice::DeviceManager* );
+      void changed();
+
+    private:
+      bool testForCdrom( const QString& );
+      bool determineBusIdLun( const QString &dev, int& bus, int& id, int& lun );
+      QString resolveSymLink( const QString& path );
+
+      class Private;
+      Private* d;
+
+      /**
+       * Add a device to the managers device lists and initialize the device.
+       */
+      Device *addDevice( Device* );
+
+      void BSDDeviceScan();
+      void NetBSDDeviceScan();
+      void LinuxDeviceScan();
+    };
+}
+
+#endif
diff --git a/libk3bdevice/k3bdevicetypes.h b/libk3bdevice/k3bdevicetypes.h
new file mode 100644
index 0000000..feb9a4e
--- /dev/null
+++ b/libk3bdevice/k3bdevicetypes.h
@@ -0,0 +1,266 @@
+/*
+ *
+ * $Id: k3bdevicetypes.h 654649 2007-04-16 17:55:50Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#ifndef _K3B_DEVICE_TYPES_H_
+#define _K3B_DEVICE_TYPES_H_
+
+namespace K3bDevice {
+  const unsigned short FEATURE_PROFILE_LIST = 0x000;
+  const unsigned short FEATURE_CORE = 0x001;
+  const unsigned short FEATURE_MORPHING = 0x002;
+  const unsigned short FEATURE_REMOVABLE_MEDIA = 0x003;
+  const unsigned short FEATURE_WRITE_PROTECT = 0x004;
+  const unsigned short FEATURE_RANDOM_READABLE = 0x010;
+  const unsigned short FEATURE_MULTI_READ = 0x01D;
+  const unsigned short FEATURE_CD_READ = 0x01E;
+  const unsigned short FEATURE_DVD_READ = 0x01F;
+  const unsigned short FEATURE_RANDOM_WRITABLE = 0x020;
+  const unsigned short FEATURE_INCREMENTAL_STREAMING_WRITABLE = 0x021;
+  const unsigned short FEATURE_SECTOR_ERASABLE = 0x022;
+  const unsigned short FEATURE_FORMATTABLE = 0x023;
+  const unsigned short FEATURE_DEFECT_MANAGEMENT = 0x024;
+  const unsigned short FEATURE_WRITE_ONCE = 0x025;
+  const unsigned short FEATURE_RESTRICTED_OVERWRITE = 0x026;
+  const unsigned short FEATURE_CD_RW_CAV_WRITE = 0x027;
+  const unsigned short FEATURE_MRW = 0x028;
+  const unsigned short FEATURE_ENHANCED_DEFECT_REPORTING = 0x029;
+  const unsigned short FEATURE_DVD_PLUS_RW = 0x02A;
+  const unsigned short FEATURE_DVD_PLUS_R = 0x02B;
+  const unsigned short FEATURE_RIGID_RESTRICTED_OVERWRITE = 0x02C;
+  const unsigned short FEATURE_CD_TRACK_AT_ONCE = 0x02D;
+  const unsigned short FEATURE_CD_MASTERING = 0x02E;
+  const unsigned short FEATURE_DVD_R_RW_WRITE = 0x02F;
+  const unsigned short FEATURE_DDCD_READ = 0x030;
+  const unsigned short FEATURE_DDCD_R_WRITE = 0x031;
+  const unsigned short FEATURE_DDCD_RW_WRITE = 0x032;
+  const unsigned short FEATURE_LAYER_JUMP_RECORDING = 0x033;
+  const unsigned short FEATURE_CD_RW_MEDIA_WRITE_SUPPORT = 0x037;
+  const unsigned short FEATURE_BD_PSEUDO_OVERWRITE = 0x038;
+  const unsigned short FEATURE_DVD_PLUS_RW_DUAL_LAYER = 0x03A;            /**< since MMC5 revision 3 */
+  const unsigned short FEATURE_DVD_PLUS_R_DUAL_LAYER = 0x03B;
+  const unsigned short FEATURE_BD_READ = 0x040;
+  const unsigned short FEATURE_BD_WRITE = 0x041;
+  const unsigned short FEATURE_HD_DVD_READ = 0x050;
+  const unsigned short FEATURE_HD_DVD_WRITE = 0x051;
+  const unsigned short FEATURE_POWER_MANAGEMENT = 0x100;
+  const unsigned short FEATURE_EMBEDDED_CHANGER = 0x102;
+  const unsigned short FEATURE_CD_AUDIO_ANALOG_PLAY = 0x103;
+  const unsigned short FEATURE_MICROCODE_UPGRADE = 0x104;
+  const unsigned short FEATURE_TIMEOUT = 0x105;
+  const unsigned short FEATURE_DVD_CSS = 0x106;
+  const unsigned short FEATURE_REAL_TIME_STREAMING = 0x107;
+  const unsigned short FEATURE_LOGICAL_UNIT_SERIAL_NUMBER = 0x108;
+  const unsigned short FEATURE_DISC_CONTROL_BLOCKS = 0x10A;
+  const unsigned short FEATURE_DVD_CPRM = 0x10B;
+  const unsigned short FEATURE_FIRMWARE_DATE = 0x10C;
+
+  enum Interface {
+    SCSI,        /**< The device is accessed through the SCSI subsystem. */
+    IDE,         /**< The device is accessed through the IDE (ATAPI) interface. */
+    OTHER        /**< Unknown interface (this is not used as the DeviceManager does only handle SCSI and IDE anyway). */
+  };
+
+  /**
+   * Specifies the device type. Device::type() returns a bitwise or
+   * of device types.
+   */
+  enum DeviceType {
+    DEVICE_CD_ROM = 0x1,          /**< Device reads CD-ROM media (every device in K3b supports this.) */
+    DEVICE_CD_R = 0x2,            /**< Device writes CD-R media */
+    DEVICE_CD_RW = 0x4,           /**< Device writes CD-RW media */
+    DEVICE_DVD_ROM = 0x8,         /**< Device reads DVD-ROM media */
+    DEVICE_DVD_RAM = 0x10,        /**< Device writes DVD-RAM media */
+    DEVICE_DVD_R = 0x20,          /**< Device writes DVD-R media */
+    DEVICE_DVD_RW = 0x40,         /**< Device writes DVD-RW media */
+    DEVICE_DVD_R_DL = 0x80,       /**< Device writes DVD-R Dual Layer media */
+    DEVICE_DVD_PLUS_R = 0x100,    /**< Device writes DVD+R media */
+    DEVICE_DVD_PLUS_RW = 0x200,   /**< Device writes DVD+RW media */
+    DEVICE_DVD_PLUS_R_DL = 0x400, /**< Device writes DVD+R Double Layer media */
+    DEVICE_HD_DVD_ROM = 0x800,    /**< Device reads HD DVD-ROM media */
+    DEVICE_HD_DVD_R = 0x1000,     /**< Device writes HD DVD-R media */
+    DEVICE_HD_DVD_RAM = 0x2000,   /**< Device writes HD DVD-RAM media */
+    DEVICE_BD_ROM = 0x4000,       /**< Device reads BD-ROM media */
+    DEVICE_BD_R = 0x8000,         /**< Device writes BD-R media */
+    DEVICE_BD_RE = 0x10000,       /**< Device writes BD-RE media */
+    CDR = DEVICE_CD_R,            /**< \deprecated {use DEVICE_CD_R instead) */
+    CDRW = DEVICE_CD_RW,          /**< \deprecated {use DEVICE_CD_RW instead) */
+    CDROM = DEVICE_CD_ROM,        /**< \deprecated {use DEVICE_CD_ROM instead) */
+    DVD = DEVICE_DVD_ROM,         /**< \deprecated {use DEVICE_DVD_ROM instead) */
+    DVDRAM = DEVICE_DVD_RAM,      /**< \deprecated {use DEVICE_DVD_RAM instead) */
+    DVDR = DEVICE_DVD_R,          /**< \deprecated {use DEVICE_DVD_R instead) */
+    DVDRW = DEVICE_DVD_RW,        /**< \deprecated {use DEVICE_DVD_RW instead) */
+    DVDPR = DEVICE_DVD_PLUS_R,    /**< \deprecated {use DEVICE_DVD_PLUS_R instead) */
+    DVDPRW = DEVICE_DVD_PLUS_RW   /**< \deprecated {use DEVICE_DVD_PLUS_RW instead) */
+  };
+
+
+  /**
+   * The different writing modes. Device::writingModes() returns a bitwise or of writing modes.
+   */
+  enum WritingMode {
+    WRITINGMODE_SAO = 0x1,           /**< Device writes CD or DVD-R media in Session at once (also known as DAO) writing mode */
+    WRITINGMODE_SAO_R96P = 0x2,      /**< Device writes CD media with packed R-W subchannels Session at once writing mode */
+    WRITINGMODE_SAO_R96R = 0x4,      /**< Device writes CD media with raw R-W subchannels Session at once writing mode */
+    WRITINGMODE_TAO = 0x8,           /**< Device writes CD media in Track at once writing mode */
+    WRITINGMODE_RAW = 0x10,          /**< Device writes CD media in Raw writing mode */
+    WRITINGMODE_RAW_R16 = 0x20,      /**< Device writes CD media with P/Q subchannels in Raw writing mode */
+    WRITINGMODE_RAW_R96P = 0x40,     /**< Device writes CD media with packed R-W subchannels Raw writing mode */
+    WRITINGMODE_RAW_R96R = 0x80,     /**< Device writes CD media with raw R-W subchannels Raw writing mode */
+    WRITINGMODE_INCR_SEQ = 0x100,    /**< Device writes DVD-R(W) media in incremental sequential writing mode */
+    WRITINGMODE_RES_OVWR = 0x200,    /**< Device writes DVD-RW media in restricted overwrite mode */
+    WRITINGMODE_LAYER_JUMP = 0x400,  /**< Device writes DVD-R Dual layer media in Layer Jump writing mode */
+    WRITINGMODE_RRM = 0x800,         /**< Device writes BD-R media in Random Recording Mode */
+    WRITINGMODE_SRM = 0x1000,        /**< Device writes BD-R media in Sequential recording mode */
+    WRITINGMODE_SRM_POW = 0x2000,    /**< Device writes BD-R media in Pseudo overwrite Sequential recording mode */
+    SAO = WRITINGMODE_SAO,           /**< \deprecated {use WRITINGMODE_SAO instead) */
+    TAO = WRITINGMODE_TAO,           /**< \deprecated {use WRITINGMODE_TAO instead) */
+    RAW = WRITINGMODE_RAW,           /**< \deprecated {use WRITINGMODE_RAW instead) */
+    SAO_R96P = WRITINGMODE_SAO_R96P, /**< \deprecated {use WRITINGMODE_SAO_R96P instead) */
+    SAO_R96R = WRITINGMODE_SAO_R96R, /**< \deprecated {use WRITINGMODE_SAO_R96R instead) */
+    RAW_R16 = WRITINGMODE_RAW_R16,   /**< \deprecated {use WRITINGMODE_RAW_R16 instead) */
+    RAW_R96P = WRITINGMODE_RAW_R96P, /**< \deprecated {use WRITINGMODE_RAW_R96P instead) */
+    RAW_R96R = WRITINGMODE_RAW_R96R  /**< \deprecated {use WRITINGMODE_RAW_R96R instead) */
+  };
+
+
+  enum MediaState { 
+    STATE_UNKNOWN = 0x1,    /**< Media state is unknown (when an error occurred or the device is unable to determine the media state). */
+    STATE_NO_MEDIA = 0x2,   /**< No media inserted. */
+    STATE_COMPLETE = 0x4,   /**< The inserted media is complete. */ 
+    STATE_INCOMPLETE = 0x8, /**< The inserted media is incomplete/appendable. */
+    STATE_EMPTY = 0x10      /**< The inserted media is empty. */
+  };
+
+  enum BackGroundFormattingState {
+    BG_FORMAT_NONE = 0x1,
+    BG_FORMAT_INCOMPLETE = 0x2,
+    BG_FORMAT_IN_PROGRESS = 0x4,
+    BG_FORMAT_COMPLETE = 0x8
+  };
+
+  /**
+   * Defines the different media types as retured by 
+   * Device::cdMediaType() and Device::dvdMediaType()
+   */
+  enum MediaType {
+    MEDIA_UNKNOWN = 0x1,                           /**< Represents an unknown media type (when an error occurred) */
+    MEDIA_NONE = 0x2,                              /**< No medium is inserted */
+    MEDIA_DVD_ROM = 0x4,                           /**< */
+    MEDIA_DVD_R = 0x8,                             /**< */
+    MEDIA_DVD_R_SEQ = 0x10,                        /**< */
+    MEDIA_DVD_R_DL = 0x20,                         /**< Dual Layer DVD-R media. */
+    MEDIA_DVD_R_DL_SEQ = 0x40,                     /**< */
+    MEDIA_DVD_R_DL_JUMP = 0x80,                    /**< */
+    MEDIA_DVD_RAM = 0x100,                         /**< */
+    MEDIA_DVD_RW = 0x200,                          /**< */
+    MEDIA_DVD_RW_OVWR = 0x400,                     /**< DVD-RW media formatted in Restricted Overwrite mode. */
+    MEDIA_DVD_RW_SEQ = 0x800,                      /**< DVD-RW media formatted in Incremental Sequential mode. */
+    MEDIA_DVD_PLUS_RW = 0x1000,                    /**< */
+    MEDIA_DVD_PLUS_R = 0x2000,                     /**< */
+    MEDIA_DVD_PLUS_R_DL = 0x4000,                  /**< Double Layer DVD+R media. */
+    MEDIA_DVD_PLUS_RW_DL = 0x8000,                 /**< Double Layer DVD+RW media. */
+    MEDIA_CD_ROM = 0x10000,                        /**< */
+    MEDIA_CD_R = 0x20000,                          /**< */
+    MEDIA_CD_RW = 0x40000,                         /**< */
+    MEDIA_HD_DVD_ROM = 0x80000,                    /**< */
+    MEDIA_HD_DVD_R = 0x100000,                     /**< */
+    MEDIA_HD_DVD_RAM = 0x200000,                   /**< */
+    MEDIA_BD_ROM = 0x400000,                       /**< Read-only Blu-ray Disc (BD) */
+    MEDIA_BD_R = 0x800000,                         /**< Writable Blu-ray Disc (BD-R) */
+    MEDIA_BD_R_SRM = 0x1000000,                    /**< Writable Blu-ray Disc (BD-R) */
+    MEDIA_BD_R_SRM_POW = 0x2000000,                /**< Writable Blu-ray Disc (BD-R) */
+    MEDIA_BD_R_RRM = 0x4000000,                    /**< Writable Blu-ray Disc (BD-R) */
+    MEDIA_BD_RE = 0x8000000,                       /**< Rewritable Blu-ray Disc (BD-RE) */
+    MEDIA_WRITABLE_CD = MEDIA_CD_R |               /**< This is a bitwise or of media types representing all writable CD media.*/
+                        MEDIA_CD_RW,
+    MEDIA_CD_ALL = MEDIA_WRITABLE_CD |
+                   MEDIA_CD_ROM,
+    MEDIA_WRITABLE_DVD_SL = MEDIA_DVD_R |          /**< This is a bitwise or of media types representing all writable single layer DVD media.*/
+                            MEDIA_DVD_R_SEQ | 
+                            MEDIA_DVD_RW |
+                            MEDIA_DVD_RW_OVWR |
+                            MEDIA_DVD_RW_SEQ |
+                            MEDIA_DVD_PLUS_RW |
+                            MEDIA_DVD_PLUS_R,
+    MEDIA_WRITABLE_DVD_DL = MEDIA_DVD_R_DL |       /**< This is a bitwise or of media types representing all writable double layer DVD media.*/
+                            MEDIA_DVD_R_DL_SEQ |
+                            MEDIA_DVD_R_DL_JUMP |
+                            MEDIA_DVD_PLUS_R_DL |
+                            MEDIA_DVD_PLUS_RW_DL,
+    MEDIA_WRITABLE_DVD = MEDIA_WRITABLE_DVD_SL |   /**< This is a bitwise or of media types representing all writable DVD media.*/
+                         MEDIA_WRITABLE_DVD_DL,
+    MEDIA_REWRITABLE_DVD =  MEDIA_DVD_RW |
+                            MEDIA_DVD_RW_OVWR |
+                            MEDIA_DVD_RW_SEQ |
+                            MEDIA_DVD_PLUS_RW_DL |
+                            MEDIA_DVD_PLUS_RW,
+    MEDIA_WRITABLE_BD = MEDIA_BD_R |               /**< This is a bitwise or of media types representing all writable BD media.*/
+                        MEDIA_BD_R_SRM |
+                        MEDIA_BD_R_SRM_POW |
+                        MEDIA_BD_R_RRM |
+                        MEDIA_BD_RE,
+    MEDIA_WRITABLE = MEDIA_WRITABLE_CD |           /**< This is a bitwise or of media types representing all writable media.*/
+                     MEDIA_WRITABLE_DVD |
+                     MEDIA_WRITABLE_BD,
+    MEDIA_REWRITABLE = MEDIA_CD_RW |
+                       MEDIA_REWRITABLE_DVD |
+                       MEDIA_BD_RE,
+    MEDIA_DVD_MINUS_ALL = MEDIA_DVD_R |            /**< This is a bitwise or of media types representing all DVD-R/W media.*/
+                          MEDIA_DVD_R_SEQ | 
+                          MEDIA_DVD_RW |
+                          MEDIA_DVD_RW_OVWR |
+                          MEDIA_DVD_RW_SEQ |
+                          MEDIA_DVD_R_DL |
+                          MEDIA_DVD_R_DL_SEQ |
+                          MEDIA_DVD_R_DL_JUMP,
+    MEDIA_DVD_PLUS_ALL = MEDIA_DVD_PLUS_RW |       /**< This is a bitwise or of media types representing all DVD+R/W media.*/
+                         MEDIA_DVD_PLUS_R |
+                         MEDIA_DVD_PLUS_R_DL |
+                         MEDIA_DVD_PLUS_RW_DL,
+    MEDIA_DVD_ALL = MEDIA_WRITABLE_DVD |
+                    MEDIA_DVD_ROM,
+    MEDIA_BD_ALL = MEDIA_WRITABLE_BD |
+                   MEDIA_BD_ROM,
+    MEDIA_ALL = MEDIA_CD_ALL |
+                MEDIA_DVD_ALL |
+                MEDIA_BD_ALL
+  };
+
+  inline bool isDvdMedia( int mediaType ) {
+    return ( mediaType == MEDIA_DVD_ROM || 
+	     mediaType == MEDIA_DVD_R || 
+	     mediaType == MEDIA_DVD_R_SEQ || 
+	     mediaType == MEDIA_DVD_R_DL ||
+	     mediaType == MEDIA_DVD_R_DL_SEQ ||
+	     mediaType == MEDIA_DVD_R_DL_JUMP ||
+	     mediaType == MEDIA_DVD_RW || 
+	     mediaType == MEDIA_DVD_RW_OVWR || 
+	     mediaType == MEDIA_DVD_RW_SEQ || 
+	     mediaType == MEDIA_DVD_PLUS_RW || 
+	     mediaType == MEDIA_DVD_PLUS_R ||
+	     mediaType == MEDIA_DVD_PLUS_R_DL );
+  }
+
+  inline bool isRewritableMedia( int mediaType ) {
+    return ( mediaType == MEDIA_DVD_RW ||
+	     mediaType == MEDIA_DVD_RW_OVWR || 
+	     mediaType == MEDIA_DVD_RW_SEQ || 
+	     mediaType == MEDIA_DVD_PLUS_RW || 
+	     mediaType == MEDIA_CD_RW );
+  }
+}
+
+#endif
diff --git a/libk3bdevice/k3bdiskinfo.cpp b/libk3bdevice/k3bdiskinfo.cpp
new file mode 100644
index 0000000..6c91d19
--- /dev/null
+++ b/libk3bdevice/k3bdiskinfo.cpp
@@ -0,0 +1,266 @@
+/* 
+ *
+ * $Id: k3bdiskinfo.cpp 654649 2007-04-16 17:55:50Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include "k3bdiskinfo.h"
+#include "k3bdeviceglobals.h"
+
+#include <k3bmsf.h>
+
+#include <klocale.h>
+#include <k3bdebug.h>
+#include <kio/global.h>
+
+#include <qstringlist.h>
+
+
+K3bDevice::DiskInfo::DiskInfo()
+  : m_mediaType(MEDIA_UNKNOWN),
+    m_currentProfile(MEDIA_UNKNOWN),
+    m_diskState(STATE_UNKNOWN),
+    m_lastSessionState(STATE_UNKNOWN),
+    m_bgFormatState(0),
+    m_numSessions(0),
+    m_numTracks(0),
+    m_rewritable(false)
+{
+}
+
+
+K3bDevice::DiskInfo::~DiskInfo()
+{
+}
+
+
+int K3bDevice::DiskInfo::diskState() const
+{
+  return m_diskState;
+}
+
+
+int K3bDevice::DiskInfo::lastSessionState() const
+{
+  return m_lastSessionState;
+}
+
+
+int K3bDevice::DiskInfo::bgFormatState() const
+{
+  return m_bgFormatState;
+}
+
+
+bool K3bDevice::DiskInfo::empty() const
+{
+  return diskState() == STATE_EMPTY;
+}
+
+
+bool K3bDevice::DiskInfo::rewritable() const
+{
+  return m_rewritable;
+}
+
+
+bool K3bDevice::DiskInfo::appendable() const
+{
+  return diskState() == STATE_INCOMPLETE;
+}
+
+
+int K3bDevice::DiskInfo::mediaType() const
+{
+  return m_mediaType;
+}
+
+
+bool K3bDevice::DiskInfo::isDvdMedia() const
+{
+  return K3bDevice::isDvdMedia( mediaType() );
+}
+
+
+int K3bDevice::DiskInfo::numSessions() const
+{
+  if( empty() )
+    return 0;
+  else
+    return m_numSessions;
+}
+
+
+int K3bDevice::DiskInfo::numTracks() const
+{
+  if( empty() )
+    return 0;
+  else
+    return m_numTracks;
+}
+
+
+int K3bDevice::DiskInfo::numLayers() const
+{
+  if( isDvdMedia() )
+    return m_numLayers;
+  else
+    return 1;
+}
+
+
+K3b::Msf K3bDevice::DiskInfo::remainingSize() const
+{
+  if( empty() )
+    return capacity();
+
+  //
+  // There is no way to properly determine the used size on an overwrite media
+  // without having a look at the filesystem (or is there?)
+  //
+  else if( appendable() ||
+	   mediaType() & (MEDIA_DVD_PLUS_RW|MEDIA_DVD_RW_OVWR) )
+    return capacity() - m_usedCapacity;
+
+  else
+    return 0;
+}
+
+
+K3b::Msf K3bDevice::DiskInfo::capacity() const
+{
+  return (m_capacity == 0 ? size() : m_capacity);
+}
+
+
+K3b::Msf K3bDevice::DiskInfo::size() const
+{
+  if( empty() )
+    return 0;
+  else
+    return m_usedCapacity;
+}
+
+
+K3b::Msf K3bDevice::DiskInfo::firstLayerSize() const
+{
+  if( numLayers() > 1 )
+    return m_firstLayerSize;
+  else
+    return size();
+}
+
+
+void K3bDevice::DiskInfo::debug() const
+{
+  k3bDebug() << "DiskInfo:" << endl
+	    << "Mediatype:       " << K3bDevice::mediaTypeString( mediaType() ) << endl
+	    << "Current Profile: " << K3bDevice::mediaTypeString( currentProfile() ) << endl
+	    << "Disk state:      " << ( diskState() == K3bDevice::STATE_EMPTY ? 
+					"empty" :
+					( diskState() == K3bDevice::STATE_INCOMPLETE ?
+					  "incomplete" :
+					  ( diskState() == K3bDevice::STATE_COMPLETE ?
+					    "complete" : 
+					    ( diskState() == K3bDevice::STATE_NO_MEDIA ?
+					      "no media" : 
+					      "unknown" ) ) ) ) << endl
+	    << "Empty:           " << empty() << endl
+	    << "Rewritable:      " << rewritable() << endl
+	    << "Appendable:      " << appendable() << endl
+	    << "Sessions:        " << numSessions() << endl
+	    << "Tracks:          " << numTracks() << endl
+	    << "Layers:          " << numLayers() << endl
+	    << "Capacity:        " << capacity()
+	    << " (LBA " << capacity().lba()
+	    << ") (" << capacity().mode1Bytes() << " Bytes)" << endl
+
+	    << "Remaining size:  " << remainingSize() 
+	    << " (LBA " << remainingSize().lba()
+	    << ") (" << remainingSize().mode1Bytes() << " Bytes)" << endl
+
+	    << "Used Size:       " << size()
+	    << " (LBA " << size().lba()
+	    << ") (" << size().mode1Bytes() << " Bytes)" << endl;
+
+  if( mediaType() == K3bDevice::MEDIA_DVD_PLUS_RW )
+    k3bDebug() << "Bg Format:       " << ( bgFormatState() == BG_FORMAT_NONE ? 
+					  "none" :
+					  ( bgFormatState() == BG_FORMAT_INCOMPLETE ?
+					    "incomplete" :
+					    ( bgFormatState() == BG_FORMAT_IN_PROGRESS ?
+					      "in progress" :
+					      ( bgFormatState() == BG_FORMAT_COMPLETE ?
+                                                "complete" : "unknown" ) ) ) ) << endl;
+}
+
+
+bool K3bDevice::DiskInfo::operator==( const K3bDevice::DiskInfo& other ) const
+{
+  return( m_mediaType == other.m_mediaType &&
+	  m_currentProfile == other.m_currentProfile &&
+	  m_diskState == other.m_diskState &&
+	  m_lastSessionState == other.m_lastSessionState &&
+	  m_bgFormatState == other.m_bgFormatState &&
+	  m_numSessions == other.m_numSessions &&
+	  m_numTracks == other.m_numTracks &&
+	  m_numLayers == other.m_numLayers &&
+	  m_rewritable == other.m_rewritable &&
+	  m_capacity == other.m_capacity &&
+	  m_usedCapacity == other.m_usedCapacity &&
+	  m_firstLayerSize == other.m_firstLayerSize &&
+	  m_mediaId == other.m_mediaId );
+}
+
+
+bool K3bDevice::DiskInfo::operator!=( const K3bDevice::DiskInfo& other ) const
+{
+  return( m_mediaType != other.m_mediaType ||
+	  m_currentProfile != other.m_currentProfile ||
+	  m_diskState != other.m_diskState ||
+	  m_lastSessionState != other.m_lastSessionState ||
+	  m_bgFormatState != other.m_bgFormatState ||
+	  m_numSessions != other.m_numSessions ||
+	  m_numTracks != other.m_numTracks ||
+	  m_numLayers != other.m_numLayers ||
+	  m_rewritable != other.m_rewritable ||
+	  m_capacity != other.m_capacity ||
+	  m_usedCapacity != other.m_usedCapacity ||
+	  m_firstLayerSize != other.m_firstLayerSize ||
+	  m_mediaId != other.m_mediaId );
+}
+
+
+// kdbgstream& K3bDevice::operator<<( kdbgstream& s, const K3bDevice::DiskInfo& ngInf )
+// {
+//    s << "DiskInfo:" << endl
+//      << "Mediatype:       " << K3bDevice::mediaTypeString( ngInf.mediaType() ) << endl
+//      << "Current Profile: " << K3bDevice::mediaTypeString( ngInf.currentProfile() ) << endl
+//      << "Disk state:      " << ( ngInf.diskState() == K3bDevice::STATE_EMPTY ? 
+// 				 "empty" :
+// 				 ( ngInf.diskState() == K3bDevice::STATE_INCOMPLETE ?
+// 				   "incomplete" :
+// 				   ( ngInf.diskState() == K3bDevice::STATE_COMPLETE ?
+// 				     "complete" : 
+// 				     ( ngInf.diskState() == K3bDevice::STATE_NO_MEDIA ?
+// 				       "no media" : 
+// 				       "unknown" ) ) ) ) << endl
+//      << "Empty:           " << ngInf.empty() << endl
+//      << "Rewritable:      " << ngInf.rewritable() << endl
+//      << "Appendable:      " << ngInf.appendable() << endl
+//      << "Sessions:        " << ngInf.numSessions() << endl
+//      << "Tracks:          " << ngInf.numTracks() << endl
+//      << "Size:            " << ngInf.capacity().toString() << endl
+//      << "Remaining size:  " << ngInf.remainingSize().toString() << endl;
+   
+//    return s;
+// }
diff --git a/libk3bdevice/k3bdiskinfo.h b/libk3bdevice/k3bdiskinfo.h
new file mode 100644
index 0000000..ed7c382
--- /dev/null
+++ b/libk3bdevice/k3bdiskinfo.h
@@ -0,0 +1,182 @@
+/*
+ *
+ * $Id: k3bdiskinfo.h 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#ifndef _K3B_DISKINFO_H_
+#define _K3B_DISKINFO_H_
+
+#include <k3bdevicetypes.h>
+
+#include <k3btoc.h>
+#include <k3bmsf.h>
+#include "k3bdevice_export.h"
+
+#include <qcstring.h>
+
+
+class kdbgstream;
+
+
+namespace K3bDevice
+{
+  /**
+   * This class is directly accociated to a strcuture from 
+   * the MMC draft READ_DISK_INFO.
+   * It also holds some additional data.
+   * This class' data will be retrieved by K3bDevice::Device.
+   *
+   * Before using any values one should check diskState != STATE_UNKNOWN or
+   * diskState == STATE_NO_MEDIA.
+   * That may mean that no disk is in the drive or an error occurred.
+   * Writers should never give the STATE_UNKNOWN state. CD-ROM or DVD-ROM
+   * drives on the other hand may have trouble determining the state of the disk.
+   */
+  class LIBK3BDEVICE_EXPORT DiskInfo
+    {
+    public:
+      DiskInfo();
+      ~DiskInfo();
+
+      /**
+       * Returnes the state of the disk.
+       * See enum State.
+       */
+      int diskState() const;
+
+      /**
+       * Returnes the state of the last session.
+       * See enum State.
+       */
+      int lastSessionState() const;
+
+      /**
+       * Returnes the state of the background formatting. This does
+       * only make sense for DVD+RW (and MRW which is not yet supported)
+       */
+      int bgFormatState() const;
+
+      /**
+       * returnes true if diskState() == STATE_EMPTY
+       */
+      bool empty() const;
+
+      /**
+       * Is this a rewritable media (e.g. a CD-RW, DVD-RW, or DVD+RW)
+       */
+      bool rewritable() const;
+
+      /**
+       * Is this disk appendable
+       * returnes true if diskState() == STATE_INCOMPLETE
+       */
+      bool appendable() const;
+
+      /**
+       * The type of the disk:
+       * CD-ROM, CD-R, CD-RW, DVD-ROM, DVD-R(W), DVD+R(W)
+       */
+      int mediaType() const;
+
+      /**
+       * This is the current profile of the drive. That means it may differ
+       * from drive to drive.
+       * -1 means no info.
+       * Mainly interesting for the distiction of DVD-R(W) modes:
+       * Sequential and Restricted Overwrite.
+       */
+      int currentProfile() const { return m_currentProfile; }
+
+      /**
+       * Just for easy implementation since there are so many
+       * different DVD formats.
+       */
+      bool isDvdMedia() const;
+
+      /**
+       * The number of sessions on the disk.
+       * This does not include any leadout or the last empty session
+       * on a DVD+-R(W)
+       */
+      int numSessions() const;
+
+      /**
+       * The number of finished tracks.
+       * This does not include the empty track.
+       */
+      int numTracks() const;
+
+      /**
+       * Number of layers on a DVD media. For CD media this is always 1.
+       */
+      int numLayers() const;
+
+      /**
+       * Does only make sense for appendable disks.
+       */
+      K3b::Msf remainingSize() const;
+
+      /**
+       * The capacity of the disk.
+       * For complete disks this may be the same as size()
+       */
+      K3b::Msf capacity() const;
+
+      /**
+       * Returns the size of the used part.
+       * For appendable media this equals capacity() - remainingSize()
+       */
+      K3b::Msf size() const;
+
+      /**
+       * Returns the size of Data area in the first layer for DL DVD media.
+       * Otherwise size() is returned.
+       *
+       * This does not specify the layer change sector as the data area on DVD media does
+       * not start at sector 0 but at sector 30000h or 31000h depending on the type.
+       */
+      K3b::Msf firstLayerSize() const;
+
+      const QCString& mediaId() const { return m_mediaId; }
+
+      void debug() const;
+
+      bool operator==( const DiskInfo& ) const;
+      bool operator!=( const DiskInfo& ) const;
+
+    private:
+      int m_mediaType;
+      int m_currentProfile;
+
+      int m_diskState;
+      int m_lastSessionState;
+      int m_bgFormatState;
+      int m_numSessions;
+      int m_numTracks;
+      int m_numLayers;  // only for DVD media
+      int m_rewritable;
+
+      K3b::Msf m_capacity;
+      K3b::Msf m_usedCapacity;
+      K3b::Msf m_firstLayerSize;
+
+      QCString m_mediaId;
+
+      friend class Device;
+    };
+
+  //  kdbgstream& operator<<( kdbgstream& s, const DiskInfo& ngInf );
+}
+
+#endif
diff --git a/libk3bdevice/k3bhalconnection.cpp b/libk3bdevice/k3bhalconnection.cpp
new file mode 100644
index 0000000..2b0877b
--- /dev/null
+++ b/libk3bdevice/k3bhalconnection.cpp
@@ -0,0 +1,610 @@
+/*
+ *
+ * $Id: sourceheader,v 1.3 2005/01/19 13:03:46 trueg Exp $
+ * Copyright (C) 2005-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include "k3bhalconnection.h"
+#include "k3bdevice.h"
+
+#include <k3bdebug.h>
+#include <klocale.h>
+
+#include <qtimer.h>
+
+// We acknowledge the the dbus API is unstable
+#define DBUS_API_SUBJECT_TO_CHANGE
+#include <dbus/connection.h>
+#include <dbus/dbus.h>
+#include <hal/libhal.h>
+
+
+static char** qstringListToArray( const QStringList& s )
+{
+  char** a = new char*[s.count()];
+  for( unsigned int i = 0; i < s.count(); ++i ) {
+    a[i] = new char[s[i].length()+1];
+    ::strncpy( a[i], s[i].local8Bit().data(), s[i].length() );
+    a[s[i].length()] = '\0';
+  }
+  return a;
+}
+
+static void freeArray( char** a, unsigned int length )
+{
+  for( unsigned int i = 0; i < length; ++i )
+    delete [] a[i];
+  delete a;
+}
+
+
+// CALLBACKS
+void halDeviceAdded( LibHalContext* ctx, const char* udi )
+{
+  Q_UNUSED( ctx );
+  k3bDebug() << "adding udi   " << udi << endl;
+  K3bDevice::HalConnection::instance()->addDevice( udi );
+}
+
+
+void halDeviceRemoved( LibHalContext* ctx, const char* udi )
+{
+  Q_UNUSED( ctx );
+  k3bDebug() << "removing udi " << udi << endl;
+  K3bDevice::HalConnection::instance()->removeDevice( udi );
+}
+
+
+K3bDevice::HalConnection* K3bDevice::HalConnection::s_instance = 0;
+
+
+class K3bDevice::HalConnection::Private
+{
+public:
+  Private()
+    : halContext(0),
+      dBusQtConnection(0),
+      bOpen(false) {
+  }
+
+  LibHalContext* halContext;
+  DBusConnection* connection;
+  DBusQt::Connection* dBusQtConnection;
+
+  bool bOpen;
+
+  QMap<QCString, QString> udiDeviceMap;
+  QMap<QString, QCString> deviceUdiMap;
+
+  QMap<QCString, QCString> deviceMediumUdiMap;
+};
+
+
+K3bDevice::HalConnection* K3bDevice::HalConnection::instance()
+{
+  if( s_instance == 0 )
+    s_instance = new HalConnection( 0 );
+
+  if( !s_instance->isConnected() && !s_instance->open() )
+      k3bDebug() << "(K3bDevice::HalConnection) failed to open connection to HAL." << endl;
+
+  return s_instance;
+}
+
+
+K3bDevice::HalConnection::HalConnection( QObject* parent, const char* name )
+  : QObject( parent, name )
+{
+  d = new Private();
+}
+
+
+K3bDevice::HalConnection::~HalConnection()
+{
+  s_instance = 0;
+  close();
+  delete d;
+}
+
+
+bool K3bDevice::HalConnection::isConnected() const
+{
+  return d->bOpen;
+}
+
+
+bool K3bDevice::HalConnection::open()
+{
+  close();
+
+  k3bDebug() << "(K3bDevice::HalConnection) initializing HAL >= 0.5" << endl;
+
+  d->halContext = libhal_ctx_new();
+  if( !d->halContext ) {
+    k3bDebug() << "(K3bDevice::HalConnection) unable to create HAL context." << endl;
+    return false;
+  }
+
+  DBusError error;
+  dbus_error_init( &error );
+  d->connection = dbus_bus_get( DBUS_BUS_SYSTEM, &error );
+  if( dbus_error_is_set(&error) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) unable to connect to DBUS: " << error.message << endl;
+    return false;
+  }
+
+  setupDBusQtConnection( d->connection );
+
+  libhal_ctx_set_dbus_connection( d->halContext, d->connection );
+
+  libhal_ctx_set_device_added( d->halContext, halDeviceAdded );
+  libhal_ctx_set_device_removed( d->halContext, halDeviceRemoved );
+  libhal_ctx_set_device_new_capability( d->halContext, 0 );
+  libhal_ctx_set_device_lost_capability( d->halContext, 0 );
+  libhal_ctx_set_device_property_modified( d->halContext, 0 );
+  libhal_ctx_set_device_condition( d->halContext, 0 );
+
+  if( !libhal_ctx_init( d->halContext, 0 ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) Failed to init HAL context!" << endl;
+    return false;
+  }
+
+  d->bOpen = true;
+
+  //
+  // report all devices
+  //
+  int numDevices;
+  char** halDeviceList = libhal_get_all_devices( d->halContext, &numDevices, 0 );
+  for( int i = 0; i < numDevices; ++i )
+    addDevice( halDeviceList[i] );
+
+  return true;
+}
+
+
+void K3bDevice::HalConnection::close()
+{
+  if( d->halContext ) {
+    // clear the context
+    if( isConnected() )
+      libhal_ctx_shutdown( d->halContext, 0 );
+    libhal_ctx_free( d->halContext );
+
+    // delete the connection (may be 0 if open() failed)
+    delete d->dBusQtConnection;
+
+    d->halContext = 0;
+    d->dBusQtConnection = 0;
+    d->bOpen = false;
+  }
+}
+
+
+QStringList K3bDevice::HalConnection::devices() const
+{
+  return QStringList( d->udiDeviceMap.values() );
+}
+
+
+void K3bDevice::HalConnection::addDevice( const char* udi )
+{
+  // ignore devices that have no property "info.capabilities" to suppress error messages
+  if( !libhal_device_property_exists( d->halContext, udi, "info.capabilities", 0 ) )
+    return;
+
+  if( libhal_device_query_capability( d->halContext, udi, "storage.cdrom", 0 ) ) {
+    char* dev = libhal_device_get_property_string( d->halContext, udi, "block.device", 0 );
+    if( dev ) {
+      QString s( dev );
+      libhal_free_string( dev );
+
+      if( !s.isEmpty() ) {
+	k3bDebug() << "Mapping udi " << udi << " to device " << s << endl;
+	d->udiDeviceMap[udi] = s;
+	d->deviceUdiMap[s] = udi;
+	emit deviceAdded( s );
+      }
+    }
+  }
+  else {
+    if( libhal_device_property_exists( d->halContext, udi, "block.storage_device", 0 ) ) {
+      char* deviceUdi = libhal_device_get_property_string( d->halContext, udi, "block.storage_device", 0 );
+      if( deviceUdi ) {
+	QCString du( deviceUdi );
+	libhal_free_string( deviceUdi );
+
+	if( d->udiDeviceMap.contains( du ) ) {
+	  //
+	  // A new medium has been inserted. Save this medium's udi so we can reuse it later
+	  // on for the mount/unmount/eject methods
+	  //
+	  d->deviceMediumUdiMap[du] = QCString( udi );
+	  emit mediumChanged( d->udiDeviceMap[du] );
+	}
+      }
+    }
+  }
+}
+
+
+void K3bDevice::HalConnection::removeDevice( const char* udi )
+{
+  QMapIterator<QCString, QString> it = d->udiDeviceMap.find( udi );
+  if( it != d->udiDeviceMap.end() ) {
+    k3bDebug() << "Unmapping udi " << udi << " from device " << it.data() << endl;
+    emit deviceRemoved( it.data() );
+    d->udiDeviceMap.erase( it );
+    d->deviceUdiMap.erase( it.data() );
+  }
+  else {
+    if( libhal_device_property_exists( d->halContext, udi, "block.storage_device", 0 ) ) {
+      char* deviceUdi = libhal_device_get_property_string( d->halContext, udi, "block.storage_device", 0 );
+      if( deviceUdi ) {
+	QCString du( deviceUdi );
+	libhal_free_string( deviceUdi );
+
+	if( d->udiDeviceMap.contains( du ) ) {
+	  //
+	  // A medium has been removed/ejected.
+	  //
+	  d->deviceMediumUdiMap[du] = 0;
+	  emit mediumChanged( d->udiDeviceMap[du] );
+	}
+      }
+    }
+  }
+}
+
+
+int K3bDevice::HalConnection::lock( Device* dev )
+{
+  //
+  // The code below is based on the code from kioslave/media/mediamanager/halbackend.cpp in the kdebase package
+  // Copyright (c) 2004-2005 Jérôme Lodewyck <jerome dot lodewyck at normalesup dot org>
+  //
+  DBusMessage* dmesg = 0;
+  DBusMessage* reply = 0;
+  DBusError error;
+
+  if( !d->deviceUdiMap.contains( dev->blockDeviceName() ) ) {
+    return org_freedesktop_Hal_Device_Volume_NoSuchDevice;
+  }
+
+  QCString udi = d->deviceUdiMap[dev->blockDeviceName()];
+
+  if( !( dmesg = dbus_message_new_method_call( "org.freedesktop.Hal", udi.data(),
+					       "org.freedesktop.Hal.Device",
+					       "Lock" ) ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) lock failed for " << udi << ": could not create dbus message\n";
+    return org_freedesktop_Hal_CommunicationError;
+  }
+
+  const char* lockComment = "Locked by the K3b libraries";
+
+  if( !dbus_message_append_args( dmesg,
+				 DBUS_TYPE_STRING, &lockComment,
+				 DBUS_TYPE_INVALID ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) lock failed for " << udi << ": could not append args to dbus message\n";
+    dbus_message_unref( dmesg );
+    return org_freedesktop_Hal_CommunicationError;
+  }
+
+  int ret = org_freedesktop_Hal_Success;
+
+  dbus_error_init( &error );
+  reply = dbus_connection_send_with_reply_and_block( d->connection, dmesg, -1, &error );
+  if( dbus_error_is_set( &error ) ) {
+    kdError() << "(K3bDevice::HalConnection) lock failed for " << udi << ": " << error.name << " - " << error.message << endl;
+    if( !strcmp(error.name, "org.freedesktop.Hal.NoSuchDevice" ) )
+      ret = org_freedesktop_Hal_NoSuchDevice;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.DeviceAlreadyLocked" ) )
+      ret = org_freedesktop_Hal_DeviceAlreadyLocked;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.PermissionDenied" ) )
+      ret = org_freedesktop_Hal_PermissionDenied;
+
+    dbus_error_free( &error );
+  }
+  else
+    k3bDebug() << "(K3bDevice::HalConnection) lock queued for " << udi << endl;
+
+  dbus_message_unref( dmesg );
+  if( reply )
+    dbus_message_unref( reply );
+
+  return ret;
+}
+
+
+int K3bDevice::HalConnection::unlock( Device* dev )
+{
+  //
+  // The code below is based on the code from kioslave/media/mediamanager/halbackend.cpp in the kdebase package
+  // Copyright (c) 2004-2005 Jérôme Lodewyck <jerome dot lodewyck at normalesup dot org>
+  //
+  DBusMessage* dmesg = 0;
+  DBusMessage* reply = 0;
+  DBusError error;
+
+  if( !d->deviceUdiMap.contains( dev->blockDeviceName() ) ) {
+    return org_freedesktop_Hal_Device_Volume_NoSuchDevice;
+  }
+
+  QCString udi = d->deviceUdiMap[dev->blockDeviceName()];
+
+  if( !( dmesg = dbus_message_new_method_call( "org.freedesktop.Hal", udi.data(),
+					       "org.freedesktop.Hal.Device",
+					       "Unlock" ) ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) unlock failed for " << udi << ": could not create dbus message\n";
+    return org_freedesktop_Hal_CommunicationError;
+  }
+
+  if( !dbus_message_append_args( dmesg,
+				 DBUS_TYPE_INVALID ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) unlock failed for " << udi << ": could not append args to dbus message\n";
+    dbus_message_unref( dmesg );
+    return org_freedesktop_Hal_CommunicationError;
+  }
+
+  int ret = org_freedesktop_Hal_Success;
+
+  dbus_error_init( &error );
+  reply = dbus_connection_send_with_reply_and_block( d->connection, dmesg, -1, &error );
+  if( dbus_error_is_set( &error ) ) {
+    kdError() << "(K3bDevice::HalConnection) unlock failed for " << udi << ": " << error.name << " - " << error.message << endl;
+    if( !strcmp(error.name, "org.freedesktop.Hal.NoSuchDevice" ) )
+      ret = org_freedesktop_Hal_NoSuchDevice;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.DeviceAlreadyLocked" ) )
+      ret = org_freedesktop_Hal_DeviceAlreadyLocked;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.PermissionDenied" ) )
+      ret = org_freedesktop_Hal_PermissionDenied;
+
+    dbus_error_free( &error );
+  }
+  else
+    k3bDebug() << "(K3bDevice::HalConnection) unlock queued for " << udi << endl;
+
+  dbus_message_unref( dmesg );
+  if( reply )
+    dbus_message_unref( reply );
+
+  return ret;
+}
+
+
+int K3bDevice::HalConnection::mount( K3bDevice::Device* dev,
+				     const QString& mountPoint,
+				     const QString& fstype,
+				     const QStringList& options )
+{
+  //
+  // The code below is based on the code from kioslave/media/mediamanager/halbackend.cpp in the kdebase package
+  // Copyright (c) 2004-2005 Jérôme Lodewyck <jerome dot lodewyck at normalesup dot org>
+  //
+  DBusMessage* dmesg = 0;
+  DBusMessage* reply = 0;
+  DBusError error;
+
+  if( !d->deviceUdiMap.contains( dev->blockDeviceName() ) )
+    return org_freedesktop_Hal_NoSuchDevice;
+
+  if( !d->deviceMediumUdiMap.contains( d->deviceUdiMap[dev->blockDeviceName()] ) )
+    return org_freedesktop_Hal_Device_Volume_NoSuchDevice;
+
+  QCString mediumUdi = d->deviceMediumUdiMap[d->deviceUdiMap[dev->blockDeviceName()]];
+
+  if( !( dmesg = dbus_message_new_method_call( "org.freedesktop.Hal", mediumUdi.data(),
+					       "org.freedesktop.Hal.Device.Volume",
+					       "Mount" ) ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) mount failed for " << mediumUdi << ": could not create dbus message\n";
+    return org_freedesktop_Hal_CommunicationError;
+  }
+
+  char** poptions = qstringListToArray( options );
+
+  QByteArray strMountPoint = mountPoint.local8Bit();
+  QByteArray strFstype = fstype.local8Bit();
+
+  if( !dbus_message_append_args( dmesg,
+				 DBUS_TYPE_STRING, strMountPoint.data(),
+				 DBUS_TYPE_STRING, strFstype.data(),
+				 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &poptions, options.count(),
+				 DBUS_TYPE_INVALID ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) mount failed for " << mediumUdi << ": could not append args to dbus message\n";
+    dbus_message_unref( dmesg );
+    freeArray( poptions, options.count() );
+    return org_freedesktop_Hal_CommunicationError;
+  }
+
+  freeArray( poptions, options.count() );
+
+  int ret = org_freedesktop_Hal_Success;
+
+  dbus_error_init( &error );
+  reply = dbus_connection_send_with_reply_and_block( d->connection, dmesg, -1, &error );
+  if( dbus_error_is_set( &error ) ) {
+    kdError() << "(K3bDevice::HalConnection) mount failed for " << mediumUdi << ": " << error.name << " - " << error.message << endl;
+    if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.NoSuchDevice" ) )
+      ret = org_freedesktop_Hal_Device_Volume_NoSuchDevice;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.PermissionDenied" ) )
+      ret = org_freedesktop_Hal_Device_Volume_PermissionDenied;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.UnknownFilesystemType" ) )
+      ret = org_freedesktop_Hal_Device_Volume_UnknownFilesystemType;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.MountPointNotAvailable" ) )
+      ret = org_freedesktop_Hal_Device_Volume_MountPointNotAvailable;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.AlreadyMounted" ) )
+      ret = org_freedesktop_Hal_Device_Volume_AlreadyMounted;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.InvalidMountpoint" ) )
+      ret = org_freedesktop_Hal_Device_Volume_InvalidMountpoint;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.InvalidMountOption" ) )
+      ret = org_freedesktop_Hal_Device_Volume_InvalidMountOption;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.PermissionDeniedByPolicy" ) )
+      ret = org_freedesktop_Hal_Device_Volume_PermissionDeniedByPolicy;
+
+    dbus_error_free( &error );
+  }
+  else
+    k3bDebug() << "(K3bDevice::HalConnection) mount queued for " << mediumUdi << endl;
+
+  dbus_message_unref( dmesg );
+  if( reply )
+    dbus_message_unref( reply );
+
+  return ret;
+}
+
+
+int K3bDevice::HalConnection::unmount( K3bDevice::Device* dev,
+				       const QStringList& options )
+{
+  //
+  // The code below is based on the code from kioslave/media/mediamanager/halbackend.cpp in the kdebase package
+  // Copyright (c) 2004-2005 Jérôme Lodewyck <jerome dot lodewyck at normalesup dot org>
+  //
+  DBusMessage* dmesg = 0;
+  DBusMessage* reply = 0;
+  DBusError error;
+
+  if( !d->deviceUdiMap.contains( dev->blockDeviceName() ) )
+    return org_freedesktop_Hal_NoSuchDevice;
+
+  if( !d->deviceMediumUdiMap.contains( d->deviceUdiMap[dev->blockDeviceName()] ) )
+    return org_freedesktop_Hal_Device_Volume_NoSuchDevice;
+
+  QCString mediumUdi = d->deviceMediumUdiMap[d->deviceUdiMap[dev->blockDeviceName()]];
+
+  if( !( dmesg = dbus_message_new_method_call( "org.freedesktop.Hal", mediumUdi.data(),
+					       "org.freedesktop.Hal.Device.Volume",
+					       "Unmount" ) ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) unmount failed for " << mediumUdi << ": could not create dbus message\n";
+    return org_freedesktop_Hal_CommunicationError;
+  }
+
+  char** poptions = qstringListToArray( options );
+
+  if( !dbus_message_append_args( dmesg,
+				 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &poptions, options.count(),
+				 DBUS_TYPE_INVALID ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) unmount failed for " << mediumUdi << ": could not append args to dbus message\n";
+    dbus_message_unref( dmesg );
+    freeArray( poptions, options.count() );
+    return org_freedesktop_Hal_CommunicationError;
+  }
+
+  freeArray( poptions, options.count() );
+
+  int ret = org_freedesktop_Hal_Success;
+
+  dbus_error_init( &error );
+  reply = dbus_connection_send_with_reply_and_block( d->connection, dmesg, -1, &error );
+  if( dbus_error_is_set( &error ) ) {
+    kdError() << "(K3bDevice::HalConnection) unmount failed for " << mediumUdi << ": " << error.name << " - " << error.message << endl;
+    if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.NoSuchDevice" ) )
+      ret = org_freedesktop_Hal_Device_Volume_NoSuchDevice;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.PermissionDenied" ) )
+      ret = org_freedesktop_Hal_Device_Volume_PermissionDenied;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.MountPointNotAvailable" ) )
+      ret = org_freedesktop_Hal_Device_Volume_MountPointNotAvailable;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.InvalidUnmountOption" ) )
+      ret = org_freedesktop_Hal_Device_Volume_InvalidUnmountOption;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.InvalidMountpoint" ) )
+      ret = org_freedesktop_Hal_Device_Volume_InvalidMountpoint;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.PermissionDeniedByPolicy" ) )
+      ret = org_freedesktop_Hal_Device_Volume_PermissionDeniedByPolicy;
+
+    dbus_error_free( &error );
+  }
+  else
+    k3bDebug() << "(K3bDevice::HalConnection) unmount queued for " << mediumUdi << endl;
+
+  dbus_message_unref( dmesg );
+  if( reply )
+    dbus_message_unref( reply );
+
+  return ret;
+}
+
+
+int K3bDevice::HalConnection::eject( K3bDevice::Device* dev,
+				     const QStringList& options )
+{
+  //
+  // The code below is based on the code from kioslave/media/mediamanager/halbackend.cpp in the kdebase package
+  // Copyright (c) 2004-2005 Jérôme Lodewyck <jerome dot lodewyck at normalesup dot org>
+  //
+  DBusMessage* dmesg = 0;
+  DBusMessage* reply = 0;
+  DBusError error;
+
+  if( !d->deviceUdiMap.contains( dev->blockDeviceName() ) )
+    return org_freedesktop_Hal_NoSuchDevice;
+
+  if( !d->deviceMediumUdiMap.contains( d->deviceUdiMap[dev->blockDeviceName()] ) )
+    return org_freedesktop_Hal_Device_Volume_NoSuchDevice;
+
+  QCString mediumUdi = d->deviceMediumUdiMap[d->deviceUdiMap[dev->blockDeviceName()]];
+
+  if( !( dmesg = dbus_message_new_method_call( "org.freedesktop.Hal", mediumUdi.data(),
+					       "org.freedesktop.Hal.Device.Volume",
+					       "Eject" ) ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) eject failed for " << mediumUdi << ": could not create dbus message\n";
+    return org_freedesktop_Hal_CommunicationError;
+  }
+
+  char** poptions = qstringListToArray( options );
+
+  if( !dbus_message_append_args( dmesg,
+				 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &poptions, options.count(),
+				 DBUS_TYPE_INVALID ) ) {
+    k3bDebug() << "(K3bDevice::HalConnection) eject failed for " << mediumUdi << ": could not append args to dbus message\n";
+    dbus_message_unref( dmesg );
+    freeArray( poptions, options.count() );
+    return org_freedesktop_Hal_CommunicationError;
+  }
+
+  freeArray( poptions, options.count() );
+
+  int ret = org_freedesktop_Hal_Success;
+
+  dbus_error_init( &error );
+  reply = dbus_connection_send_with_reply_and_block( d->connection, dmesg, -1, &error );
+  if( dbus_error_is_set( &error ) ) {
+    kdError() << "(K3bDevice::HalConnection) eject failed for " << mediumUdi << ": " << error.name << " - " << error.message << endl;
+    if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.NoSuchDevice" ) )
+      ret = org_freedesktop_Hal_Device_Volume_NoSuchDevice;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.PermissionDenied" ) )
+      ret = org_freedesktop_Hal_Device_Volume_PermissionDenied;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.InvalidEjectOption" ) )
+      ret = org_freedesktop_Hal_Device_Volume_InvalidEjectOption;
+    else if( !strcmp(error.name, "org.freedesktop.Hal.Device.Volume.PermissionDeniedByPolicy" ) )
+      ret = org_freedesktop_Hal_Device_Volume_PermissionDeniedByPolicy;
+
+    dbus_error_free( &error );
+  }
+  else
+    k3bDebug() << "(K3bDevice::HalConnection) eject queued for " << mediumUdi << endl;
+
+  dbus_message_unref( dmesg );
+  if( reply )
+    dbus_message_unref( reply );
+
+  return ret;
+}
+
+
+void K3bDevice::HalConnection::setupDBusQtConnection( DBusConnection* dbusConnection )
+{
+  d->dBusQtConnection = new DBusQt::Connection( this );
+  d->dBusQtConnection->dbus_connection_setup_with_qt_main( dbusConnection );
+}
+
+#include "k3bhalconnection.moc"
diff --git a/libk3bdevice/k3bhalconnection.h b/libk3bdevice/k3bhalconnection.h
new file mode 100644
index 0000000..583bbf2
--- /dev/null
+++ b/libk3bdevice/k3bhalconnection.h
@@ -0,0 +1,223 @@
+/* 
+ *
+ * $Id: sourceheader,v 1.3 2005/01/19 13:03:46 trueg Exp $
+ * Copyright (C) 2005-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#ifndef _K3B_HAL_CONNECTION_H_
+#define _K3B_HAL_CONNECTION_H_
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "k3bdevice_export.h"
+
+#include <qobject.h>
+#include <qmap.h>
+#include <qstringlist.h>
+
+class DBusConnection;
+
+
+namespace K3bDevice {
+
+  class Device;
+
+  /**
+   * This is a simple HAL/DBUS wrapper which creates QT signals whenever a new optical
+   * drive is plugged into the system or one is unplugged.
+   *
+   * The HalConnection class also handles media changes. Whenever a new medium is inserted
+   * into a drive or a medium is removed (i.e. ejected) a signal is emitted. This way it
+   * is easy to keep track of the inserted media.
+   *
+   * This class does not deal with K3b devices but with system device names
+   * such as /dev/cdrom. These device names can be used in DeviceManager::findDevice().
+   */
+  class LIBK3BDEVICE_EXPORT HalConnection : public QObject
+    {
+      Q_OBJECT
+
+    public:
+      ~HalConnection();
+
+      /**
+       * Creates a new singleton HalConnection object or returns the already existing one.
+       * A newly created HalConnection will emit newDevice signals for all devices in the HAL
+       * manager. However, since one cannot be sure if this is the first time the HalConnection
+       * is created it is recommended to connect to the signals and query the list of current
+       * devices.
+       *
+       * \return An instance of the singleton HalConnection object.
+       */
+      static HalConnection* instance();
+
+      /**
+       * \return true if a connection to the HAL deamon could be established and
+       *         communication has been set up.
+       */
+      bool isConnected() const;
+
+      /**
+       * \return a list of optical devices as reported by HAL.
+       */
+      QStringList devices() const;
+
+      /**
+       * \internal
+       */
+      void addDevice( const char* udi );
+
+      /**
+       * \internal
+       */
+      void removeDevice( const char* udi );
+
+      /**
+       * Error codes named as the HAL deamon raises them
+       */
+      enum ErrorCodes {
+	org_freedesktop_Hal_Success = 0, //*< The operation was successful. This code does not match any in HAL
+	org_freedesktop_Hal_CommunicationError, //*< DBus communication error. This code does not match any in HAL
+	org_freedesktop_Hal_NoSuchDevice,
+	org_freedesktop_Hal_DeviceAlreadyLocked,
+	org_freedesktop_Hal_PermissionDenied,
+	org_freedesktop_Hal_Device_Volume_NoSuchDevice,
+	org_freedesktop_Hal_Device_Volume_PermissionDenied,
+	org_freedesktop_Hal_Device_Volume_AlreadyMounted,
+	org_freedesktop_Hal_Device_Volume_InvalidMountOption,
+	org_freedesktop_Hal_Device_Volume_UnknownFilesystemType,
+	org_freedesktop_Hal_Device_Volume_InvalidMountpoint,
+	org_freedesktop_Hal_Device_Volume_MountPointNotAvailable,
+	org_freedesktop_Hal_Device_Volume_PermissionDeniedByPolicy,
+	org_freedesktop_Hal_Device_Volume_InvalidUnmountOption,
+	org_freedesktop_Hal_Device_Volume_InvalidEjectOption
+      };
+
+     public slots:
+      /**
+       * Lock the device in HAL
+       * 
+       * Be aware that once the method returns the HAL deamon has not necessarily 
+       * finished the procedure yet.
+       *
+       * \param dev The device to lock
+       * \return An error code
+       *
+       * \see ErrorCode
+       */
+      int lock( Device* );
+
+      /**
+       * Unlock a previously locked device in HAL
+       * 
+       * Be aware that once the method returns the HAL deamon has not necessarily 
+       * finished the procedure yet.
+       *
+       * \param dev The device to lock
+       * \return An error code
+       *
+       * \see ErrorCode
+       */
+      int unlock( Device* );
+
+      /**
+       * Mounts a device via HAL
+       * 
+       * Be aware that once the method returns the HAL deamon has not necessarily 
+       * finished the procedure yet.
+       *
+       * \param dev The device to lock
+       * \return An error code
+       *
+       * \see ErrorCode
+       */
+      int mount( Device*, 
+		 const QString& mountPoint = QString::null, 
+		 const QString& fstype = QString::null,
+		 const QStringList& options = QStringList() );
+
+      /**
+       * Unmounts a device via HAL
+       * 
+       * Be aware that once the method returns the HAL deamon has not necessarily 
+       * finished the procedure yet.
+       *
+       * \param dev The device to lock
+       * \return An error code
+       *
+       * \see ErrorCode
+       */
+      int unmount( Device*,
+		   const QStringList& options = QStringList() );
+
+      /**
+       * Unmounts a device via HAL
+       * 
+       * Be aware that once the method returns the HAL deamon has not necessarily 
+       * finished the procedure yet.
+       *
+       * \param dev The device to lock
+       * \return An error code
+       *
+       * \see ErrorCode
+       */
+      int eject( Device*,
+		 const QStringList& options = QStringList() );
+
+    signals:
+      /**
+       * This signal gets emitted whenever HAL finds a new optical drive.
+       *
+       * \param dev The block device name of the new drive.
+       */
+      void deviceAdded( const QString& dev );
+
+      /**
+       * This signal gets emitted whenever HAL detects that an optical drive
+       * has been unplugged.
+       *
+       * \param dev The block device name of the drive.
+       */
+      void deviceRemoved( const QString& dev );
+
+      /**
+       * This signal gets emitted whenever a new medium is inserted into a
+       * device or an inserted is removed (i.e. ejected)
+       *
+       * \param dev The block device name of the drive the medium is or was inserted into.
+       */
+      void mediumChanged( const QString& dev );
+
+    private:
+      /**
+       * HalConnection is a signelton class. Use the instance() method to create it.
+       */
+      HalConnection( QObject* parent = 0, const char* name = 0 );
+
+      /**
+       * Tries to open a connection to HAL.
+       */
+      bool open();
+      void close();
+
+      static HalConnection* s_instance;
+
+      class Private;
+      Private* d;
+
+      void setupDBusQtConnection( DBusConnection* dbusConnection );
+    };
+}
+
+#endif
diff --git a/libk3bdevice/k3bmmc.h b/libk3bdevice/k3bmmc.h
new file mode 100644
index 0000000..ebe2171
--- /dev/null
+++ b/libk3bdevice/k3bmmc.h
@@ -0,0 +1,697 @@
+/* 
+ *
+ * $Id: k3bmmc.h 630384 2007-02-05 09:33:17Z mlaurent $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#ifndef _K3B_MMC_H_
+#define _K3B_MMC_H_
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+
+namespace K3bDevice 
+{
+  /* 
+   * struct disc_info taken from cdrwtool.h
+   *
+   *
+   * disc status (status):
+   *     00b - empty disc
+   *     01b - incomplete disc (appendable)
+   *     10b - Complete disc
+   *     11b - Others
+   *
+   * State of last session (border)
+   *     00b - Empty session
+   *     01b - Incomplete session
+   *     10b - Reseverd
+   *     11b - Complete session (only possible when disc status is complete)
+   */
+
+  typedef struct disc_info {
+    Q_UINT16 length;
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char reserved1 : 3;
+    unsigned char erasable  : 1;
+    unsigned char border    : 2;
+    unsigned char status    : 2;
+#else
+    unsigned char status    : 2;
+    unsigned char border    : 2;
+    unsigned char erasable  : 1;
+    unsigned char reserved1 : 3;
+#endif
+    unsigned char n_first_track;
+    unsigned char n_sessions_l;
+    unsigned char first_track_l;
+    unsigned char last_track_l;
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char did_v     : 1;
+    unsigned char dbc_v     : 1;
+    unsigned char uru       : 1;
+    unsigned char reserved2 : 2;
+    unsigned char dbit      : 1;
+    unsigned char bg_f_status : 1;
+#else
+    unsigned char bg_f_status : 1;
+    unsigned char dbit      : 1;
+    unsigned char reserved2 : 2;
+    unsigned char uru       : 1;
+    unsigned char dbc_v     : 1;
+    unsigned char did_v     : 1;
+#endif
+
+    /*
+     * disc type
+     *    00h - CD-DA of CDROM
+     *    10h - CD-I
+     *    20h - CD-ROM XA
+     *    FFh - Undefined
+     *    All other values are reserved
+     */
+    unsigned char disc_type;
+    unsigned char n_sessions_m;
+    unsigned char first_track_m;
+    unsigned char last_track_m;
+    Q_UINT32 disc_id;
+
+    /*
+     * Last session lead-in start time
+     * if the disc is complete this shall be FF/FF/FF
+     */
+    unsigned char lead_in_r;
+    unsigned char lead_in_m;
+    unsigned char lead_in_s;
+    unsigned char lead_in_f;
+
+    /*
+     * Last possible start time for start of lead-in
+     * if the disc is complete this shall be FF/FF/FF
+     */
+    unsigned char lead_out_r;
+    unsigned char lead_out_m;
+    unsigned char lead_out_s;
+    unsigned char lead_out_f;
+
+    unsigned char disc_bar_code[8];
+
+    //
+    // We need to make sure the structure has a proper size
+    // I think it needs to be a power of 2.
+    // With ide-scsi there is no problem. But without the
+    // GPCMD_READ_DISC_INFO command failes if the size is 34
+    //
+
+/*     unsigned char reserved3; */
+/*     unsigned char opc_entries; */
+  } disc_info_t;
+
+
+
+  /* 
+   * struct track_info taken from cdrwtool.h
+   */
+  typedef struct track_info {
+    unsigned char data_length[2];
+    unsigned char track_number_l;
+    unsigned char session_number_l;
+    unsigned char reserved1;
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char reserved2       : 2;
+    unsigned char damage          : 1;
+    unsigned char copy            : 1;
+    unsigned char track_mode      : 4;
+    unsigned char rt              : 1;
+    unsigned char blank           : 1;
+    unsigned char packet          : 1;
+    unsigned char fp              : 1;
+    unsigned char data_mode       : 4;
+    unsigned char reserved3       : 6;
+    unsigned char lra_v           : 1;
+    unsigned char nwa_v           : 1;
+#else
+    unsigned char track_mode      : 4;
+    unsigned char copy            : 1;
+    unsigned char damage          : 1;
+    unsigned char reserved2       : 2;
+    unsigned char data_mode       : 4;
+    unsigned char fp              : 1;
+    unsigned char packet          : 1;
+    unsigned char blank           : 1;
+    unsigned char rt              : 1;
+    unsigned char nwa_v           : 1;
+    unsigned char lra_v           : 1;
+    unsigned char reserved3       : 6;
+#endif
+    unsigned char track_start[4];
+    unsigned char next_writable[4];
+    unsigned char free_blocks[4];
+    unsigned char packet_size[4];
+    unsigned char track_size[4];
+    unsigned char last_recorded[4];
+    unsigned char track_number_m;
+    unsigned char session_number_m;
+    unsigned char reserved4;
+    unsigned char reserved5;
+    unsigned char read_compatibility[4];
+  } track_info_t;
+
+
+  /*
+   * Use this with the GPCMD_READ_TOC_PMA_ATIP command
+   * where format is set to 2 (Full TOC)
+   */
+  struct toc_raw_track_descriptor {
+    unsigned char session_number;
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char adr     : 4;
+    unsigned char control : 4;
+#else
+    unsigned char control : 4;
+    unsigned char adr     : 4;
+#endif
+    unsigned char tno;
+    unsigned char point;
+    unsigned char min;
+    unsigned char sec;
+    unsigned char frame;
+    unsigned char zero;
+    unsigned char p_min;
+    unsigned char p_sec;
+    unsigned char p_frame;
+  };
+
+
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+  struct cd_wr_speed_performance {
+    unsigned char res0;                   /* Reserved                          */
+    unsigned char res_1_27        : 6;    /* Reserved                          */
+    unsigned char rot_ctl_sel     : 2;    /* Rotational control selected       */
+    unsigned char wr_speed_supp[2];       /* Supported write speed             */
+  };
+#else
+  struct cd_wr_speed_performance {
+    unsigned char res0;                   /* Reserved                          */
+    unsigned char rot_ctl_sel     : 2;    /* Rotational control selected       */
+    unsigned char res_1_27        : 6;    /* Reserved                          */
+    unsigned char wr_speed_supp[2];       /* Supported write speed             */
+  };
+#endif
+
+
+  /**
+   * Based on the cdrecord struct cd_mode_page_2A
+   * MM Capabilities and Mechanical Status Page
+   */
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+
+  struct mm_cap_page_2A {
+    unsigned char PS               : 1;
+    unsigned char res_1            : 1;
+    unsigned char page_code        : 6;
+    unsigned char page_len;             /* 0x14 = 20 Bytes (MMC) */
+                                        /* 0x18 = 24 Bytes (MMC-2) */
+                                        /* 0x1C >= 28 Bytes (MMC-3) */
+    unsigned char res_2_67         : 2; /* Reserved        */
+    unsigned char dvd_ram_read     : 1; /* Reads DVD-RAM media       */
+    unsigned char dvd_r_read       : 1; /* Reads DVD-R media       */
+    unsigned char dvd_rom_read     : 1; /* Reads DVD ROM media       */
+    unsigned char method2          : 1; /* Reads fixed packet method2 media  */
+    unsigned char cd_rw_read       : 1; /* Reads CD-RW media       */
+    unsigned char cd_r_read        : 1; /* Reads CD-R  media       */
+    unsigned char res_3_67         : 2; /* Reserved        */
+    unsigned char dvd_ram_write    : 1; /* Supports writing DVD-RAM media    */
+    unsigned char dvd_r_write      : 1; /* Supports writing DVD-R media      */
+    unsigned char res_3_3          : 1; /* Reserved        */
+    unsigned char test_write       : 1; /* Supports emulation write      */
+    unsigned char cd_rw_write      : 1; /* Supports writing CD-RW media      */
+    unsigned char cd_r_write       : 1; /* Supports writing CD-R  media      */
+    unsigned char BUF              : 1; /* Supports Buffer under. free rec.  */
+    unsigned char multi_session    : 1; /* Reads multi-session media      */
+    unsigned char mode_2_form_2    : 1; /* Reads Mode-2 form 2 media      */
+    unsigned char mode_2_form_1    : 1; /* Reads Mode-2 form 1 media (XA)    */
+    unsigned char digital_port_1   : 1; /* Supports digital output on port 1 */
+    unsigned char digital_port_2   : 1; /* Supports digital output on port 2 */
+    unsigned char composite        : 1; /* Deliveres composite A/V stream    */
+    unsigned char audio_play       : 1; /* Supports Audio play operation     */
+    unsigned char read_bar_code    : 1; /* Supports reading bar codes      */
+    unsigned char UPC              : 1; /* Reads media catalog number (UPC)  */
+    unsigned char ISRC             : 1; /* Reads ISRC information      */
+    unsigned char c2_pointers      : 1; /* Supports C2 error pointers      */
+    unsigned char rw_deint_corr    : 1; /* Reads de-interleved R-W sub chan  */
+    unsigned char rw_supported     : 1; /* Reads R-W sub channel information */
+    unsigned char cd_da_accurate   : 1; /* READ CD data stream is accurate   */
+    unsigned char cd_da_supported  : 1; /* Reads audio data with READ CD cmd */
+    unsigned char loading_type     : 3; /* Loading mechanism type      */
+    unsigned char res_6_4          : 1; /* Reserved        */
+    unsigned char eject            : 1; /* Ejects disc/cartr with STOP LoEj  */
+    unsigned char prevent_jumper   : 1; /* State of prev/allow jumper 0=pres */
+    unsigned char lock_state       : 1; /* Lock state 0=unlocked 1=locked    */
+    unsigned char lock             : 1; /* PREVENT/ALLOW may lock media      */
+    unsigned char res_7            : 2; /* Reserved        */
+    unsigned char rw_in_lead_in    : 1; /* Reads raw R-W subcode from lead in */
+    unsigned char side_change      : 1; /* Side change capable       */
+    unsigned char sw_slot_sel      : 1; /* Load empty slot in changer      */
+    unsigned char disk_present_rep : 1; /* Changer supports disk present rep */
+    unsigned char sep_chan_mute    : 1; /* Mute controls each channel separat*/
+    unsigned char sep_chan_vol     : 1; /* Vol controls each channel separat */
+    unsigned char max_read_speed[2];    /* Max. read speed in KB/s      */
+                                        /* obsolete in MMC-4 */
+    unsigned char num_vol_levels[2];    /* # of supported volume levels      */
+    unsigned char buffer_size[2];       /* Buffer size for the data in KB    */
+    unsigned char cur_read_speed[2];    /* Current read speed in KB/s      */
+                                        /* obsolete in MMC-4 */
+    unsigned char res_16;               /* Reserved        */
+    unsigned char res_17           : 2; /* Reserved        */
+    unsigned char length           : 2; /* 0=32BCKs 1=16BCKs 2=24BCKs 3=24I2c*/
+    unsigned char LSBF             : 1; /* Set: LSB first Clear: MSB first   */
+    unsigned char RCK              : 1; /* Set: HIGH high LRCK=left channel  */
+    unsigned char BCK              : 1; /* Data valid on falling edge of BCK */
+    unsigned char res_17_0         : 1; /* Reserved        */
+    unsigned char max_write_speed[2];   /* Max. write speed supported in KB/s*/
+                                        /* obsolete in MMC-4 */
+    unsigned char cur_write_speed[2];   /* Current write speed in KB/s      */
+                                        /* obsolete in MMC-4 */
+
+    /* Byte 22 ... Only in MMC-2      */
+    unsigned char copy_man_rev[2];      /* Copy management revision supported*/
+    unsigned char res_24;               /* Reserved        */
+    unsigned char res_25;               /* Reserved        */
+
+    /* Byte 26 ... Only in MMC-3      */
+    unsigned char res_26;               /* Reserved        */
+    unsigned char res_27_27        : 6; /* Reserved        */
+    unsigned char rot_ctl_sel      : 2; /* Rotational control selected      */
+    unsigned char v3_cur_write_speed[2]; /* Current write speed in KB/s      */
+    unsigned char num_wr_speed_des[2];  /* # of wr speed perf descr. tables  */
+    struct cd_wr_speed_performance
+    wr_speed_des[1];                    /* wr speed performance descriptor   */
+                                        /* Actually more (num_wr_speed_des)  */
+  };
+
+#else  // LITTLE_ENDIAN
+
+  struct mm_cap_page_2A {
+    unsigned char page_code        : 6;
+    unsigned char res_1            : 1;
+    unsigned char PS               : 1;
+    unsigned char page_len;             /* 0x14 = 20 Bytes (MMC) */
+                                        /* 0x18 = 24 Bytes (MMC-2) */
+                                        /* 0x1C >= 28 Bytes (MMC-3) */
+    unsigned char cd_r_read        : 1; /* Reads CD-R  media       */
+    unsigned char cd_rw_read       : 1; /* Reads CD-RW media       */
+    unsigned char method2          : 1; /* Reads fixed packet method2 media  */
+    unsigned char dvd_rom_read     : 1; /* Reads DVD ROM media       */
+    unsigned char dvd_r_read       : 1; /* Reads DVD-R media       */
+    unsigned char dvd_ram_read     : 1; /* Reads DVD-RAM media       */
+    unsigned char res_2_67         : 2; /* Reserved        */
+    unsigned char cd_r_write       : 1; /* Supports writing CD-R  media      */
+    unsigned char cd_rw_write      : 1; /* Supports writing CD-RW media      */
+    unsigned char test_write       : 1; /* Supports emulation write      */
+    unsigned char res_3_3          : 1; /* Reserved        */
+    unsigned char dvd_r_write      : 1; /* Supports writing DVD-R media      */
+    unsigned char dvd_ram_write    : 1; /* Supports writing DVD-RAM media    */
+    unsigned char res_3_67         : 2; /* Reserved        */
+    unsigned char audio_play       : 1; /* Supports Audio play operation     */
+    unsigned char composite        : 1; /* Deliveres composite A/V stream    */
+    unsigned char digital_port_2   : 1; /* Supports digital output on port 2 */
+    unsigned char digital_port_1   : 1; /* Supports digital output on port 1 */
+    unsigned char mode_2_form_1    : 1; /* Reads Mode-2 form 1 media (XA)    */
+    unsigned char mode_2_form_2    : 1; /* Reads Mode-2 form 2 media      */
+    unsigned char multi_session    : 1; /* Reads multi-session media      */
+    unsigned char BUF              : 1; /* Supports Buffer under. free rec.  */
+    unsigned char cd_da_supported  : 1; /* Reads audio data with READ CD cmd */
+    unsigned char cd_da_accurate   : 1; /* READ CD data stream is accurate   */
+    unsigned char rw_supported     : 1; /* Reads R-W sub channel information */
+    unsigned char rw_deint_corr    : 1; /* Reads de-interleved R-W sub chan  */
+    unsigned char c2_pointers      : 1; /* Supports C2 error pointers      */
+    unsigned char ISRC             : 1; /* Reads ISRC information      */
+    unsigned char UPC              : 1; /* Reads media catalog number (UPC)  */
+    unsigned char read_bar_code    : 1; /* Supports reading bar codes      */
+    unsigned char lock             : 1; /* PREVENT/ALLOW may lock media      */
+    unsigned char lock_state       : 1; /* Lock state 0=unlocked 1=locked    */
+    unsigned char prevent_jumper   : 1; /* State of prev/allow jumper 0=pres */
+    unsigned char eject            : 1; /* Ejects disc/cartr with STOP LoEj  */
+    unsigned char res_6_4          : 1; /* Reserved        */
+    unsigned char loading_type     : 3; /* Loading mechanism type      */
+    unsigned char sep_chan_vol     : 1; /* Vol controls each channel separat */
+    unsigned char sep_chan_mute    : 1; /* Mute controls each channel separat*/
+    unsigned char disk_present_rep : 1; /* Changer supports disk present rep */
+    unsigned char sw_slot_sel      : 1; /* Load empty slot in changer      */
+    unsigned char side_change      : 1; /* Side change capable       */
+    unsigned char rw_in_lead_in    : 1; /* Reads raw R-W subcode from lead in */
+    unsigned char res_7            : 2; /* Reserved        */
+    unsigned char max_read_speed[2];    /* Max. read speed in KB/s      */
+                                        /* obsolete in MMC-4 */
+    unsigned char num_vol_levels[2];    /* # of supported volume levels      */
+    unsigned char buffer_size[2];       /* Buffer size for the data in KB    */
+    unsigned char cur_read_speed[2];    /* Current read speed in KB/s      */
+                                        /* obsolete in MMC-4 */
+    unsigned char res_16;               /* Reserved        */
+    unsigned char res_17_0         : 1; /* Reserved        */
+    unsigned char BCK              : 1; /* Data valid on falling edge of BCK */
+    unsigned char RCK              : 1; /* Set: HIGH high LRCK=left channel  */
+    unsigned char LSBF             : 1; /* Set: LSB first Clear: MSB first   */
+    unsigned char length           : 2; /* 0=32BCKs 1=16BCKs 2=24BCKs 3=24I2c*/
+    unsigned char res_17           : 2; /* Reserved        */
+    unsigned char max_write_speed[2];   /* Max. write speed supported in KB/s*/
+                                        /* obsolete in MMC-4 */
+    unsigned char cur_write_speed[2];   /* Current write speed in KB/s      */
+                                        /* obsolete in MMC-4 */
+
+    /* Byte 22 ... Only in MMC-2      */
+    unsigned char copy_man_rev[2];      /* Copy management revision supported*/
+    unsigned char res_24;               /* Reserved        */
+    unsigned char res_25;               /* Reserved        */
+
+    /* Byte 26 ... Only in MMC-3      */
+    unsigned char res_26;               /* Reserved        */
+    unsigned char rot_ctl_sel      : 2; /* Rotational control selected      */
+    unsigned char res_27_27        : 6; /* Reserved        */
+    unsigned char v3_cur_write_speed[2]; /* Current write speed in KB/s      */
+    unsigned char num_wr_speed_des[2];  /* # of wr speed perf descr. tables  */
+    struct cd_wr_speed_performance
+    wr_speed_des[1];                    /* wr speed performance descriptor   */
+                                        /* Actually more (num_wr_speed_des)  */
+  };
+#endif
+
+  /**
+   * Based on the cdrecord struct cd_mode_page_05
+   * Write Parameters Mode Page
+   */
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+  struct wr_param_page_05 {                /* write parameters */
+    unsigned char PS               : 1;
+    unsigned char res_1            : 1;
+    unsigned char page_code        : 6;
+    unsigned char page_len;                /* 0x32 = 50 Bytes */
+    unsigned char res_2_7          : 1;
+    unsigned char BUFE             : 1;    /* Enable Bufunderrun free rec.      */
+    unsigned char LS_V             : 1;    /* Link size valid                   */
+    unsigned char test_write       : 1;    /* Do not actually write data        */
+    unsigned char write_type       : 4;    /* Session write type (PACKET/TAO...)*/
+    unsigned char multi_session    : 2;    /* Multi session write type          */
+    unsigned char fp               : 1;    /* Fixed packed (if in packet mode)  */
+    unsigned char copy             : 1;    /* 1st higher gen of copy prot track */
+    unsigned char track_mode       : 4;    /* Track mode (Q-sub control nibble) */
+    unsigned char res_4            : 4;    /* Reserved                          */
+    unsigned char dbtype           : 4;    /* Data block type                   */
+    unsigned char link_size;               /* Link Size (default is 7)          */
+    unsigned char res_6;                   /* Reserved                          */
+    unsigned char res_7            : 2;    /* Reserved                          */
+    unsigned char host_appl_code   : 6;    /* Host application code of disk     */
+    unsigned char session_format;          /* Session format (DA/CDI/XA)        */
+    unsigned char res_9;                   /* Reserved                          */
+    unsigned char packet_size[4];          /* # of user datablocks/fixed packet */
+    unsigned char audio_pause_len[2];      /* # of blocks where index is zero   */
+    unsigned char media_cat_number[16];    /* Media catalog Number (MCN)        */
+    unsigned char ISRC[14];                /* ISRC for this track               */
+    unsigned char sub_header[4];
+    unsigned char vendor_uniq[4];
+  };
+
+#else // __LITTLE_ENDIAN
+  struct wr_param_page_05 {		/* write parameters */
+    unsigned char page_code        : 6;
+    unsigned char res_1            : 1;
+    unsigned char PS               : 1;
+    unsigned char p_len;		/* 0x32 = 50 Bytes */
+    unsigned char write_type	   : 4;	/* Session write type (PACKET/TAO...)*/
+    unsigned char test_write	   : 1;	/* Do not actually write data	     */
+    unsigned char LS_V		   : 1;	/* Link size valid		     */
+    unsigned char BUFE		   : 1;	/* Enable Bufunderrun free rec.	     */
+    unsigned char res_2_7	   : 1;
+    unsigned char track_mode	   : 4;	/* Track mode (Q-sub control nibble) */
+    unsigned char copy		   : 1;	/* 1st higher gen of copy prot track ~*/
+    unsigned char fp		   : 1;	/* Fixed packed (if in packet mode)  */
+    unsigned char multi_session	   : 2;	/* Multi session write type	     */
+    unsigned char dbtype	   : 4;	/* Data block type		     */
+    unsigned char res_4		   : 4;	/* Reserved			     */
+    unsigned char link_size;		/* Link Size (default is 7)	     */
+    unsigned char res_6;	       	/* Reserved			     */
+    unsigned char host_appl_code   : 6;	/* Host application code of disk     */
+    unsigned char res_7		   : 2;	/* Reserved			     */
+    unsigned char session_format;	/* Session format (DA/CDI/XA)	     */
+    unsigned char res_9;		/* Reserved			     */
+    unsigned char packet_size[4];	/* # of user datablocks/fixed packet */
+    unsigned char audio_pause_len[2];	/* # of blocks where index is zero   */
+    unsigned char media_cat_number[16];	/* Media catalog Number (MCN)	     */
+    unsigned char ISRC[14];		/* ISRC for this track		     */
+    unsigned char sub_header[4];
+    unsigned char vendor_uniq[4];
+  };
+#endif
+
+
+  struct toc_track_descriptor {
+    unsigned char res1;
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char adr     : 4;
+    unsigned char control : 4;
+#else
+    unsigned char control : 4;
+    unsigned char adr     : 4;
+#endif
+    unsigned char track_no;
+    unsigned char res2;
+    unsigned char start_adr[4];
+  };
+
+
+  struct atip_descriptor {
+    unsigned char dataLength[2];
+    unsigned char res1;
+    unsigned char res2;
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char ind_wr_power : 4;  // indicated writing power
+    unsigned char ddcd         : 1;  // DDCD
+    unsigned char ref_speed    : 3;  // reference Speed
+    unsigned char zero         : 1;  // 0
+    unsigned char uru          : 1;  // Uru
+    unsigned char res3         : 6;
+    unsigned char one          : 1;  // 1
+    unsigned char disc_type    : 1;  // Disc Type
+    unsigned char disc_subtype : 3;  // Disc Sub-Type
+    unsigned char a1_valid     : 1;
+    unsigned char a2_valid     : 1;
+    unsigned char a3_valid     : 1;
+#else
+    unsigned char ref_speed    : 3;  // reference Speed
+    unsigned char ddcd         : 1;  // DDCD
+    unsigned char ind_wr_power : 4;  // indicated writing power
+    unsigned char res3         : 6;
+    unsigned char uru          : 1;  // Uru
+    unsigned char zero         : 1;  // 0
+    unsigned char a3_valid     : 1;
+    unsigned char a2_valid     : 1;
+    unsigned char a1_valid     : 1;
+    unsigned char disc_subtype : 3;  // Disc Sub-Type
+    unsigned char disc_type    : 1;  // Disc Type
+    unsigned char one          : 1;  // 1
+#endif
+    unsigned char res4;
+    unsigned char lead_in_m;
+    unsigned char lead_in_s;
+    unsigned char lead_in_f;
+    unsigned char res5;
+    unsigned char lead_out_m;
+    unsigned char lead_out_s;
+    unsigned char lead_out_f;
+    unsigned char res6;
+    unsigned char a1[3];
+    unsigned char res7;
+    unsigned char a2[3];
+    unsigned char res8;
+    unsigned char a3[3];
+    unsigned char res9;
+    unsigned char s4[3];
+    unsigned char res10;
+  };
+
+
+  struct mechanism_status_header {
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char fault         : 1;
+    unsigned char changer_state : 2;
+    unsigned char slot_low      : 5;
+#else
+    unsigned char slot_low      : 5;
+    unsigned char changer_state : 2;
+    unsigned char fault         : 1;
+#endif
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char mech_state    : 3;
+    unsigned char door_open     : 1;
+    unsigned char res1          : 1;
+    unsigned char slot_high     : 3;
+#else
+    unsigned char slot_high     : 3;
+    unsigned char res1          : 1;
+    unsigned char door_open     : 1;
+    unsigned char mech_state    : 3;
+#endif
+    unsigned char current_lba[3];
+    unsigned char num_slots;
+    unsigned char slot_len[2];
+  };
+
+  struct mechanism_status_slot {
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char disc_present  : 1;
+    unsigned char res1          : 6;
+    unsigned char change        : 1;
+#else
+    unsigned char change        : 1;
+    unsigned char res1          : 6;
+    unsigned char disc_present  : 1;
+#endif
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char res2          : 6;
+    unsigned char cwp_v         : 1;
+    unsigned char cwp           : 1;
+#else
+    unsigned char cwp           : 1;
+    unsigned char cwp_v         : 1;
+    unsigned char res2          : 6;
+#endif
+    unsigned char res3;
+    unsigned char res4;
+  };
+
+
+  struct inquiry {
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char p_qualifier   : 3;
+    unsigned char p_device_type : 5;
+    unsigned char rmb           : 1;
+    unsigned char reserved1     : 7;
+#else
+    unsigned char p_device_type : 5;
+    unsigned char p_qualifier   : 3;
+    unsigned char reserved1     : 7;
+    unsigned char rmb           : 1;
+#endif
+    unsigned char version;
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char interface_dep : 4;
+    unsigned char data_format   : 4;
+#else
+    unsigned char data_format   : 4;
+    unsigned char interface_dep : 4;
+#endif
+    unsigned char add_length;
+    unsigned char reserved2;
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char bque          : 1;
+    unsigned char enc_serv      : 1;
+    unsigned char vs1           : 1;
+    unsigned char multi_p       : 1;
+    unsigned char m_chngr       : 1;
+    unsigned char reserved3     : 1;
+    unsigned char reserved4     : 1;
+    unsigned char addr_16       : 1;
+    unsigned char rel_adr       : 1;
+    unsigned char reserved5     : 1;
+    unsigned char w_bus_16      : 1;
+    unsigned char sync          : 1;
+    unsigned char linked        : 1;
+    unsigned char reserved6     : 1;
+    unsigned char cmd_que       : 1;
+    unsigned char vs2           : 1;
+#else
+    unsigned char addr_16       : 1;
+    unsigned char reserved4     : 1;
+    unsigned char reserved3     : 1;
+    unsigned char m_chngr       : 1;
+    unsigned char multi_p       : 1;
+    unsigned char vs1           : 1;
+    unsigned char enc_serv      : 1;
+    unsigned char bque          : 1;
+    unsigned char vs2           : 1;
+    unsigned char cmd_que       : 1;
+    unsigned char reserved6     : 1;
+    unsigned char linked        : 1;
+    unsigned char sync          : 1;
+    unsigned char w_bus_16      : 1;
+    unsigned char reserved5     : 1;
+    unsigned char rel_adr       : 1;
+#endif
+    unsigned char vendor[8];
+    unsigned char product[16];
+    unsigned char revision[4];
+    unsigned char vendor_specific[20];
+    unsigned char reserved7[2];
+    unsigned char version1[2];
+    unsigned char version2[2];
+    unsigned char version3[2];
+    unsigned char version4[2];
+    unsigned char version5[2];
+    unsigned char version6[2];
+    unsigned char version7[2];
+    unsigned char version8[2];
+
+    // bytes 74-95: reserved
+    // bytes 96-n: vendor specific
+  };
+
+
+  struct ricoh_mode_page_30 {
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char PS               : 1;
+    unsigned char res_1            : 1;
+    unsigned char page_code        : 6;
+#else
+    unsigned char page_code        : 6;
+    unsigned char res_1            : 1;
+    unsigned char PS               : 1;
+#endif
+    unsigned char page_len;                  /* 0xE = 14 Bytes */
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char res_2_67        :2;
+    unsigned char AWSCS           :1;     /* Auto write speed control supp. */
+    unsigned char ARSCS           :1;     /* Auto read speed control supp. */
+    unsigned char res_2_23        :2;
+    unsigned char TWBFS           :1;     /* Test Burn-Free sup.  */
+    unsigned char BUEFS           :1;     /* Burn-Free supported  */
+#else
+    unsigned char BUEFS           :1;     /* Burn-Free supported  */
+    unsigned char TWBFS           :1;     /* Test Burn-Free sup.  */
+    unsigned char res_2_23        :2;
+    unsigned char ARSCS           :1;     /* Auto read speed control supp. */
+    unsigned char AWSCS           :1;     /* Auto write speed control supp. */
+    unsigned char res_2_67        :2;
+#endif
+#ifdef WORDS_BIGENDIAN // __BYTE_ORDER == __BIG_ENDIAN
+    unsigned char res_3_67        :2;
+    unsigned char AWSCD           :1;     /* Auto write speed control disabled */
+    unsigned char ARSCE           :1;     /* Auto read speed control enabled */
+    unsigned char res_2_13        :3;
+    unsigned char BUEFE           :1;     /* Burn-Free enabled    */
+#else
+    unsigned char BUEFE           :1;     /* Burn-Free enabled    */
+    unsigned char res_2_13        :3;
+    unsigned char ARSCE           :1;     /* Auto read speed control enabled */
+    unsigned char AWSCD           :1;     /* Auto write speed control disabled */
+    unsigned char res_3_67        :2;
+#endif
+    unsigned char link_counter[2];        /* Burn-Free link counter */
+    unsigned char res[10];                /* Padding up to 16 bytes */
+  };
+}
+
+
+#endif
diff --git a/libk3bdevice/k3bmsf.cpp b/libk3bdevice/k3bmsf.cpp
new file mode 100644
index 0000000..c7257a1
--- /dev/null
+++ b/libk3bdevice/k3bmsf.cpp
@@ -0,0 +1,335 @@
+/* 
+ *
+ * $Id: k3bmsf.cpp 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include "k3bmsf.h"
+#include <qregexp.h>
+
+#include <math.h>
+
+
+K3b::Msf::Msf()
+  : m_minutes(0),
+    m_seconds(0),
+    m_frames(0)
+{
+}
+
+K3b::Msf::Msf( const K3b::Msf& m )
+  : m_minutes(m.minutes()),
+    m_seconds(m.seconds()),
+    m_frames(m.frames())
+{
+}
+
+K3b::Msf::Msf( int m, int s, int f )
+  : m_minutes(m),
+    m_seconds(s),
+    m_frames(f)
+{
+  makeValid();
+}
+
+K3b::Msf::Msf( int i )
+  : m_minutes(0),
+    m_seconds(0),
+    m_frames(i)
+{
+  makeValid();
+}
+
+
+void K3b::Msf::setValue( int m, int s, int f )
+{
+  m_minutes = m;
+  m_seconds = s;
+  m_frames = f;
+  makeValid();
+}
+
+
+void K3b::Msf::addMinutes( int m )
+{
+  m_minutes += m;
+  makeValid();
+}
+
+void K3b::Msf::addSeconds( int s )
+{
+  m_seconds += s;
+  makeValid();
+}
+
+void K3b::Msf::addFrames( int f )
+{
+  m_frames += f;
+  makeValid();
+}
+
+K3b::Msf& K3b::Msf::operator=( const K3b::Msf& m )
+{
+  m_frames = m.frames();
+  m_seconds = m.seconds();
+  m_minutes = m.minutes();
+  return *this;
+}
+
+K3b::Msf& K3b::Msf::operator=( int i )
+{
+  m_frames = i;
+  m_seconds = 0;
+  m_minutes = 0;
+  makeValid();
+  return *this;
+}
+
+K3b::Msf& K3b::Msf::operator+=( const K3b::Msf& m )
+{
+  m_frames += m.frames();
+  m_seconds += m.seconds();
+  m_minutes += m.minutes();
+  makeValid();
+  return *this;
+}
+
+K3b::Msf& K3b::Msf::operator+=( int i )
+{
+  addFrames(i);
+  return *this;
+}
+
+K3b::Msf& K3b::Msf::operator-=( const K3b::Msf& m )
+{
+  m_frames -= m.frames();
+  m_seconds -= m.seconds();
+  m_minutes -= m.minutes();
+  makeValid();
+  return *this;
+}
+
+K3b::Msf& K3b::Msf::operator-=( int i )
+{
+  m_frames -= i;
+  makeValid();
+  return *this;
+}
+
+
+const K3b::Msf K3b::Msf::operator++( int )
+{
+  Msf old = *this;
+  ++(*this);
+  return old;
+}
+
+
+K3b::Msf& K3b::Msf::operator++()
+{
+  (*this) += 1;
+  return *this;
+}
+
+
+const K3b::Msf K3b::Msf::operator--( int )
+{
+  Msf old = *this;
+  --(*this);
+  return old;
+}
+
+
+K3b::Msf& K3b::Msf::operator--()
+{
+  (*this) -= 1;
+  return *this;
+}
+
+
+QString K3b::Msf::toString( bool showFrames ) const
+{
+  QString str;
+
+  if( showFrames )
+    str.sprintf( "%.2i:%.2i:%.2i", m_minutes, m_seconds, m_frames );
+  else
+    str.sprintf( "%.2i:%.2i", m_minutes, m_seconds );
+
+  return str;
+}
+
+
+KIO::filesize_t K3b::Msf::mode1Bytes() const
+{
+  return (KIO::filesize_t)2048 * ( (KIO::filesize_t)lba() );
+}
+
+KIO::filesize_t K3b::Msf::mode2Form1Bytes() const
+{
+  return (KIO::filesize_t)2048 * ( (KIO::filesize_t)lba() );
+}
+
+KIO::filesize_t K3b::Msf::mode2Form2Bytes() const
+{
+  return (KIO::filesize_t)2324 * ( (KIO::filesize_t)lba() );
+}
+
+KIO::filesize_t K3b::Msf::audioBytes() const
+{
+  return (KIO::filesize_t)2352 * ( (KIO::filesize_t)lba() );
+}
+
+KIO::filesize_t K3b::Msf::rawBytes() const
+{
+  return (KIO::filesize_t)2448 * ( (KIO::filesize_t)lba() );
+}
+
+void K3b::Msf::makeValid()
+{
+  if( m_frames < 0 ) {
+    int newFrames = m_frames/-75 + 1;
+    m_seconds -= newFrames;
+    m_frames += 75*newFrames;
+  }
+  m_seconds += m_frames/75;
+  m_frames = m_frames % 75;
+  if( m_seconds < 0 ) {
+    int newSecs = m_seconds/-60 + 1;
+    m_minutes -= newSecs;
+    m_seconds += 60*newSecs;
+  }
+  m_minutes += m_seconds/60;
+  m_seconds = m_seconds % 60;
+  if( m_minutes < 0 ) {
+    m_minutes = 0;
+    m_seconds = 0;
+    m_frames = 0;
+  }
+}
+
+
+
+QRegExp K3b::Msf::regExp()
+{
+  //
+  // An MSF can have the following formats:
+  // 100        (treated as frames)
+  // 100:23     (minutes:seconds)
+  // 100:23:72  (minutes:seconds:frames)
+  // 100:23.72  (minutes:seconds.frames)
+  //
+  static QRegExp rx( "(\\d+)(?::([0-5]?\\d)(?:[:\\.]((?:[0-6]?\\d)|(?:7[0-4])))?)?" );
+  return rx;
+}
+
+
+K3b::Msf K3b::Msf::fromSeconds( double ms )
+{
+  return K3b::Msf( static_cast<int>( ::ceil(ms*75.0) ) );
+}
+
+
+K3b::Msf K3b::Msf::fromString( const QString& s, bool* ok )
+{
+  QRegExp rx = regExp();
+
+  K3b::Msf msf;
+
+  if( rx.exactMatch( s ) ) {
+    //
+    // first number - cap(1)
+    // second number - cap(2)
+    // third number - cap(3)
+    //
+    if( rx.cap(2).isEmpty() ) {
+      msf.m_frames = rx.cap(1).toInt();
+    }
+    else {
+      msf.m_minutes = rx.cap(1).toInt();
+      msf.m_seconds = rx.cap(2).toInt();
+      msf.m_frames = rx.cap(3).toInt();
+    }
+
+    if( ok )
+      *ok = true;
+  }
+  else if( ok )
+    *ok = false;
+
+  msf.makeValid();
+
+  return msf;
+}
+
+
+
+K3b::Msf K3b::operator+( const K3b::Msf& m1, const K3b::Msf& m2 )
+{
+  K3b::Msf msf(m1);
+  return msf += m2;
+}
+
+K3b::Msf K3b::operator+( const K3b::Msf& m, int i )
+{
+  K3b::Msf msf(m);
+  return msf += i;
+}
+
+K3b::Msf K3b::operator-( const K3b::Msf& m1, const K3b::Msf& m2 )
+{
+  K3b::Msf msf(m1);
+  return msf -= m2;
+}
+
+K3b::Msf K3b::operator-( const K3b::Msf& m, int i )
+{
+  K3b::Msf msf(m);
+  return msf -= i;
+}
+
+bool K3b::operator==( const K3b::Msf& m1, const K3b::Msf& m2 )
+{
+  return ( m1.minutes() == m2.minutes() &&
+	   m1.seconds() == m2.seconds() &&
+	   m1.frames() == m2.frames() );
+}
+
+bool K3b::operator!=( const K3b::Msf& m1, const K3b::Msf& m2 )
+{
+  return !operator==( m1, m2 );
+}
+
+bool K3b::operator<( const K3b::Msf& m1, const K3b::Msf& m2 )
+{
+  return ( m1.lba() < m2.lba() );
+}
+
+bool K3b::operator>( const K3b::Msf& m1, const K3b::Msf& m2 )
+{
+  return ( m1.lba() > m2.lba() );
+}
+
+bool K3b::operator<=( const K3b::Msf& m1, const K3b::Msf& m2 )
+{
+  return ( m1.lba() <= m2.lba() );
+}
+
+bool K3b::operator>=( const K3b::Msf& m1, const K3b::Msf& m2 )
+{
+  return ( m1.lba() >= m2.lba() );
+}
+
+kdbgstream& K3b::operator<<( kdbgstream& s, const Msf& m )
+{
+  return s << m.toString();
+}
diff --git a/libk3bdevice/k3bmsf.h b/libk3bdevice/k3bmsf.h
new file mode 100644
index 0000000..d2209c3
--- /dev/null
+++ b/libk3bdevice/k3bmsf.h
@@ -0,0 +1,118 @@
+/* 
+ *
+ * $Id: k3bmsf.h 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#ifndef _K3B_MSF_H_
+#define _K3B_MSF_H_
+
+#include <qstring.h>
+#include <qregexp.h>
+
+#include <kdebug.h>
+#include <kio/global.h>
+#include "k3bdevice_export.h"
+
+namespace K3b
+{
+  /**
+   * int values are always treated as frames
+   * except in the set methods
+   * A MSF is never < 0.
+   */
+  class LIBK3BDEVICE_EXPORT Msf
+    {
+    public:
+      Msf();
+      Msf( const Msf& );
+      Msf( int, int, int );
+      Msf( int );
+
+      Msf& operator=( const Msf& );
+      Msf& operator=( int );
+      Msf& operator+=( const Msf& );
+      Msf& operator+=( int );
+      Msf& operator-=( const Msf& );
+      Msf& operator-=( int );
+      const Msf operator++( int );
+      Msf& operator++();
+      const Msf operator--( int );
+      Msf& operator--();
+
+      int minutes() const { return m_minutes; }
+      int seconds() const { return m_seconds; }
+      int frames() const { return m_frames; }
+
+      int totalFrames() const { return ( m_minutes*60 + m_seconds )*75 + m_frames; }
+      int lba() const { return totalFrames(); }
+
+      //      operator int () const { return lba(); }
+
+      void setValue( int m, int s, int f );
+
+      void addMinutes( int m );
+      void addSeconds( int s );
+      void addFrames( int f );
+
+      QString toString( bool showFrames = true ) const;
+
+      KIO::filesize_t mode1Bytes() const;
+      KIO::filesize_t mode2Form1Bytes() const;
+      KIO::filesize_t mode2Form2Bytes() const;
+      KIO::filesize_t audioBytes() const;
+      KIO::filesize_t rawBytes() const;
+      unsigned long long pcmSamples() const { return lba()*588; }
+
+      /**
+       * Convert a string representation into an Msf object.
+       *
+       * Valid strings include:
+       * \li 100       - treated as 100 frames
+       * \li 100:23    - treated as 100 minutes and 23 seconds
+       * \li 100:23:57 - treated as 100 minutes, 23 seconds, and 57 frames
+       * \li 100:23.57 - treated as 100 minutes, 23 seconds, and 57 frames
+       */
+      static Msf fromString( const QString&, bool* ok = 0 );
+
+      /**
+       * @param ms seconds
+       * frames will be rounded up
+       */
+      static Msf fromSeconds( double ms );
+
+      static QRegExp regExp();
+
+    private:
+      void makeValid();
+      int m_minutes;
+      int m_seconds;
+      int m_frames;
+    };
+
+  LIBK3BDEVICE_EXPORT Msf operator+( const Msf&, const Msf& );
+  LIBK3BDEVICE_EXPORT Msf operator+( const Msf&, int );
+  LIBK3BDEVICE_EXPORT Msf operator-( const Msf&, const Msf& );
+  LIBK3BDEVICE_EXPORT Msf operator-( const Msf&, int );
+  LIBK3BDEVICE_EXPORT bool operator==( const Msf&, const Msf& );
+  LIBK3BDEVICE_EXPORT bool operator!=( const Msf&, const Msf& );
+  LIBK3BDEVICE_EXPORT bool operator<( const Msf&, const Msf& );
+  LIBK3BDEVICE_EXPORT bool operator>( const Msf&, const Msf& );
+  LIBK3BDEVICE_EXPORT bool operator<=( const Msf&, const Msf& );
+  LIBK3BDEVICE_EXPORT bool operator>=( const Msf&, const Msf& );
+
+  LIBK3BDEVICE_EXPORT kdbgstream& operator<<( kdbgstream&, const Msf& );
+  LIBK3BDEVICE_EXPORT inline kndbgstream& operator<<( kndbgstream &stream, const Msf& ) { return stream; }
+}
+
+#endif
diff --git a/libk3bdevice/k3bscsicommand.cpp b/libk3bdevice/k3bscsicommand.cpp
new file mode 100644
index 0000000..2b34217
--- /dev/null
+++ b/libk3bdevice/k3bscsicommand.cpp
@@ -0,0 +1,218 @@
+/*
+ *
+ * $Id: k3bscsicommand.cpp 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include "k3bscsicommand.h"
+#include "k3bdevice.h"
+
+#include <k3bdebug.h>
+
+
+QString K3bDevice::commandString( const unsigned char& command )
+{
+  if( command == MMC_BLANK )
+    return "BLANK";
+  if( command == MMC_CLOSE_TRACK_SESSION )
+    return "CLOSE TRACK/SESSION";
+  if( command == MMC_ERASE )
+    return "ERASE";
+  if( command == MMC_FORMAT_UNIT )
+    return "FORMAT UNIT";
+  if( command == MMC_GET_CONFIGURATION )
+    return "GET CONFIGURATION";
+  if( command == MMC_GET_EVENT_STATUS_NOTIFICATION )
+    return "GET EVENT STATUS NOTIFICATION";
+  if( command == MMC_GET_PERFORMANCE )
+    return "GET PERFORMANCE";
+  if( command == MMC_INQUIRY )
+    return "INQUIRY";
+  if( command == MMC_LOAD_UNLOAD_MEDIUM )
+    return "LOAD/UNLOAD MEDIUM";
+  if( command == MMC_MECHANISM_STATUS )
+    return "MECHANISM STATUS";
+  if( command == MMC_MODE_SELECT )
+    return "MODE SELECT";
+  if( command == MMC_MODE_SENSE )
+    return "MODE SENSE";
+  if( command == MMC_PAUSE_RESUME )
+    return "PAUSE/RESUME";
+  if( command == MMC_PLAY_AUDIO_10 )
+    return "PLAY AUDIO (10)";
+  if( command == MMC_PLAY_AUDIO_12 )
+    return "PLAY AUDIO (12)";
+  if( command == MMC_PLAY_AUDIO_MSF )
+    return "PLAY AUDIO (MSF)";
+  if( command == MMC_PREVENT_ALLOW_MEDIUM_REMOVAL )
+    return "PREVENT ALLOW MEDIUM REMOVAL";
+  if( command == MMC_READ_10 )
+    return "READ (10)";
+  if( command == MMC_READ_12 )
+    return "READ (12)";
+  if( command == MMC_READ_BUFFER )
+    return "READ BUFFER";
+  if( command == MMC_READ_BUFFER_CAPACITY )
+    return "READ BUFFER CAPACITY";
+  if( command == MMC_READ_CAPACITY )
+    return "READ CAPACITY";
+  if( command == MMC_READ_CD )
+    return "READ CD";
+  if( command == MMC_READ_CD_MSF )
+    return "READ CD MSF";
+  if( command == MMC_READ_DISC_INFORMATION )
+    return "READ DISC INFORMATION";
+  if( command == MMC_READ_DVD_STRUCTURE )
+    return "READ DVD STRUCTURE";
+  if( command == MMC_READ_FORMAT_CAPACITIES )
+    return "READ FORMAT CAPACITIES";
+  if( command == MMC_READ_SUB_CHANNEL )
+    return "READ SUB-CHANNEL";
+  if( command == MMC_READ_TOC_PMA_ATIP )
+    return "READ TOC/PMA/ATIP";
+  if( command == MMC_READ_TRACK_INFORMATION )
+    return "READ TRACK INFORMATION";
+  if( command == MMC_REPAIR_TRACK )
+    return "REPAIR TRACK";
+  if( command == MMC_REPORT_KEY )
+    return "REPORT KEY";
+  if( command == MMC_REQUEST_SENSE )
+    return "REQUEST SENSE";
+  if( command == MMC_RESERVE_TRACK )
+    return "RESERVE TRACK";
+  if( command == MMC_SCAN )
+    return "SCAN";
+  if( command == MMC_SEEK_10 )
+    return "SEEK (10)";
+  if( command == MMC_SEND_CUE_SHEET )
+    return "SEND CUE SHEET";
+  if( command == MMC_SEND_DVD_STRUCTURE )
+    return "SEND DVD STRUCTURE";
+  if( command == MMC_SEND_KEY )
+    return "SEND KEY";
+  if( command == MMC_SEND_OPC_INFORMATION )
+    return "SEND OPC INFORMATION";
+  if( command == MMC_SET_SPEED )
+    return "SET SPEED";
+  if( command == MMC_SET_READ_AHEAD )
+    return "SET READ AHEAD";
+  if( command == MMC_SET_STREAMING )
+    return "SET STREAMING";
+  if( command == MMC_START_STOP_UNIT )
+    return "START STOP UNIT";
+  if( command == MMC_STOP_PLAY_SCAN )
+    return "STOP PLAY/SCAN";
+  if( command == MMC_SYNCHRONIZE_CACHE )
+    return "SYNCHRONIZE CACHE";
+  if( command == MMC_TEST_UNIT_READY )
+    return "TEST UNIT READY";
+  if( command == MMC_VERIFY_10 )
+    return "VERIFY (10)";
+  if( command == MMC_WRITE_10 )
+    return "WRITE (10)";
+  if( command == MMC_WRITE_12 )
+    return "WRITE (12)";
+  if( command == MMC_WRITE_AND_VERIFY_10 )
+    return "WRITE AND VERIFY (10)";
+  if( command == MMC_WRITE_BUFFER )
+    return "WRITE BUFFER";
+
+  return "unknown";
+}
+
+
+QString K3bDevice::ScsiCommand::senseKeyToString( int key )
+{
+  switch( key ) {
+  case 0x0:
+    return "NO SENSE (2)";
+  case 0x1:
+    return "RECOVERED ERROR (1)";
+  case 0x2:
+    return "NOT READY (2)";
+  case 0x3:
+    return "MEDIUM ERROR (3)";
+  case 0x4:
+    return "HARDWARE ERROR (4)";
+  case 0x5:
+    return "ILLEGAL REQUEST (5)";
+  case 0x6:
+    return "UNIT ATTENTION (6)";
+  case 0x7:
+    return "DATA PROTECT (7)";
+  case 0x8:
+    return "BLANK CHECK (8)";
+  case 0x9:
+    return "VENDOR SPECIFIC (9)";
+  case 0xA:
+    return "COPY ABORTED (A)";
+  case 0xB:
+    return "ABORTED COMMAND (B)";
+  case 0xC:
+    return "0xC is obsolete... ??";
+  }
+
+  return "unknown";
+}
+
+
+void K3bDevice::ScsiCommand::debugError( int command, int errorCode, int senseKey, int asc, int ascq ) {
+  if( m_printErrors ) {
+    k3bDebug() << "(K3bDevice::ScsiCommand) failed: " << endl
+	      << "                           command:    " << QString("%1 (%2)")
+      .arg( K3bDevice::commandString( command ) )
+      .arg( QString::number(command, 16) ) << endl
+	      << "                           errorcode:  " << QString::number(errorCode, 16) << endl
+	      << "                           sense key:  " << senseKeyToString(senseKey) << endl
+	      << "                           asc:        " << QString::number(asc, 16) << endl
+	      << "                           ascq:       " << QString::number(ascq, 16) << endl;
+  }
+}
+
+
+
+#ifdef Q_OS_LINUX
+#include "k3bscsicommand_linux.cpp"
+#endif
+#ifdef Q_OS_FREEBSD
+#include "k3bscsicommand_bsd.cpp"
+#endif
+#ifdef Q_OS_NETBSD
+#include "k3bscsicommand_netbsd.cpp"
+#endif
+
+
+
+K3bDevice::ScsiCommand::ScsiCommand( K3bDevice::Device::Handle handle )
+  : d(new Private),
+    m_device(0),
+    m_printErrors(true)
+{
+  m_deviceHandle = handle;
+  clear();
+}
+
+
+K3bDevice::ScsiCommand::ScsiCommand( const K3bDevice::Device* dev )
+  : d(new Private),
+    m_device(dev),
+    m_printErrors(true)
+{
+  clear();
+}
+
+
+K3bDevice::ScsiCommand::~ScsiCommand()
+{
+  delete d;
+}
+
diff --git a/libk3bdevice/k3bscsicommand.h b/libk3bdevice/k3bscsicommand.h
new file mode 100644
index 0000000..11a9860
--- /dev/null
+++ b/libk3bdevice/k3bscsicommand.h
@@ -0,0 +1,142 @@
+/*
+ *
+ * $Id: k3bscsicommand.h 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#ifndef _K3B_SCSI_COMMAND_H_
+#define _K3B_SCSI_COMMAND_H_
+
+#include <qglobal.h>
+#include <qstring.h>
+
+#include "k3bdevice.h"
+
+
+namespace K3bDevice
+{
+  const unsigned char MMC_BLANK = 0xA1;
+  const unsigned char MMC_CLOSE_TRACK_SESSION = 0x5B;
+  const unsigned char MMC_ERASE = 0x2C;
+  const unsigned char MMC_FORMAT_UNIT = 0x04;
+  const unsigned char MMC_GET_CONFIGURATION = 0x46;
+  const unsigned char MMC_GET_EVENT_STATUS_NOTIFICATION = 0x4A;
+  const unsigned char MMC_GET_PERFORMANCE = 0xAC;
+  const unsigned char MMC_INQUIRY = 0x12;
+  const unsigned char MMC_LOAD_UNLOAD_MEDIUM = 0xA6;
+  const unsigned char MMC_MECHANISM_STATUS = 0xBD;
+  const unsigned char MMC_MODE_SELECT = 0x55;
+  const unsigned char MMC_MODE_SENSE = 0x5A;
+  const unsigned char MMC_PAUSE_RESUME = 0x4B;
+  const unsigned char MMC_PLAY_AUDIO_10 = 0x45;
+  const unsigned char MMC_PLAY_AUDIO_12 = 0xA5;
+  const unsigned char MMC_PLAY_AUDIO_MSF = 0x47;
+  const unsigned char MMC_PREVENT_ALLOW_MEDIUM_REMOVAL = 0x1E;
+  const unsigned char MMC_READ_10 = 0x28;
+  const unsigned char MMC_READ_12 = 0xA8;
+  const unsigned char MMC_READ_BUFFER = 0x3C;
+  const unsigned char MMC_READ_BUFFER_CAPACITY = 0x5C;
+  const unsigned char MMC_READ_CAPACITY = 0x25;
+  const unsigned char MMC_READ_CD = 0xBE;
+  const unsigned char MMC_READ_CD_MSF = 0xB9;
+  const unsigned char MMC_READ_DISC_INFORMATION = 0x51;
+  const unsigned char MMC_READ_DVD_STRUCTURE = 0xAD;
+  const unsigned char MMC_READ_DISC_STRUCTURE = 0xAD; /**< READ DVD STRUCTURE has been renamed to READ DISC STRUCTURE in MMC5 */
+  const unsigned char MMC_READ_FORMAT_CAPACITIES = 0x23;
+  const unsigned char MMC_READ_SUB_CHANNEL = 0x42;
+  const unsigned char MMC_READ_TOC_PMA_ATIP = 0x43;
+  const unsigned char MMC_READ_TRACK_INFORMATION = 0x52;
+  const unsigned char MMC_REPAIR_TRACK = 0x58;
+  const unsigned char MMC_REPORT_KEY = 0xA4;
+  const unsigned char MMC_REQUEST_SENSE = 0x03;
+  const unsigned char MMC_RESERVE_TRACK = 0x53;
+  const unsigned char MMC_SCAN = 0xBA;
+  const unsigned char MMC_SEEK_10 = 0x2B;
+  const unsigned char MMC_SEND_CUE_SHEET = 0x5D;
+  const unsigned char MMC_SEND_DVD_STRUCTURE = 0xBF;
+  const unsigned char MMC_SEND_KEY = 0xA3;
+  const unsigned char MMC_SEND_OPC_INFORMATION = 0x54;
+  const unsigned char MMC_SET_SPEED = 0xBB;
+  const unsigned char MMC_SET_READ_AHEAD = 0xA7;
+  const unsigned char MMC_SET_STREAMING = 0xB6;
+  const unsigned char MMC_START_STOP_UNIT = 0x1B;
+  const unsigned char MMC_STOP_PLAY_SCAN = 0x4E;
+  const unsigned char MMC_SYNCHRONIZE_CACHE = 0x35;
+  const unsigned char MMC_TEST_UNIT_READY = 0x00;
+  const unsigned char MMC_VERIFY_10 = 0x2F;
+  const unsigned char MMC_WRITE_10 = 0x2A;
+  const unsigned char MMC_WRITE_12 = 0xAA;
+  const unsigned char MMC_WRITE_AND_VERIFY_10 = 0x2E;
+  const unsigned char MMC_WRITE_BUFFER = 0x3B;
+
+  QString commandString( const unsigned char& command );
+
+  enum TransportDirection {
+    TR_DIR_NONE,
+    TR_DIR_READ,
+    TR_DIR_WRITE
+  };
+
+  class ScsiCommand
+    {
+    public:
+      ScsiCommand( K3bDevice::Device::Handle handle );
+      ScsiCommand( const Device* );
+      ~ScsiCommand();
+
+      /**
+       * Enales or disables printing of debugging messages for failed
+       * commands.
+       *
+       * Default is enabled.
+       */
+      void enableErrorMessages( bool b ) { m_printErrors = b; }
+
+      void clear();
+
+      unsigned char& operator[]( size_t );
+
+      // TODO: use this
+/*       union ErrorCode { */
+/* 	K3bDevice::uint32 code; */
+/* 	struct { */
+/* 	  K3bDevice::uint8 errorCode; */
+/* 	  K3bDevice::uint8 senseKey; */
+/* 	  K3bDevice::uint8 asc; */
+/* 	  K3bDevice::uint8 ascq; */
+/* 	} details; */
+/*       }; */
+
+      /**
+       * \return 0 on success, -1 if the device could not be opened, and
+       *         an error code otherwise. The error code is constructed from
+       *         the scsi error code, the sense key, asc, and ascq. These four values are 
+       *         combined into the lower 32 bit of an integer in the order used above.
+       */
+      int transport( TransportDirection dir = TR_DIR_NONE,
+		     void* = 0,
+		     size_t len = 0 );
+
+    private:
+      static QString senseKeyToString( int key );
+      void debugError( int command, int errorCode, int senseKey, int asc, int ascq );
+
+      class Private;
+      Private *d;
+      Device::Handle m_deviceHandle;
+      const Device* m_device;
+
+      bool m_printErrors;
+    };
+}
+
+#endif
diff --git a/libk3bdevice/k3bscsicommand_bsd.cpp b/libk3bdevice/k3bscsicommand_bsd.cpp
new file mode 100644
index 0000000..84e12f9
--- /dev/null
+++ b/libk3bdevice/k3bscsicommand_bsd.cpp
@@ -0,0 +1,208 @@
+/*
+ *
+ * $Id: k3bscsicommand_bsd.cpp 679320 2007-06-23 15:57:22Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include "k3bscsicommand.h"
+#include "k3bdevice.h"
+
+#include <k3bdebug.h>
+
+#include <stdio.h>
+#include <errno.h>
+#include <camlib.h>
+#include <cam/scsi/scsi_message.h>
+#include <cam/scsi/scsi_pass.h>
+
+#define ERRCODE(s)	((((s)[2]&0x0F)<<16)|((s)[12]<<8)|((s)[13]))
+#define EMEDIUMTYPE	EINVAL
+#define	ENOMEDIUM	ENODEV
+#define CREAM_ON_ERRNO(s)	do {			\
+    switch ((s)[12])					\
+    {	case 0x04:	errno=EAGAIN;	break;		\
+	case 0x20:	errno=ENODEV;	break;		\
+	case 0x21:	if ((s)[13]==0)	errno=ENOSPC;	\
+			else		errno=EINVAL;	\
+			break;				\
+	case 0x30:	errno=EMEDIUMTYPE;  break;	\
+	case 0x3A:	errno=ENOMEDIUM;    break;	\
+    }							\
+} while(0)
+
+
+
+class K3bDevice::ScsiCommand::Private
+{
+public:
+  union ccb ccb;
+};
+
+
+void K3bDevice::ScsiCommand::clear()
+{
+  memset (&d->ccb,0,sizeof(ccb));
+}
+
+
+unsigned char& K3bDevice::ScsiCommand::operator[]( size_t i )
+{
+  if( d->ccb.csio.cdb_len < i+1 )
+    d->ccb.csio.cdb_len = i+1;
+  return d->ccb.csio.cdb_io.cdb_bytes[i];
+}
+
+int K3bDevice::ScsiCommand::transport( TransportDirection dir,
+				       void* data,
+				       size_t len )
+{
+  if( !m_device )
+    return -1;
+
+  m_device->usageLock();
+
+  bool needToClose = false;
+  if( !m_device->isOpen() ) {
+    needToClose = true;
+  }
+
+  if( !m_device->open( true ) ) {
+      m_device->usageUnlock();
+      return -1;
+  }
+  d->ccb.ccb_h.path_id    = m_device->handle()->path_id;
+  d->ccb.ccb_h.target_id  = m_device->handle()->target_id;
+  d->ccb.ccb_h.target_lun = m_device->handle()->target_lun;
+
+  k3bDebug() << "(K3bDevice::ScsiCommand) transport command " << QString::number((int)d->ccb.csio.cdb_io.cdb_bytes[0], 16) << ", length: " << (int)d->ccb.csio.cdb_len << endl;
+  int ret=0;
+  int direction = CAM_DEV_QFRZDIS;
+  if (!len)
+    direction |= CAM_DIR_NONE;
+  else
+    direction |= (dir & TR_DIR_READ)?CAM_DIR_IN : CAM_DIR_OUT;
+  cam_fill_csio (&(d->ccb.csio), 1, 0 /* NULL */, direction, MSG_SIMPLE_Q_TAG, (u_int8_t *)data, len, sizeof(d->ccb.csio.sense_data), d->ccb.csio.cdb_len, 30*1000);
+  unsigned char * sense = (unsigned char *)&d->ccb.csio.sense_data;
+
+  ret = cam_send_ccb(m_device->handle(), &d->ccb);
+
+  if (ret < 0) {
+      k3bDebug() << "(K3bDevice::ScsiCommand) transport failed: " << ret << endl;
+
+      if( needToClose )
+          m_device->close();
+
+      m_device->usageUnlock();
+
+      struct scsi_sense_data* senset = (struct scsi_sense_data*)sense;
+      debugError( d->ccb.csio.cdb_io.cdb_bytes[0],
+		  senset->error_code & SSD_ERRCODE,
+		  senset->flags & SSD_KEY,
+		  senset->add_sense_code,
+		  senset->add_sense_code_qual );
+
+      int result = (((senset->error_code & SSD_ERRCODE)<<24) & 0xF000 |
+                    ((senset->flags & SSD_KEY)<<16)          & 0x0F00 |
+                    (senset->add_sense_code<<8)              & 0x00F0 |
+                    (senset->add_sense_code_qual)            & 0x000F );
+
+      return result ? result : ret;
+  }
+
+  else if ((d->ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
+      if( needToClose )
+          m_device->close();
+      m_device->usageUnlock();
+      return 0;
+  }
+
+  errno = EIO;
+  // FreeBSD 5-CURRENT since 2003-08-24, including 5.2 fails to
+  // pull sense data automatically, at least for ATAPI transport,
+  // so I reach for it myself...
+  if ((d->ccb.csio.scsi_status==SCSI_STATUS_CHECK_COND) &&
+      !(d->ccb.ccb_h.status&CAM_AUTOSNS_VALID))
+    {
+      u_int8_t  _sense[18];
+      u_int32_t resid=d->ccb.csio.resid;
+
+      memset(_sense,0,sizeof(_sense));
+
+      operator[](0)      = 0x03;	// REQUEST SENSE
+      d->ccb.csio.cdb_io.cdb_bytes[4] = sizeof(_sense);
+      d->ccb.csio.cdb_len   = 6;
+      d->ccb.csio.ccb_h.flags |= CAM_DIR_IN|CAM_DIS_AUTOSENSE;
+      d->ccb.csio.data_ptr  = _sense;
+      d->ccb.csio.dxfer_len = sizeof(_sense);
+      d->ccb.csio.sense_len = 0;
+
+      ret = cam_send_ccb(m_device->handle(), &d->ccb);
+
+      d->ccb.csio.resid = resid;
+      if (ret<0)
+	{
+	  k3bDebug() << "(K3bDevice::ScsiCommand) transport failed (2): " << ret << endl;
+	  ret = -1;
+	  struct scsi_sense_data* senset = (struct scsi_sense_data*)sense;
+	  debugError( d->ccb.csio.cdb_io.cdb_bytes[0],
+		      senset->error_code & SSD_ERRCODE,
+		      senset->flags & SSD_KEY,
+		      senset->add_sense_code,
+		      senset->add_sense_code_qual );
+
+	  if( needToClose )
+	    m_device->close();
+          m_device->usageUnlock();
+
+	  return -1;
+	}
+      if ((d->ccb.ccb_h.status&CAM_STATUS_MASK) != CAM_REQ_CMP)
+	{
+	  k3bDebug() << "(K3bDevice::ScsiCommand) transport failed (3): " << ret << endl;
+	  errno=EIO,-1;
+	  ret = -1;
+	  struct scsi_sense_data* senset = (struct scsi_sense_data*)sense;
+	  debugError( d->ccb.csio.cdb_io.cdb_bytes[0],
+		      senset->error_code & SSD_ERRCODE,
+		      senset->flags & SSD_KEY,
+		      senset->add_sense_code,
+		      senset->add_sense_code_qual );
+
+	  if( needToClose )
+	    m_device->close();
+          m_device->usageUnlock();
+
+	  return -1;
+	}
+
+      memcpy(sense,_sense,sizeof(_sense));
+    }
+
+  ret = ERRCODE(sense);
+  k3bDebug() << "(K3bDevice::ScsiCommand) transport failed (4): " << ret << endl;
+  if (ret == 0)
+    ret = -1;
+  else
+    CREAM_ON_ERRNO(((unsigned char *)&d->ccb.csio.sense_data));
+  struct scsi_sense_data* senset = (struct scsi_sense_data*)sense;
+  debugError( d->ccb.csio.cdb_io.cdb_bytes[0],
+	      senset->error_code & SSD_ERRCODE,
+	      senset->flags & SSD_KEY,
+	      senset->add_sense_code,
+	      senset->add_sense_code_qual );
+
+  if( needToClose )
+    m_device->close();
+  m_device->usageUnlock();
+
+  return ret;
+}
diff --git a/libk3bdevice/k3bscsicommand_linux.cpp b/libk3bdevice/k3bscsicommand_linux.cpp
new file mode 100644
index 0000000..774da06
--- /dev/null
+++ b/libk3bdevice/k3bscsicommand_linux.cpp
@@ -0,0 +1,177 @@
+/*
+ *
+ * $Id: k3bscsicommand_linux.cpp 679274 2007-06-23 13:23:58Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * Parts of this file are inspired (and copied) from transport.hxx
+ * from the dvd+rw-tools (C) Andy Polyakov <appro@fy.chalmers.se>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include "k3bscsicommand.h"
+#include "k3bdevice.h"
+
+#include <k3bdebug.h>
+
+#include <sys/ioctl.h>
+#undef __STRICT_ANSI__
+#include <linux/cdrom.h>
+#define __STRICT_ANSI__
+#include <scsi/sg.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/utsname.h>
+
+
+#if !defined(SG_FLAG_LUN_INHIBIT)
+# if defined(SG_FLAG_UNUSED_LUN_INHIBIT)
+#  define SG_FLAG_LUN_INHIBIT SG_FLAG_UNUSED_LUN_INHIBIT
+# else
+#  define SG_FLAG_LUN_INHIBIT 0
+# endif
+#endif
+
+#ifdef SG_IO
+static bool useSgIo()
+{
+  struct utsname buf;
+  uname( &buf );
+  // was CDROM_SEND_PACKET declared dead in 2.5?
+  return ( strcmp( buf.release, "2.5.43" ) >=0 );
+}
+#endif
+
+
+class K3bDevice::ScsiCommand::Private
+{
+public:
+  struct cdrom_generic_command cmd;
+  struct request_sense sense;
+
+#ifdef SG_IO
+  bool useSgIo;
+  struct sg_io_hdr sgIo;
+#endif
+};
+
+
+void K3bDevice::ScsiCommand::clear()
+{
+  ::memset( &d->cmd, 0, sizeof(struct cdrom_generic_command) );
+  ::memset( &d->sense, 0, sizeof(struct request_sense) );
+
+  d->cmd.quiet = 1;
+  d->cmd.sense = &d->sense;
+
+#ifdef SG_IO
+  d->useSgIo = useSgIo();
+  ::memset( &d->sgIo, 0, sizeof(struct sg_io_hdr) );
+#endif
+}
+
+
+unsigned char& K3bDevice::ScsiCommand::operator[]( size_t i )
+{
+#ifdef SG_IO
+  if( d->sgIo.cmd_len < i+1 )
+    d->sgIo.cmd_len = i+1;
+#endif
+  return d->cmd.cmd[i];
+}
+
+
+int K3bDevice::ScsiCommand::transport( TransportDirection dir,
+				       void* data,
+				       size_t len )
+{
+  bool needToClose = false;
+  if( m_device ) {
+      m_device->usageLock();
+      if( !m_device->isOpen() ) {
+          needToClose = true;
+      }
+      if ( !m_device->open( dir == TR_DIR_WRITE ) ) {
+          m_device->usageUnlock();
+          return -1;
+      }
+      m_deviceHandle = m_device->handle();
+  }
+
+  if( m_deviceHandle == -1 ) {
+    return -1;
+  }
+
+  int i = -1;
+
+#ifdef SG_IO
+  if( d->useSgIo ) {
+    d->sgIo.interface_id= 'S';
+    d->sgIo.mx_sb_len = sizeof( struct request_sense );
+    d->sgIo.cmdp      = d->cmd.cmd;
+    d->sgIo.sbp       = (unsigned char*)&d->sense;
+    d->sgIo.flags     = SG_FLAG_LUN_INHIBIT|SG_FLAG_DIRECT_IO;
+    d->sgIo.dxferp    = data;
+    d->sgIo.dxfer_len = len;
+    d->sgIo.timeout   = 5000;
+    if( dir == TR_DIR_READ )
+      d->sgIo.dxfer_direction = SG_DXFER_FROM_DEV;
+    else if( dir == TR_DIR_WRITE )
+      d->sgIo.dxfer_direction = SG_DXFER_TO_DEV;
+    else
+      d->sgIo.dxfer_direction = SG_DXFER_NONE;
+
+    i = ::ioctl( m_deviceHandle, SG_IO, &d->sgIo );
+
+    if( ( d->sgIo.info&SG_INFO_OK_MASK ) != SG_INFO_OK )
+      i = -1;
+  }
+  else {
+#endif
+    d->cmd.buffer = (unsigned char*)data;
+    d->cmd.buflen = len;
+    if( dir == TR_DIR_READ )
+      d->cmd.data_direction = CGC_DATA_READ;
+    else if( dir == TR_DIR_WRITE )
+      d->cmd.data_direction = CGC_DATA_WRITE;
+    else
+      d->cmd.data_direction = CGC_DATA_NONE;
+
+    i = ::ioctl( m_deviceHandle, CDROM_SEND_PACKET, &d->cmd );
+#ifdef SG_IO
+  }
+#endif
+
+  if( needToClose )
+    m_device->close();
+
+  if ( m_device ) {
+      m_device->usageUnlock();
+  }
+
+  if( i ) {
+    debugError( d->cmd.cmd[0],
+		d->sense.error_code,
+		d->sense.sense_key,
+		d->sense.asc,
+		d->sense.ascq );
+
+    int errCode =
+      (d->sense.error_code<<24) & 0xF000 |
+      (d->sense.sense_key<<16)  & 0x0F00 |
+      (d->sense.asc<<8)         & 0x00F0 |
+      (d->sense.ascq)           & 0x000F;
+
+    return( errCode != 0 ? errCode : 1 );
+  }
+  else
+    return 0;
+}
diff --git a/libk3bdevice/k3bscsicommand_netbsd.cpp b/libk3bdevice/k3bscsicommand_netbsd.cpp
new file mode 100644
index 0000000..bd09e7a
--- /dev/null
+++ b/libk3bdevice/k3bscsicommand_netbsd.cpp
@@ -0,0 +1,111 @@
+/*
+ *
+ * $Id: sourceheader 511311 2006-02-19 14:51:05Z trueg $
+ * Copyright (C) 2006 Mark Davies <mark@mcs.vuw.ac.nz>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#include "k3bscsicommand.h"
+#include "k3bdevice.h"
+
+#include <k3bdebug.h>
+
+#include <sys/ioctl.h>
+#include <sys/scsiio.h>
+// #include <sys/cdio.h>
+// #include <sys/dkio.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+
+
+class K3bDevice::ScsiCommand::Private
+{
+public:
+  struct scsireq cmd;
+};
+
+
+void K3bDevice::ScsiCommand::clear()
+{
+  ::memset( &d->cmd, 0, sizeof(struct scsireq ) );
+}
+
+
+unsigned char& K3bDevice::ScsiCommand::operator[]( size_t i )
+{
+  if( d->cmd.cmdlen < i+1 )
+    d->cmd.cmdlen = i+1;
+  return d->cmd.cmd[i];
+}
+
+
+int K3bDevice::ScsiCommand::transport( TransportDirection dir,
+				       void* data,
+				       size_t len )
+{
+  bool needToClose = false;
+  if( m_device ) {
+      m_device->usageLock();
+      if( !m_device->isOpen() ) {
+          needToClose = true;
+      }
+      m_device->open( dir == TR_DIR_WRITE );
+      m_deviceHandle = m_device->handle();
+  }
+
+  if( m_deviceHandle == -1 ) {
+      if ( m_device ) {
+          m_device->usageUnlock();
+      }
+
+      return -1;
+  }
+
+  d->cmd.timeout = 10000;
+  d->cmd.databuf = (caddr_t) data;
+  d->cmd.datalen = len;
+  //  d->cmd.datalen_used = len;
+  d->cmd.senselen = SENSEBUFLEN;
+  switch (dir)
+  {
+  case TR_DIR_READ:
+      d->cmd.flags = SCCMD_READ;
+      break;
+  case TR_DIR_WRITE:
+      d->cmd.flags = SCCMD_WRITE;
+      break;
+  default:
+      d->cmd.flags = SCCMD_READ;
+      break;
+  }
+
+  int i = ::ioctl( m_deviceHandle, SCIOCCOMMAND, &d->cmd );
+
+  if ( m_device ) {
+      if( needToClose )
+          m_device->close();
+      m_device->usageUnlock();
+  }
+
+  if( i || (d->cmd.retsts != SCCMD_OK)) {
+      debugError( d->cmd.cmd[0],
+                  d->cmd.retsts,
+                  d->cmd.sense[2],
+                  d->cmd.sense[12],
+                  d->cmd.sense[13] );
+
+      return 1;
+  }
+  else
+      return 0;
+}
diff --git a/libk3bdevice/k3btoc.cpp b/libk3bdevice/k3btoc.cpp
new file mode 100644
index 0000000..570bc9e
--- /dev/null
+++ b/libk3bdevice/k3btoc.cpp
@@ -0,0 +1,163 @@
+/* 
+ *
+ * $Id: k3btoc.cpp 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#include "k3btoc.h"
+#include "k3bdebug.h"
+
+#include <qstring.h>
+
+
+K3bDevice::Toc::Toc()
+  : QValueList<K3bDevice::Track>()
+{
+}
+
+
+K3bDevice::Toc::Toc( const Toc& toc )
+  : QValueList<K3bDevice::Track>( toc )
+{
+  m_firstSector = toc.firstSector();
+}
+
+
+K3bDevice::Toc::~Toc()
+{
+}
+
+
+K3bDevice::Toc& K3bDevice::Toc::operator=( const Toc& toc )
+{
+  if( &toc == this ) return *this;
+
+  m_firstSector = toc.firstSector();
+
+  QValueList<K3bDevice::Track>::operator=( toc );
+
+  return *this;
+}
+
+
+const K3b::Msf& K3bDevice::Toc::firstSector() const
+{
+  return m_firstSector;
+}
+
+
+K3b::Msf K3bDevice::Toc::lastSector() const
+{
+  if( isEmpty() )
+    return 0;
+  // the last track's last sector should be the last sector of the entire cd
+  return last().lastSector();
+}
+
+
+K3b::Msf K3bDevice::Toc::length() const
+{
+  // +1 since the last sector is included
+  return lastSector() - firstSector() + 1;
+}
+
+
+unsigned int K3bDevice::Toc::discId() const
+{
+  // calculate cddb-id
+  unsigned int id = 0;
+  for( Toc::const_iterator it = constBegin(); it != constEnd(); ++it ) {
+    unsigned int n = (*it).firstSector().lba() + 150;
+    n /= 75;
+    while( n > 0 ) {
+      id += n % 10;
+      n /= 10;
+    }
+  }
+  unsigned int l = length().lba();
+  l /= 75;
+  id = ( ( id % 0xff ) << 24 ) | ( l << 8 ) | count();
+
+  return id;
+}
+
+
+int K3bDevice::Toc::contentType() const
+{
+  int audioCnt = 0, dataCnt = 0;
+  for( Toc::const_iterator it = constBegin(); it != constEnd(); ++it ) {
+    if( (*it).type() == K3bDevice::Track::AUDIO )
+      audioCnt++;
+    else
+      dataCnt++;
+  }
+
+  if( audioCnt + dataCnt == 0 )
+    return K3bDevice::NONE;
+  if( audioCnt == 0 )
+    return K3bDevice::DATA;
+  if( dataCnt == 0 )
+    return K3bDevice::AUDIO;
+  return K3bDevice::MIXED;
+}
+
+
+int K3bDevice::Toc::sessions() const
+{
+  if( isEmpty() )
+    return 0;
+  else if( last().session() == 0 )
+    return 1; // default if unknown
+  else
+    return last().session();
+}
+
+
+void K3bDevice::Toc::clear()
+{
+  QValueList<Track>::clear();
+  m_mcn.resize( 0 );
+  m_firstSector = 0;
+}
+
+
+void K3bDevice::Toc::debug() const
+{
+  k3bDebug() << count() << " in " << sessions() << " sessions" << endl;
+  int sessionN = 0;
+  int trackN = 0;
+  for( Toc::const_iterator it = begin(); it != end(); ++it ) {
+    ++trackN;
+    if( sessionN != (*it).session() ) {
+      sessionN = (*it).session();
+      k3bDebug() << "Session Number " << sessionN << endl;
+    }
+    k3bDebug() << "  Track " << trackN << ( (*it).type() == Track::AUDIO ? " AUDIO" : " DATA" )
+	      << " " << (*it).firstSector().lba() << " - " << (*it).lastSector().lba()
+	      << " (" << (*it).length().lba() << ")" << endl;
+  }
+}
+
+
+bool K3bDevice::Toc::operator==( const Toc& other ) const
+{
+  return( m_firstSector == other.m_firstSector &&
+	  QValueList<Track>::operator==( other ) );
+}
+
+
+bool K3bDevice::Toc::operator!=( const Toc& other ) const
+{
+  return( m_firstSector != other.m_firstSector ||
+	  QValueList<Track>::operator!=( other ) );
+}
diff --git a/libk3bdevice/k3btoc.h b/libk3bdevice/k3btoc.h
new file mode 100644
index 0000000..adfba74
--- /dev/null
+++ b/libk3bdevice/k3btoc.h
@@ -0,0 +1,101 @@
+/* 
+ *
+ * $Id: k3btoc.h 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#ifndef K3BTOC_H
+#define K3BTOC_H
+
+#include <qvaluelist.h>
+#include <qcstring.h>
+
+#include <k3bmsf.h>
+
+#include "k3btrack.h"
+#include "k3bdevice_export.h"
+class QString;
+
+namespace K3bDevice
+{
+
+  enum ContentsType {
+    DATA,
+    AUDIO,
+    MIXED,
+    NONE // no tracks
+  };
+
+  /**
+   * A list of K3bTracks that represents the contents
+   * of a cd.
+   * The Toc deletes all its tracks when it is deleted and
+   * deletes removed tracks.
+   */
+  class LIBK3BDEVICE_EXPORT Toc : public QValueList<K3bTrack>
+  {
+  public:
+    Toc();
+    /** deep copy */
+    Toc( const Toc& );
+    /** deletes all tracks */
+    ~Toc();
+    /** deep copy */
+    Toc& operator=( const Toc& );
+
+    /**
+     * CDDB disc Id
+     */
+    unsigned int discId() const;
+
+    const QCString& mcn() const { return m_mcn; }
+
+    /**
+     * determine the contents type based on the tracks' types.
+     * Audio, Data, or Mixed
+     */
+    int contentType() const;
+
+    /**
+     * \return the number of sessions in this TOC.
+     */
+    int sessions() const;
+
+    /**
+     * The first track's first sector could differ from the disc's
+     * first sector if there is a pregap before index 1
+     */
+    const K3b::Msf& firstSector() const;
+    K3b::Msf lastSector() const;
+    K3b::Msf length() const;
+
+    void setFirstSector( int i ) { m_firstSector = i; }
+
+    void setMcn( const QCString& mcn ) { m_mcn = mcn; }
+
+    void clear();
+
+    void debug() const;
+
+    bool operator==( const Toc& ) const;
+    bool operator!=( const Toc& ) const;
+
+  private:
+    unsigned int m_discId;
+    K3b::Msf m_firstSector;
+
+    QCString m_mcn;
+  };
+}
+
+#endif
diff --git a/libk3bdevice/k3btrack.cpp b/libk3bdevice/k3btrack.cpp
new file mode 100644
index 0000000..6efcdcb
--- /dev/null
+++ b/libk3bdevice/k3btrack.cpp
@@ -0,0 +1,123 @@
+/* 
+ *
+ * $Id: k3btrack.cpp 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+#include "k3btrack.h"
+
+
+K3bDevice::Track::Track()
+  : m_type(-1),
+    m_mode(-1),
+    m_copyPermitted(true),
+    m_preEmphasis(false),
+    m_session(0)
+{
+}
+
+
+K3bDevice::Track::Track( const Track& track )
+  : m_firstSector( track.firstSector() ),
+    m_lastSector( track.lastSector() ),
+    m_index0( track.index0() ),
+    m_type( track.type() ),
+    m_mode( track.mode() ),
+    m_copyPermitted( track.copyPermitted() ),
+    m_preEmphasis( track.preEmphasis() ),
+    m_session( track.session() ),
+    m_indices( track.indices() )
+{
+}
+
+
+K3bDevice::Track::Track( const K3b::Msf& firstSector, 
+			   const K3b::Msf& lastSector, 
+			   int type, 
+			   int mode )
+  : m_firstSector( firstSector ), 
+    m_lastSector( lastSector ), 
+    m_type( type ), 
+    m_mode( mode ), 
+    m_copyPermitted(true),
+    m_preEmphasis(false),
+    m_session(0)
+{
+}
+
+
+K3bDevice::Track& K3bDevice::Track::operator=( const K3bTrack& track )
+{
+  if( this != &track ) {
+    m_firstSector = track.firstSector();
+    m_lastSector = track.lastSector();
+    m_index0 = track.index0();
+    m_type = track.type();
+    m_mode = track.mode();
+    m_indices = track.indices();
+  }
+
+  return *this;
+}
+
+
+K3b::Msf K3bDevice::Track::length() const
+{
+  // +1 since the last sector is included
+  return m_lastSector - m_firstSector + 1;
+}
+
+
+K3b::Msf K3bDevice::Track::realAudioLength() const
+{
+  if( index0() > 0 )
+    return index0();
+  else
+    return length();
+}
+
+
+void K3bDevice::Track::setIndex0( const K3b::Msf& msf )
+{
+  if( msf <= m_lastSector-m_firstSector )
+    m_index0 = msf;
+}
+
+
+int K3bDevice::Track::indexCount() const
+{
+  return m_indices.count()-1;
+}
+
+
+bool K3bDevice::Track::operator==( const Track& other ) const
+{
+  return( m_firstSector == other.m_firstSector &&
+	  m_lastSector == other.m_lastSector &&
+	  m_index0 == other.m_index0 &&
+	  m_nextWritableAddress == other.m_nextWritableAddress &&
+	  m_freeBlocks == other.m_freeBlocks &&
+	  m_type == other.m_type &&
+	  m_mode == other.m_mode &&
+	  m_copyPermitted == other.m_copyPermitted &&
+	  m_preEmphasis == other.m_preEmphasis &&
+	  m_session == other.m_session &&
+	  m_indices == other.m_indices &&
+	  m_isrc == other.m_isrc );
+}
+
+
+bool K3bDevice::Track::operator!=( const Track& other ) const
+{
+  return !operator==( other );
+}
diff --git a/libk3bdevice/k3btrack.h b/libk3bdevice/k3btrack.h
new file mode 100644
index 0000000..f68cc86
--- /dev/null
+++ b/libk3bdevice/k3btrack.h
@@ -0,0 +1,151 @@
+/* 
+ *
+ * $Id: k3btrack.h 619556 2007-01-03 17:38:12Z trueg $
+ * Copyright (C) 2003-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * 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.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+
+
+#ifndef K3BTRACK_H
+#define K3BTRACK_H
+
+#include <qcstring.h>
+#include <qvaluevector.h>
+
+#include <k3bmsf.h>
+#include "k3bdevice_export.h"
+
+namespace K3bDevice
+{
+  class LIBK3BDEVICE_EXPORT Track
+  {
+    friend class Device;
+
+  public:
+    enum TrackType { 
+      AUDIO, 
+      DATA 
+    };
+
+    enum DataMode { 
+      MODE1, 
+      MODE2, 
+      XA_FORM1, 
+      XA_FORM2, 
+      DVD,
+      UNKNOWN
+    };
+
+    Track();
+    Track( const Track& );
+    Track( const K3b::Msf& firstSector, 
+	   const K3b::Msf& lastSector, 
+	   int type, 
+	   int mode = UNKNOWN );
+    Track& operator=( const Track& );
+
+    int type() const { return m_type; }
+
+    /**
+     * Invalid for DVDs and Audio CDs
+     */
+    int mode() const { return m_mode; }
+
+    /**
+     * Invalid for DVDs
+     */
+    bool copyPermitted() const { return m_copyPermitted; }
+    void setCopyPermitted( bool b ) { m_copyPermitted = b; }
+
+    /**
+     * Only valid for audio tracks
+     */
+    bool preEmphasis() const { return m_preEmphasis; }
+    void setPreEmphasis( bool b ) { m_preEmphasis = b; }
+
+    bool recordedIncremental() const { return m_preEmphasis; }
+    bool recordedUninterrupted() const { return !recordedIncremental(); }
+
+    const QCString& isrc() const { return m_isrc; }
+    void setIsrc( const QCString& s ) { m_isrc = s; }
+
+    const K3b::Msf& firstSector() const { return m_firstSector; }
+    const K3b::Msf& lastSector() const { return m_lastSector; }
+    void setFirstSector( const K3b::Msf& msf ) { m_firstSector = msf; }
+    void setLastSector( const K3b::Msf& msf ) { m_lastSector = msf; }
+
+    const K3b::Msf& nextWritableAddress() const { return m_nextWritableAddress; }
+    const K3b::Msf& freeBlocks() const { return m_freeBlocks; }
+
+    K3b::Msf length() const;
+
+    /**
+     * This takes index0 into account
+     */
+    K3b::Msf realAudioLength() const;
+
+    /**
+     * 0 if unknown
+     */
+    int session() const { return m_session; }
+    void setSession( int s ) { m_session = s; }
+
+    /**
+     * @return number of indices. This does not include index 0.
+     */
+    int indexCount() const;
+
+    /**
+     * Returns the index relative to the track's start.
+     * If it is zero there is no index0.
+     */
+    const K3b::Msf& index0() const { return m_index0; }
+
+    /**
+     * Set the track's index0 value.
+     * @param msf offset relative to track start.
+     */
+    void setIndex0( const K3b::Msf& msf );
+
+    /**
+     * All indices. Normally this list is empty as indices are rarely used.
+     * Starts with index 2 (since index 1 are all other sectors FIXME)
+     */
+    const QValueVector<K3b::Msf>& indices() const { return m_indices; }
+
+    bool operator==( const Track& ) const;
+    bool operator!=( const Track& ) const;
+
+  private:
+    K3b::Msf m_firstSector;
+    K3b::Msf m_lastSector;
+    K3b::Msf m_index0;
+
+    K3b::Msf m_nextWritableAddress;
+    K3b::Msf m_freeBlocks;
+
+    int m_type;
+    int m_mode;
+    bool m_copyPermitted;
+    bool m_preEmphasis;
+
+    int m_session;
+
+    QValueVector<K3b::Msf> m_indices;
+
+    QCString m_isrc;
+  };
+}
+
+typedef K3bDevice::Track K3bTrack;
+
+#endif
diff --git a/libk3bdevice/libk3bdevice.doxy b/libk3bdevice/libk3bdevice.doxy
new file mode 100644
index 0000000..cb7325a
--- /dev/null
+++ b/libk3bdevice/libk3bdevice.doxy
@@ -0,0 +1,214 @@
+# Doxyfile 1.3.9.1
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = libk3bdevice
+PROJECT_NUMBER         = 1.0
+OUTPUT_DIRECTORY       = docs/
+CREATE_SUBDIRS         = NO
+OUTPUT_LANGUAGE        = English
+USE_WINDOWS_ENCODING   = NO
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ABBREVIATE_BRIEF       = 
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        = 
+STRIP_FROM_INC_PATH    = 
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = NO
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP         = NO
+INHERIT_DOCS           = YES
+DISTRIBUTE_GROUP_DOC   = NO
+TAB_SIZE               = 8
+ALIASES                = 
+OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_JAVA   = NO
+SUBGROUPING            = YES
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = NO
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_METHODS  = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = YES
+HIDE_SCOPE_NAMES       = NO
+SHOW_INCLUDE_FILES     = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+SORT_BRIEF_DOCS        = NO
+SORT_BY_SCOPE_NAME     = NO
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = YES
+SHOW_DIRECTORIES       = YES
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = 
+FILE_PATTERNS          = *.h
+RECURSIVE              = NO
+EXCLUDE                = k3bmmc.h
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = 
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_PATTERNS        = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION    = NO
+VERBATIM_HEADERS       = NO
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = NO
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = 
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = 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         = 250
+#---------------------------------------------------------------------------
+# 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             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = NO
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = 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_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
+XML_PROGRAMLISTING     = YES
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX = 
+#---------------------------------------------------------------------------
+# 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             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::additions 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         = NO
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = NO
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+UML_LOOK               = YES
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = NO
+GRAPHICAL_HIERARCHY    = YES
+DOT_IMAGE_FORMAT       = png
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+MAX_DOT_GRAPH_DEPTH    = 0
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO
author	tpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>	2010-02-03 02:15:56 +0000
committer	tpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>	2010-02-03 02:15:56 +0000
commit	50b48aec6ddd451a6d1709c0942477b503457663 (patch)
tree	a9ece53ec06fd0a2819de7a2a6de997193566626 /libk3bdevice
download	k3b-50b48aec6ddd451a6d1709c0942477b503457663.tar.gz k3b-50b48aec6ddd451a6d1709c0942477b503457663.zip