legacy/experimental/python-libburn/pyburn.cpp

/* This file was generated by PyBindGen 0.10.0 */
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h>


#if PY_VERSION_HEX < 0x020400F0

#define PyEval_ThreadsInitialized() 1

#define Py_CLEAR(op)				\
        do {                            	\
                if (op) {			\
                        PyObject *tmp = (PyObject *)(op);	\
                        (op) = NULL;		\
                        Py_DECREF(tmp);		\
                }				\
        } while (0)


#define Py_VISIT(op)							\
        do { 								\
                if (op) {						\
                        int vret = visit((PyObject *)(op), arg);	\
                        if (vret)					\
                                return vret;				\
                }							\
        } while (0)

#endif



#if PY_VERSION_HEX < 0x020500F0

typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
typedef intobjargproc ssizeobjargproc;

#endif


#if     __GNUC__ > 2
# define PYBINDGEN_UNUSED(param) param __attribute__((__unused__))
#elif     __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
# define PYBINDGEN_UNUSED(param) __attribute__((__unused__)) param
#else
# define PYBINDGEN_UNUSED(param)
#endif  /* !__GNUC__ */

#include "libburn.h"
/* --- forward declarations --- */


typedef struct {
    PyObject_HEAD
    burn::burn_drive_info *obj;
} PyBurnBurn_drive_info;
    

extern PyTypeObject PyBurnBurn_drive_info_Type;


typedef struct {
    PyObject_HEAD
    burn::burn_multi_caps *obj;
} PyBurnBurn_multi_caps;
    

extern PyTypeObject PyBurnBurn_multi_caps_Type;


typedef struct {
    PyObject_HEAD
    burn::burn_progress *obj;
} PyBurnBurn_progress;
    

extern PyTypeObject PyBurnBurn_progress_Type;


typedef struct {
    PyObject_HEAD
    burn::burn_source *obj;
} PyBurnBurn_source;
    

extern PyTypeObject PyBurnBurn_source_Type;


typedef struct {
    PyObject_HEAD
    burn::burn_speed_descriptor *obj;
} PyBurnBurn_speed_descriptor;
    

extern PyTypeObject PyBurnBurn_speed_descriptor_Type;


typedef struct {
    PyObject_HEAD
    burn::burn_toc_entry *obj;
} PyBurnBurn_toc_entry;
    

extern PyTypeObject PyBurnBurn_toc_entry_Type;

/* --- module functions --- */


PyObject *
_wrap_burn_burnburn_drive_convert_fs_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    char *path2;
    char *adr2;
    const char *keywords[] = {"path", "adr", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "ss", (char **) keywords, &path2, &adr2)) {
        return NULL;
    }
    retval = burn::burn_drive_convert_fs_adr(path2, adr2);
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_burn_burnburn_drive_convert_fs_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_burn_burnburn_msgs_set_severities(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    char *queue_severity2;
    char *print_severity2;
    char *print_id2;
    const char *keywords[] = {"queue_severity", "print_severity", "print_id", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "sss", (char **) keywords, &queue_severity2, &print_severity2, &print_id2)) {
        return NULL;
    }
    retval = burn::burn_msgs_set_severities(queue_severity2, print_severity2, print_id2);
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_burn_burnburn_msgs_set_severities(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_burn_burnburn_finish()
{
    PyObject *py_retval;
    
    burn::burn_finish();
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_burn_burnburn_finish();


PyObject *
_wrap_burn_burnburn_drive_clear_whitelist()
{
    PyObject *py_retval;
    
    burn::burn_drive_clear_whitelist();
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_burn_burnburn_drive_clear_whitelist();


PyObject *
_wrap_burn_burnburn_drive_convert_scsi_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int bus_no2;
    int host_no2;
    int channel_no2;
    int target_no2;
    int lun_no2;
    char *adr2;
    const char *keywords[] = {"bus_no", "host_no", "channel_no", "target_no", "lun_no", "adr", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "iiiiis", (char **) keywords, &bus_no2, &host_no2, &channel_no2, &target_no2, &lun_no2, &adr2)) {
        return NULL;
    }
    retval = burn::burn_drive_convert_scsi_adr(bus_no2, host_no2, channel_no2, target_no2, lun_no2, adr2);
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_burn_burnburn_drive_convert_scsi_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_burn_burnburn_msf_to_sectors(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int m2;
    int s2;
    int f2;
    const char *keywords[] = {"m", "s", "f", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "iii", (char **) keywords, &m2, &s2, &f2)) {
        return NULL;
    }
    retval = burn::burn_msf_to_sectors(m2, s2, f2);
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_burn_burnburn_msf_to_sectors(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_burn_burnburn_drive_is_enumerable_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    char *adr2;
    const char *keywords[] = {"adr", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s", (char **) keywords, &adr2)) {
        return NULL;
    }
    retval = burn::burn_drive_is_enumerable_adr(adr2);
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_burn_burnburn_drive_is_enumerable_adr(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_burn_burnburn_allow_untested_profiles(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int yes2;
    const char *keywords[] = {"yes", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &yes2)) {
        return NULL;
    }
    burn::burn_allow_untested_profiles(yes2);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_burn_burnburn_allow_untested_profiles(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_burn_burnburn_preset_device_open(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int exclusive2;
    int blocking2;
    int abort_on_busy2;
    const char *keywords[] = {"exclusive", "blocking", "abort_on_busy", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "iii", (char **) keywords, &exclusive2, &blocking2, &abort_on_busy2)) {
        return NULL;
    }
    burn::burn_preset_device_open(exclusive2, blocking2, abort_on_busy2);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_burn_burnburn_preset_device_open(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_burn_burnburn_msf_to_lba(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int m2;
    int s2;
    int f2;
    const char *keywords[] = {"m", "s", "f", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "iii", (char **) keywords, &m2, &s2, &f2)) {
        return NULL;
    }
    retval = burn::burn_msf_to_lba(m2, s2, f2);
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_burn_burnburn_msf_to_lba(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_burn_burnburn_initialize()
{
    PyObject *py_retval;
    int retval;
    
    retval = burn::burn_initialize();
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_burn_burnburn_initialize();


PyObject *
_wrap_burn_burnburn_drive_add_whitelist(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    char *device_address2;
    const char *keywords[] = {"device_address", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s", (char **) keywords, &device_address2)) {
        return NULL;
    }
    retval = burn::burn_drive_add_whitelist(device_address2);
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_burn_burnburn_drive_add_whitelist(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_burn_burnburn_set_verbosity(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int level2;
    const char *keywords[] = {"level", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &level2)) {
        return NULL;
    }
    burn::burn_set_verbosity(level2);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_burn_burnburn_set_verbosity(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);

static PyMethodDef burn_burn_functions[] = {
    {(char *) "drive_convert_fs_adr", (PyCFunction) _wrap_burn_burnburn_drive_convert_fs_adr, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "msgs_set_severities", (PyCFunction) _wrap_burn_burnburn_msgs_set_severities, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "finish", (PyCFunction) _wrap_burn_burnburn_finish, METH_NOARGS, NULL },
    {(char *) "drive_clear_whitelist", (PyCFunction) _wrap_burn_burnburn_drive_clear_whitelist, METH_NOARGS, NULL },
    {(char *) "drive_convert_scsi_adr", (PyCFunction) _wrap_burn_burnburn_drive_convert_scsi_adr, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "msf_to_sectors", (PyCFunction) _wrap_burn_burnburn_msf_to_sectors, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "drive_is_enumerable_adr", (PyCFunction) _wrap_burn_burnburn_drive_is_enumerable_adr, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "allow_untested_profiles", (PyCFunction) _wrap_burn_burnburn_allow_untested_profiles, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "preset_device_open", (PyCFunction) _wrap_burn_burnburn_preset_device_open, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "msf_to_lba", (PyCFunction) _wrap_burn_burnburn_msf_to_lba, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "initialize", (PyCFunction) _wrap_burn_burnburn_initialize, METH_NOARGS, NULL },
    {(char *) "drive_add_whitelist", (PyCFunction) _wrap_burn_burnburn_drive_add_whitelist, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "set_verbosity", (PyCFunction) _wrap_burn_burnburn_set_verbosity, METH_KEYWORDS|METH_VARARGS, NULL },
    {NULL, NULL, 0, NULL}
};
/* --- classes --- */


static PyObject* _wrap_PyBurnBurn_drive_info__get_read_dvdram(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->read_dvdram));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_read_dvdram(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->read_dvdram)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_read_dvdr(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->read_dvdr));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_read_dvdr(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->read_dvdr)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_read_dvdrom(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->read_dvdrom));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_read_dvdrom(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->read_dvdrom)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_read_cdr(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->read_cdr));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_read_cdr(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->read_cdr)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_read_cdrw(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->read_cdrw));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_read_cdrw(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->read_cdrw)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_write_dvdram(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->write_dvdram));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_write_dvdram(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->write_dvdram)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_write_dvdr(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->write_dvdr));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_write_dvdr(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->write_dvdr)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_write_cdr(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->write_cdr));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_write_cdr(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->write_cdr)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_write_cdrw(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->write_cdrw));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_write_cdrw(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->write_cdrw)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_write_simulate(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->write_simulate));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_write_simulate(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->write_simulate)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_c2_errors(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->c2_errors));
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_c2_errors(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", self->obj->c2_errors)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_buffer_size(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->buffer_size);
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_buffer_size(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->buffer_size)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_tao_block_types(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->tao_block_types);
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_tao_block_types(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->tao_block_types)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_sao_block_types(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->sao_block_types);
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_sao_block_types(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->sao_block_types)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_raw_block_types(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->raw_block_types);
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_raw_block_types(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->raw_block_types)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_drive_info__get_packet_block_types(PyBurnBurn_drive_info *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->packet_block_types);
    return py_retval;
}
static int _wrap_PyBurnBurn_drive_info__set_packet_block_types(PyBurnBurn_drive_info *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->packet_block_types)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyGetSetDef PyBurnBurn_drive_info__getsets[] = {
    {
        (char*) "read_dvdrom", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_read_dvdrom, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_read_dvdrom, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "read_dvdram", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_read_dvdram, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_read_dvdram, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "tao_block_types", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_tao_block_types, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_tao_block_types, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "write_dvdr", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_write_dvdr, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_write_dvdr, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "read_dvdr", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_read_dvdr, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_read_dvdr, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "c2_errors", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_c2_errors, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_c2_errors, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "read_cdr", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_read_cdr, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_read_cdr, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "write_cdrw", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_write_cdrw, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_write_cdrw, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "write_dvdram", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_write_dvdram, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_write_dvdram, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "write_simulate", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_write_simulate, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_write_simulate, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "read_cdrw", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_read_cdrw, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_read_cdrw, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "packet_block_types", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_packet_block_types, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_packet_block_types, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "sao_block_types", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_sao_block_types, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_sao_block_types, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "buffer_size", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_buffer_size, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_buffer_size, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "write_cdr", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_write_cdr, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_write_cdr, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "raw_block_types", /* attribute name */
        (getter) _wrap_PyBurnBurn_drive_info__get_raw_block_types, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_drive_info__set_raw_block_types, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    { NULL, NULL, NULL, NULL, NULL }
};


static int
_wrap_PyBurnBurn_drive_info__tp_init__0(PyBurnBurn_drive_info *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    PyBurnBurn_drive_info *arg02;
    const char *keywords[] = {"arg0", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_drive_info_Type, &arg02)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_drive_info(*((PyBurnBurn_drive_info *) arg02)->obj);
    return 0;
}

static int
_wrap_PyBurnBurn_drive_info__tp_init__1(PyBurnBurn_drive_info *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    const char *keywords[] = {NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_drive_info();
    return 0;
}

int _wrap_PyBurnBurn_drive_info__tp_init(PyBurnBurn_drive_info *self, PyObject *args, PyObject *kwargs)
{
    int retval;
    PyObject *error_list;
    PyObject *exceptions[2] = {0,};
    retval = _wrap_PyBurnBurn_drive_info__tp_init__0(self, args, kwargs, &exceptions[0]);
    if (!exceptions[0]) {
        return retval;
    }
    retval = _wrap_PyBurnBurn_drive_info__tp_init__1(self, args, kwargs, &exceptions[1]);
    if (!exceptions[1]) {
        Py_DECREF(exceptions[0]);
        return retval;
    }
    error_list = PyList_New(2);
    PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0]));
    Py_DECREF(exceptions[0]);
    PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1]));
    Py_DECREF(exceptions[1]);
    PyErr_SetObject(PyExc_TypeError, error_list);
    Py_DECREF(error_list);
    return -1;
}


static PyObject*
_wrap_PyBurnBurn_drive_info__copy__(PyBurnBurn_drive_info *self)
{

    PyBurnBurn_drive_info *py_copy;
    py_copy = PyObject_New(PyBurnBurn_drive_info, &PyBurnBurn_drive_info_Type);
    py_copy->obj = new burn::burn_drive_info(*self->obj);
    return (PyObject*) py_copy;
}

static PyMethodDef PyBurnBurn_drive_info_methods[] = {
    {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_drive_info__copy__, METH_NOARGS, NULL},
    {NULL, NULL, 0, NULL}
};

static void
_wrap_PyBurnBurn_drive_info__tp_dealloc(PyBurnBurn_drive_info *self)
{
        burn::burn_drive_info *tmp = self->obj;
        self->obj = NULL;
        delete tmp;
    self->ob_type->tp_free((PyObject*)self);
}

static PyObject*
_wrap_PyBurnBurn_drive_info__tp_richcompare (PyBurnBurn_drive_info *self, PyBurnBurn_drive_info *other, int opid)
{
    
    if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_drive_info_Type)) {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }
    switch (opid)
    {
    case Py_LT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_LE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_EQ:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_NE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    } /* closes switch (opid) */
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

PyTypeObject PyBurnBurn_drive_info_Type = {
    PyObject_HEAD_INIT(NULL)
    0,                                 /* ob_size */
    (char *) "burn.burn.Burn_drive_info",            /* tp_name */
    sizeof(PyBurnBurn_drive_info),                  /* tp_basicsize */
    0,                                 /* tp_itemsize */
    /* methods */
    (destructor)_wrap_PyBurnBurn_drive_info__tp_dealloc,        /* tp_dealloc */
    (printfunc)0,                      /* tp_print */
    (getattrfunc)NULL,       /* tp_getattr */
    (setattrfunc)NULL,       /* tp_setattr */
    (cmpfunc)NULL,           /* tp_compare */
    (reprfunc)NULL,             /* tp_repr */
    (PyNumberMethods*)NULL,     /* tp_as_number */
    (PySequenceMethods*)NULL, /* tp_as_sequence */
    (PyMappingMethods*)NULL,   /* tp_as_mapping */
    (hashfunc)NULL,             /* tp_hash */
    (ternaryfunc)NULL,          /* tp_call */
    (reprfunc)NULL,              /* tp_str */
    (getattrofunc)NULL,     /* tp_getattro */
    (setattrofunc)NULL,     /* tp_setattro */
    (PyBufferProcs*)NULL,  /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT,                      /* tp_flags */
    NULL,                        /* Documentation string */
    (traverseproc)NULL,     /* tp_traverse */
    (inquiry)NULL,             /* tp_clear */
    (richcmpfunc)_wrap_PyBurnBurn_drive_info__tp_richcompare,   /* tp_richcompare */
    0,             /* tp_weaklistoffset */
    (getiterfunc)NULL,          /* tp_iter */
    (iternextfunc)NULL,     /* tp_iternext */
    (struct PyMethodDef*)PyBurnBurn_drive_info_methods, /* tp_methods */
    (struct PyMemberDef*)0,              /* tp_members */
    PyBurnBurn_drive_info__getsets,                     /* tp_getset */
    NULL,                              /* tp_base */
    NULL,                              /* tp_dict */
    (descrgetfunc)NULL,    /* tp_descr_get */
    (descrsetfunc)NULL,    /* tp_descr_set */
    0,                 /* tp_dictoffset */
    (initproc)_wrap_PyBurnBurn_drive_info__tp_init,             /* tp_init */
    (allocfunc)PyType_GenericAlloc,           /* tp_alloc */
    (newfunc)PyType_GenericNew,               /* tp_new */
    (freefunc)0,             /* tp_free */
    (inquiry)NULL,             /* tp_is_gc */
    NULL,                              /* tp_bases */
    NULL,                              /* tp_mro */
    NULL,                              /* tp_cache */
    NULL,                              /* tp_subclasses */
    NULL,                              /* tp_weaklist */
    (destructor) NULL                  /* tp_del */
};



static PyObject* _wrap_PyBurnBurn_multi_caps__get_multi_session(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->multi_session);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_multi_session(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->multi_session)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_multi_caps__get_multi_track(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->multi_track);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_multi_track(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->multi_track)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_multi_caps__get_start_adr(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->start_adr);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_start_adr(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->start_adr)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_multi_caps__get_might_do_tao(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->might_do_tao);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_might_do_tao(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->might_do_tao)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_multi_caps__get_might_do_sao(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->might_do_sao);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_might_do_sao(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->might_do_sao)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_multi_caps__get_might_do_raw(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->might_do_raw);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_might_do_raw(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->might_do_raw)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_multi_caps__get_advised_write_mode(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->advised_write_mode);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_advised_write_mode(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->advised_write_mode)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_multi_caps__get_selected_write_mode(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->selected_write_mode);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_selected_write_mode(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->selected_write_mode)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_multi_caps__get_current_profile(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->current_profile);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_current_profile(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->current_profile)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_multi_caps__get_current_is_cd_profile(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->current_is_cd_profile);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_current_is_cd_profile(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->current_is_cd_profile)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_multi_caps__get_might_simulate(PyBurnBurn_multi_caps *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->might_simulate);
    return py_retval;
}
static int _wrap_PyBurnBurn_multi_caps__set_might_simulate(PyBurnBurn_multi_caps *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->might_simulate)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyGetSetDef PyBurnBurn_multi_caps__getsets[] = {
    {
        (char*) "multi_track", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_multi_track, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_multi_track, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "advised_write_mode", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_advised_write_mode, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_advised_write_mode, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "current_profile", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_current_profile, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_current_profile, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "start_adr", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_start_adr, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_start_adr, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "might_do_sao", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_might_do_sao, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_might_do_sao, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "might_do_raw", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_might_do_raw, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_might_do_raw, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "might_simulate", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_might_simulate, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_might_simulate, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "multi_session", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_multi_session, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_multi_session, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "selected_write_mode", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_selected_write_mode, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_selected_write_mode, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "might_do_tao", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_might_do_tao, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_might_do_tao, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "current_is_cd_profile", /* attribute name */
        (getter) _wrap_PyBurnBurn_multi_caps__get_current_is_cd_profile, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_multi_caps__set_current_is_cd_profile, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    { NULL, NULL, NULL, NULL, NULL }
};


static int
_wrap_PyBurnBurn_multi_caps__tp_init__0(PyBurnBurn_multi_caps *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    PyBurnBurn_multi_caps *arg02;
    const char *keywords[] = {"arg0", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_multi_caps_Type, &arg02)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_multi_caps(*((PyBurnBurn_multi_caps *) arg02)->obj);
    return 0;
}

static int
_wrap_PyBurnBurn_multi_caps__tp_init__1(PyBurnBurn_multi_caps *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    const char *keywords[] = {NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_multi_caps();
    return 0;
}

int _wrap_PyBurnBurn_multi_caps__tp_init(PyBurnBurn_multi_caps *self, PyObject *args, PyObject *kwargs)
{
    int retval;
    PyObject *error_list;
    PyObject *exceptions[2] = {0,};
    retval = _wrap_PyBurnBurn_multi_caps__tp_init__0(self, args, kwargs, &exceptions[0]);
    if (!exceptions[0]) {
        return retval;
    }
    retval = _wrap_PyBurnBurn_multi_caps__tp_init__1(self, args, kwargs, &exceptions[1]);
    if (!exceptions[1]) {
        Py_DECREF(exceptions[0]);
        return retval;
    }
    error_list = PyList_New(2);
    PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0]));
    Py_DECREF(exceptions[0]);
    PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1]));
    Py_DECREF(exceptions[1]);
    PyErr_SetObject(PyExc_TypeError, error_list);
    Py_DECREF(error_list);
    return -1;
}


static PyObject*
_wrap_PyBurnBurn_multi_caps__copy__(PyBurnBurn_multi_caps *self)
{

    PyBurnBurn_multi_caps *py_copy;
    py_copy = PyObject_New(PyBurnBurn_multi_caps, &PyBurnBurn_multi_caps_Type);
    py_copy->obj = new burn::burn_multi_caps(*self->obj);
    return (PyObject*) py_copy;
}

static PyMethodDef PyBurnBurn_multi_caps_methods[] = {
    {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_multi_caps__copy__, METH_NOARGS, NULL},
    {NULL, NULL, 0, NULL}
};

static void
_wrap_PyBurnBurn_multi_caps__tp_dealloc(PyBurnBurn_multi_caps *self)
{
        burn::burn_multi_caps *tmp = self->obj;
        self->obj = NULL;
        delete tmp;
    self->ob_type->tp_free((PyObject*)self);
}

static PyObject*
_wrap_PyBurnBurn_multi_caps__tp_richcompare (PyBurnBurn_multi_caps *self, PyBurnBurn_multi_caps *other, int opid)
{
    
    if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_multi_caps_Type)) {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }
    switch (opid)
    {
    case Py_LT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_LE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_EQ:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_NE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    } /* closes switch (opid) */
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

PyTypeObject PyBurnBurn_multi_caps_Type = {
    PyObject_HEAD_INIT(NULL)
    0,                                 /* ob_size */
    (char *) "burn.burn.Burn_multi_caps",            /* tp_name */
    sizeof(PyBurnBurn_multi_caps),                  /* tp_basicsize */
    0,                                 /* tp_itemsize */
    /* methods */
    (destructor)_wrap_PyBurnBurn_multi_caps__tp_dealloc,        /* tp_dealloc */
    (printfunc)0,                      /* tp_print */
    (getattrfunc)NULL,       /* tp_getattr */
    (setattrfunc)NULL,       /* tp_setattr */
    (cmpfunc)NULL,           /* tp_compare */
    (reprfunc)NULL,             /* tp_repr */
    (PyNumberMethods*)NULL,     /* tp_as_number */
    (PySequenceMethods*)NULL, /* tp_as_sequence */
    (PyMappingMethods*)NULL,   /* tp_as_mapping */
    (hashfunc)NULL,             /* tp_hash */
    (ternaryfunc)NULL,          /* tp_call */
    (reprfunc)NULL,              /* tp_str */
    (getattrofunc)NULL,     /* tp_getattro */
    (setattrofunc)NULL,     /* tp_setattro */
    (PyBufferProcs*)NULL,  /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT,                      /* tp_flags */
    NULL,                        /* Documentation string */
    (traverseproc)NULL,     /* tp_traverse */
    (inquiry)NULL,             /* tp_clear */
    (richcmpfunc)_wrap_PyBurnBurn_multi_caps__tp_richcompare,   /* tp_richcompare */
    0,             /* tp_weaklistoffset */
    (getiterfunc)NULL,          /* tp_iter */
    (iternextfunc)NULL,     /* tp_iternext */
    (struct PyMethodDef*)PyBurnBurn_multi_caps_methods, /* tp_methods */
    (struct PyMemberDef*)0,              /* tp_members */
    PyBurnBurn_multi_caps__getsets,                     /* tp_getset */
    NULL,                              /* tp_base */
    NULL,                              /* tp_dict */
    (descrgetfunc)NULL,    /* tp_descr_get */
    (descrsetfunc)NULL,    /* tp_descr_set */
    0,                 /* tp_dictoffset */
    (initproc)_wrap_PyBurnBurn_multi_caps__tp_init,             /* tp_init */
    (allocfunc)PyType_GenericAlloc,           /* tp_alloc */
    (newfunc)PyType_GenericNew,               /* tp_new */
    (freefunc)0,             /* tp_free */
    (inquiry)NULL,             /* tp_is_gc */
    NULL,                              /* tp_bases */
    NULL,                              /* tp_mro */
    NULL,                              /* tp_cache */
    NULL,                              /* tp_subclasses */
    NULL,                              /* tp_weaklist */
    (destructor) NULL                  /* tp_del */
};



static PyObject* _wrap_PyBurnBurn_progress__get_sessions(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->sessions);
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_sessions(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->sessions)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_session(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->session);
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_session(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->session)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_tracks(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->tracks);
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_tracks(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->tracks)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_track(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->track);
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_track(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->track)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_indices(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->indices);
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_indices(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->indices)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_index(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->index);
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_index(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->index)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_start_sector(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->start_sector);
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_start_sector(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->start_sector)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_sectors(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->sectors);
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_sectors(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->sectors)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_sector(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->sector);
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_sector(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->sector)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_buffer_capacity(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->buffer_capacity));
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_buffer_capacity(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->buffer_capacity)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_buffer_available(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->buffer_available));
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_buffer_available(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->buffer_available)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_progress__get_buffer_min_fill(PyBurnBurn_progress *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(self->obj->buffer_min_fill));
    return py_retval;
}
static int _wrap_PyBurnBurn_progress__set_buffer_min_fill(PyBurnBurn_progress *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", &self->obj->buffer_min_fill)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyGetSetDef PyBurnBurn_progress__getsets[] = {
    {
        (char*) "sector", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_sector, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_sector, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "index", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_index, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_index, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "sectors", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_sectors, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_sectors, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "sessions", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_sessions, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_sessions, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "track", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_track, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_track, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "buffer_available", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_buffer_available, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_buffer_available, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "tracks", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_tracks, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_tracks, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "session", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_session, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_session, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "start_sector", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_start_sector, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_start_sector, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "buffer_capacity", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_buffer_capacity, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_buffer_capacity, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "indices", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_indices, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_indices, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "buffer_min_fill", /* attribute name */
        (getter) _wrap_PyBurnBurn_progress__get_buffer_min_fill, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_progress__set_buffer_min_fill, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    { NULL, NULL, NULL, NULL, NULL }
};


static int
_wrap_PyBurnBurn_progress__tp_init__0(PyBurnBurn_progress *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    PyBurnBurn_progress *arg02;
    const char *keywords[] = {"arg0", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_progress_Type, &arg02)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_progress(*((PyBurnBurn_progress *) arg02)->obj);
    return 0;
}

static int
_wrap_PyBurnBurn_progress__tp_init__1(PyBurnBurn_progress *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    const char *keywords[] = {NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_progress();
    return 0;
}

int _wrap_PyBurnBurn_progress__tp_init(PyBurnBurn_progress *self, PyObject *args, PyObject *kwargs)
{
    int retval;
    PyObject *error_list;
    PyObject *exceptions[2] = {0,};
    retval = _wrap_PyBurnBurn_progress__tp_init__0(self, args, kwargs, &exceptions[0]);
    if (!exceptions[0]) {
        return retval;
    }
    retval = _wrap_PyBurnBurn_progress__tp_init__1(self, args, kwargs, &exceptions[1]);
    if (!exceptions[1]) {
        Py_DECREF(exceptions[0]);
        return retval;
    }
    error_list = PyList_New(2);
    PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0]));
    Py_DECREF(exceptions[0]);
    PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1]));
    Py_DECREF(exceptions[1]);
    PyErr_SetObject(PyExc_TypeError, error_list);
    Py_DECREF(error_list);
    return -1;
}


static PyObject*
_wrap_PyBurnBurn_progress__copy__(PyBurnBurn_progress *self)
{

    PyBurnBurn_progress *py_copy;
    py_copy = PyObject_New(PyBurnBurn_progress, &PyBurnBurn_progress_Type);
    py_copy->obj = new burn::burn_progress(*self->obj);
    return (PyObject*) py_copy;
}

static PyMethodDef PyBurnBurn_progress_methods[] = {
    {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_progress__copy__, METH_NOARGS, NULL},
    {NULL, NULL, 0, NULL}
};

static void
_wrap_PyBurnBurn_progress__tp_dealloc(PyBurnBurn_progress *self)
{
        burn::burn_progress *tmp = self->obj;
        self->obj = NULL;
        delete tmp;
    self->ob_type->tp_free((PyObject*)self);
}

static PyObject*
_wrap_PyBurnBurn_progress__tp_richcompare (PyBurnBurn_progress *self, PyBurnBurn_progress *other, int opid)
{
    
    if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_progress_Type)) {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }
    switch (opid)
    {
    case Py_LT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_LE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_EQ:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_NE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    } /* closes switch (opid) */
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

PyTypeObject PyBurnBurn_progress_Type = {
    PyObject_HEAD_INIT(NULL)
    0,                                 /* ob_size */
    (char *) "burn.burn.Burn_progress",            /* tp_name */
    sizeof(PyBurnBurn_progress),                  /* tp_basicsize */
    0,                                 /* tp_itemsize */
    /* methods */
    (destructor)_wrap_PyBurnBurn_progress__tp_dealloc,        /* tp_dealloc */
    (printfunc)0,                      /* tp_print */
    (getattrfunc)NULL,       /* tp_getattr */
    (setattrfunc)NULL,       /* tp_setattr */
    (cmpfunc)NULL,           /* tp_compare */
    (reprfunc)NULL,             /* tp_repr */
    (PyNumberMethods*)NULL,     /* tp_as_number */
    (PySequenceMethods*)NULL, /* tp_as_sequence */
    (PyMappingMethods*)NULL,   /* tp_as_mapping */
    (hashfunc)NULL,             /* tp_hash */
    (ternaryfunc)NULL,          /* tp_call */
    (reprfunc)NULL,              /* tp_str */
    (getattrofunc)NULL,     /* tp_getattro */
    (setattrofunc)NULL,     /* tp_setattro */
    (PyBufferProcs*)NULL,  /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT,                      /* tp_flags */
    NULL,                        /* Documentation string */
    (traverseproc)NULL,     /* tp_traverse */
    (inquiry)NULL,             /* tp_clear */
    (richcmpfunc)_wrap_PyBurnBurn_progress__tp_richcompare,   /* tp_richcompare */
    0,             /* tp_weaklistoffset */
    (getiterfunc)NULL,          /* tp_iter */
    (iternextfunc)NULL,     /* tp_iternext */
    (struct PyMethodDef*)PyBurnBurn_progress_methods, /* tp_methods */
    (struct PyMemberDef*)0,              /* tp_members */
    PyBurnBurn_progress__getsets,                     /* tp_getset */
    NULL,                              /* tp_base */
    NULL,                              /* tp_dict */
    (descrgetfunc)NULL,    /* tp_descr_get */
    (descrsetfunc)NULL,    /* tp_descr_set */
    0,                 /* tp_dictoffset */
    (initproc)_wrap_PyBurnBurn_progress__tp_init,             /* tp_init */
    (allocfunc)PyType_GenericAlloc,           /* tp_alloc */
    (newfunc)PyType_GenericNew,               /* tp_new */
    (freefunc)0,             /* tp_free */
    (inquiry)NULL,             /* tp_is_gc */
    NULL,                              /* tp_bases */
    NULL,                              /* tp_mro */
    NULL,                              /* tp_cache */
    NULL,                              /* tp_subclasses */
    NULL,                              /* tp_weaklist */
    (destructor) NULL                  /* tp_del */
};



static PyObject* _wrap_PyBurnBurn_source__get_refcount(PyBurnBurn_source *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->refcount);
    return py_retval;
}
static int _wrap_PyBurnBurn_source__set_refcount(PyBurnBurn_source *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->refcount)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_source__get_version(PyBurnBurn_source *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->version);
    return py_retval;
}
static int _wrap_PyBurnBurn_source__set_version(PyBurnBurn_source *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->version)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyGetSetDef PyBurnBurn_source__getsets[] = {
    {
        (char*) "version", /* attribute name */
        (getter) _wrap_PyBurnBurn_source__get_version, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_source__set_version, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "refcount", /* attribute name */
        (getter) _wrap_PyBurnBurn_source__get_refcount, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_source__set_refcount, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    { NULL, NULL, NULL, NULL, NULL }
};


static int
_wrap_PyBurnBurn_source__tp_init__0(PyBurnBurn_source *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    PyBurnBurn_source *arg02;
    const char *keywords[] = {"arg0", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_source_Type, &arg02)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_source(*((PyBurnBurn_source *) arg02)->obj);
    return 0;
}

static int
_wrap_PyBurnBurn_source__tp_init__1(PyBurnBurn_source *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    const char *keywords[] = {NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_source();
    return 0;
}

int _wrap_PyBurnBurn_source__tp_init(PyBurnBurn_source *self, PyObject *args, PyObject *kwargs)
{
    int retval;
    PyObject *error_list;
    PyObject *exceptions[2] = {0,};
    retval = _wrap_PyBurnBurn_source__tp_init__0(self, args, kwargs, &exceptions[0]);
    if (!exceptions[0]) {
        return retval;
    }
    retval = _wrap_PyBurnBurn_source__tp_init__1(self, args, kwargs, &exceptions[1]);
    if (!exceptions[1]) {
        Py_DECREF(exceptions[0]);
        return retval;
    }
    error_list = PyList_New(2);
    PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0]));
    Py_DECREF(exceptions[0]);
    PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1]));
    Py_DECREF(exceptions[1]);
    PyErr_SetObject(PyExc_TypeError, error_list);
    Py_DECREF(error_list);
    return -1;
}


static PyObject*
_wrap_PyBurnBurn_source__copy__(PyBurnBurn_source *self)
{

    PyBurnBurn_source *py_copy;
    py_copy = PyObject_New(PyBurnBurn_source, &PyBurnBurn_source_Type);
    py_copy->obj = new burn::burn_source(*self->obj);
    return (PyObject*) py_copy;
}

static PyMethodDef PyBurnBurn_source_methods[] = {
    {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_source__copy__, METH_NOARGS, NULL},
    {NULL, NULL, 0, NULL}
};

static void
_wrap_PyBurnBurn_source__tp_dealloc(PyBurnBurn_source *self)
{
        burn::burn_source *tmp = self->obj;
        self->obj = NULL;
        delete tmp;
    self->ob_type->tp_free((PyObject*)self);
}

static PyObject*
_wrap_PyBurnBurn_source__tp_richcompare (PyBurnBurn_source *self, PyBurnBurn_source *other, int opid)
{
    
    if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_source_Type)) {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }
    switch (opid)
    {
    case Py_LT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_LE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_EQ:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_NE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    } /* closes switch (opid) */
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

PyTypeObject PyBurnBurn_source_Type = {
    PyObject_HEAD_INIT(NULL)
    0,                                 /* ob_size */
    (char *) "burn.burn.Burn_source",            /* tp_name */
    sizeof(PyBurnBurn_source),                  /* tp_basicsize */
    0,                                 /* tp_itemsize */
    /* methods */
    (destructor)_wrap_PyBurnBurn_source__tp_dealloc,        /* tp_dealloc */
    (printfunc)0,                      /* tp_print */
    (getattrfunc)NULL,       /* tp_getattr */
    (setattrfunc)NULL,       /* tp_setattr */
    (cmpfunc)NULL,           /* tp_compare */
    (reprfunc)NULL,             /* tp_repr */
    (PyNumberMethods*)NULL,     /* tp_as_number */
    (PySequenceMethods*)NULL, /* tp_as_sequence */
    (PyMappingMethods*)NULL,   /* tp_as_mapping */
    (hashfunc)NULL,             /* tp_hash */
    (ternaryfunc)NULL,          /* tp_call */
    (reprfunc)NULL,              /* tp_str */
    (getattrofunc)NULL,     /* tp_getattro */
    (setattrofunc)NULL,     /* tp_setattro */
    (PyBufferProcs*)NULL,  /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT,                      /* tp_flags */
    NULL,                        /* Documentation string */
    (traverseproc)NULL,     /* tp_traverse */
    (inquiry)NULL,             /* tp_clear */
    (richcmpfunc)_wrap_PyBurnBurn_source__tp_richcompare,   /* tp_richcompare */
    0,             /* tp_weaklistoffset */
    (getiterfunc)NULL,          /* tp_iter */
    (iternextfunc)NULL,     /* tp_iternext */
    (struct PyMethodDef*)PyBurnBurn_source_methods, /* tp_methods */
    (struct PyMemberDef*)0,              /* tp_members */
    PyBurnBurn_source__getsets,                     /* tp_getset */
    NULL,                              /* tp_base */
    NULL,                              /* tp_dict */
    (descrgetfunc)NULL,    /* tp_descr_get */
    (descrsetfunc)NULL,    /* tp_descr_set */
    0,                 /* tp_dictoffset */
    (initproc)_wrap_PyBurnBurn_source__tp_init,             /* tp_init */
    (allocfunc)PyType_GenericAlloc,           /* tp_alloc */
    (newfunc)PyType_GenericNew,               /* tp_new */
    (freefunc)0,             /* tp_free */
    (inquiry)NULL,             /* tp_is_gc */
    NULL,                              /* tp_bases */
    NULL,                              /* tp_mro */
    NULL,                              /* tp_cache */
    NULL,                              /* tp_subclasses */
    NULL,                              /* tp_weaklist */
    (destructor) NULL                  /* tp_del */
};



static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_source(PyBurnBurn_speed_descriptor *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->source);
    return py_retval;
}
static int _wrap_PyBurnBurn_speed_descriptor__set_source(PyBurnBurn_speed_descriptor *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->source)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_profile_loaded(PyBurnBurn_speed_descriptor *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->profile_loaded);
    return py_retval;
}
static int _wrap_PyBurnBurn_speed_descriptor__set_profile_loaded(PyBurnBurn_speed_descriptor *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->profile_loaded)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_end_lba(PyBurnBurn_speed_descriptor *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->end_lba);
    return py_retval;
}
static int _wrap_PyBurnBurn_speed_descriptor__set_end_lba(PyBurnBurn_speed_descriptor *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->end_lba)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_write_speed(PyBurnBurn_speed_descriptor *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->write_speed);
    return py_retval;
}
static int _wrap_PyBurnBurn_speed_descriptor__set_write_speed(PyBurnBurn_speed_descriptor *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->write_speed)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_read_speed(PyBurnBurn_speed_descriptor *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->read_speed);
    return py_retval;
}
static int _wrap_PyBurnBurn_speed_descriptor__set_read_speed(PyBurnBurn_speed_descriptor *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->read_speed)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_wrc(PyBurnBurn_speed_descriptor *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->wrc);
    return py_retval;
}
static int _wrap_PyBurnBurn_speed_descriptor__set_wrc(PyBurnBurn_speed_descriptor *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->wrc)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_exact(PyBurnBurn_speed_descriptor *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->exact);
    return py_retval;
}
static int _wrap_PyBurnBurn_speed_descriptor__set_exact(PyBurnBurn_speed_descriptor *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->exact)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_speed_descriptor__get_mrw(PyBurnBurn_speed_descriptor *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->mrw);
    return py_retval;
}
static int _wrap_PyBurnBurn_speed_descriptor__set_mrw(PyBurnBurn_speed_descriptor *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->mrw)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyGetSetDef PyBurnBurn_speed_descriptor__getsets[] = {
    {
        (char*) "mrw", /* attribute name */
        (getter) _wrap_PyBurnBurn_speed_descriptor__get_mrw, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_speed_descriptor__set_mrw, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "wrc", /* attribute name */
        (getter) _wrap_PyBurnBurn_speed_descriptor__get_wrc, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_speed_descriptor__set_wrc, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "profile_loaded", /* attribute name */
        (getter) _wrap_PyBurnBurn_speed_descriptor__get_profile_loaded, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_speed_descriptor__set_profile_loaded, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "source", /* attribute name */
        (getter) _wrap_PyBurnBurn_speed_descriptor__get_source, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_speed_descriptor__set_source, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "write_speed", /* attribute name */
        (getter) _wrap_PyBurnBurn_speed_descriptor__get_write_speed, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_speed_descriptor__set_write_speed, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "end_lba", /* attribute name */
        (getter) _wrap_PyBurnBurn_speed_descriptor__get_end_lba, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_speed_descriptor__set_end_lba, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "exact", /* attribute name */
        (getter) _wrap_PyBurnBurn_speed_descriptor__get_exact, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_speed_descriptor__set_exact, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "read_speed", /* attribute name */
        (getter) _wrap_PyBurnBurn_speed_descriptor__get_read_speed, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_speed_descriptor__set_read_speed, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    { NULL, NULL, NULL, NULL, NULL }
};


static int
_wrap_PyBurnBurn_speed_descriptor__tp_init__0(PyBurnBurn_speed_descriptor *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    PyBurnBurn_speed_descriptor *arg02;
    const char *keywords[] = {"arg0", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_speed_descriptor_Type, &arg02)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_speed_descriptor(*((PyBurnBurn_speed_descriptor *) arg02)->obj);
    return 0;
}

static int
_wrap_PyBurnBurn_speed_descriptor__tp_init__1(PyBurnBurn_speed_descriptor *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    const char *keywords[] = {NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_speed_descriptor();
    return 0;
}

int _wrap_PyBurnBurn_speed_descriptor__tp_init(PyBurnBurn_speed_descriptor *self, PyObject *args, PyObject *kwargs)
{
    int retval;
    PyObject *error_list;
    PyObject *exceptions[2] = {0,};
    retval = _wrap_PyBurnBurn_speed_descriptor__tp_init__0(self, args, kwargs, &exceptions[0]);
    if (!exceptions[0]) {
        return retval;
    }
    retval = _wrap_PyBurnBurn_speed_descriptor__tp_init__1(self, args, kwargs, &exceptions[1]);
    if (!exceptions[1]) {
        Py_DECREF(exceptions[0]);
        return retval;
    }
    error_list = PyList_New(2);
    PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0]));
    Py_DECREF(exceptions[0]);
    PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1]));
    Py_DECREF(exceptions[1]);
    PyErr_SetObject(PyExc_TypeError, error_list);
    Py_DECREF(error_list);
    return -1;
}


static PyObject*
_wrap_PyBurnBurn_speed_descriptor__copy__(PyBurnBurn_speed_descriptor *self)
{

    PyBurnBurn_speed_descriptor *py_copy;
    py_copy = PyObject_New(PyBurnBurn_speed_descriptor, &PyBurnBurn_speed_descriptor_Type);
    py_copy->obj = new burn::burn_speed_descriptor(*self->obj);
    return (PyObject*) py_copy;
}

static PyMethodDef PyBurnBurn_speed_descriptor_methods[] = {
    {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_speed_descriptor__copy__, METH_NOARGS, NULL},
    {NULL, NULL, 0, NULL}
};

static void
_wrap_PyBurnBurn_speed_descriptor__tp_dealloc(PyBurnBurn_speed_descriptor *self)
{
        burn::burn_speed_descriptor *tmp = self->obj;
        self->obj = NULL;
        delete tmp;
    self->ob_type->tp_free((PyObject*)self);
}

static PyObject*
_wrap_PyBurnBurn_speed_descriptor__tp_richcompare (PyBurnBurn_speed_descriptor *self, PyBurnBurn_speed_descriptor *other, int opid)
{
    
    if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_speed_descriptor_Type)) {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }
    switch (opid)
    {
    case Py_LT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_LE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_EQ:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_NE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    } /* closes switch (opid) */
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

PyTypeObject PyBurnBurn_speed_descriptor_Type = {
    PyObject_HEAD_INIT(NULL)
    0,                                 /* ob_size */
    (char *) "burn.burn.Burn_speed_descriptor",            /* tp_name */
    sizeof(PyBurnBurn_speed_descriptor),                  /* tp_basicsize */
    0,                                 /* tp_itemsize */
    /* methods */
    (destructor)_wrap_PyBurnBurn_speed_descriptor__tp_dealloc,        /* tp_dealloc */
    (printfunc)0,                      /* tp_print */
    (getattrfunc)NULL,       /* tp_getattr */
    (setattrfunc)NULL,       /* tp_setattr */
    (cmpfunc)NULL,           /* tp_compare */
    (reprfunc)NULL,             /* tp_repr */
    (PyNumberMethods*)NULL,     /* tp_as_number */
    (PySequenceMethods*)NULL, /* tp_as_sequence */
    (PyMappingMethods*)NULL,   /* tp_as_mapping */
    (hashfunc)NULL,             /* tp_hash */
    (ternaryfunc)NULL,          /* tp_call */
    (reprfunc)NULL,              /* tp_str */
    (getattrofunc)NULL,     /* tp_getattro */
    (setattrofunc)NULL,     /* tp_setattro */
    (PyBufferProcs*)NULL,  /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT,                      /* tp_flags */
    NULL,                        /* Documentation string */
    (traverseproc)NULL,     /* tp_traverse */
    (inquiry)NULL,             /* tp_clear */
    (richcmpfunc)_wrap_PyBurnBurn_speed_descriptor__tp_richcompare,   /* tp_richcompare */
    0,             /* tp_weaklistoffset */
    (getiterfunc)NULL,          /* tp_iter */
    (iternextfunc)NULL,     /* tp_iternext */
    (struct PyMethodDef*)PyBurnBurn_speed_descriptor_methods, /* tp_methods */
    (struct PyMemberDef*)0,              /* tp_members */
    PyBurnBurn_speed_descriptor__getsets,                     /* tp_getset */
    NULL,                              /* tp_base */
    NULL,                              /* tp_dict */
    (descrgetfunc)NULL,    /* tp_descr_get */
    (descrsetfunc)NULL,    /* tp_descr_set */
    0,                 /* tp_dictoffset */
    (initproc)_wrap_PyBurnBurn_speed_descriptor__tp_init,             /* tp_init */
    (allocfunc)PyType_GenericAlloc,           /* tp_alloc */
    (newfunc)PyType_GenericNew,               /* tp_new */
    (freefunc)0,             /* tp_free */
    (inquiry)NULL,             /* tp_is_gc */
    NULL,                              /* tp_bases */
    NULL,                              /* tp_mro */
    NULL,                              /* tp_cache */
    NULL,                              /* tp_subclasses */
    NULL,                              /* tp_weaklist */
    (destructor) NULL                  /* tp_del */
};



static PyObject* _wrap_PyBurnBurn_toc_entry__get_start_lba(PyBurnBurn_toc_entry *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->start_lba);
    return py_retval;
}
static int _wrap_PyBurnBurn_toc_entry__set_start_lba(PyBurnBurn_toc_entry *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->start_lba)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyObject* _wrap_PyBurnBurn_toc_entry__get_track_blocks(PyBurnBurn_toc_entry *self)
{
    PyObject *py_retval;
    
    py_retval = Py_BuildValue((char *) "i", self->obj->track_blocks);
    return py_retval;
}
static int _wrap_PyBurnBurn_toc_entry__set_track_blocks(PyBurnBurn_toc_entry *self, PyObject *value)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = Py_BuildValue((char *) "(O)", value);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &self->obj->track_blocks)) {
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return -1;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return 0;
}
static PyGetSetDef PyBurnBurn_toc_entry__getsets[] = {
    {
        (char*) "track_blocks", /* attribute name */
        (getter) _wrap_PyBurnBurn_toc_entry__get_track_blocks, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_toc_entry__set_track_blocks, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    {
        (char*) "start_lba", /* attribute name */
        (getter) _wrap_PyBurnBurn_toc_entry__get_start_lba, /* C function to get the attribute */
        (setter) _wrap_PyBurnBurn_toc_entry__set_start_lba, /* C function to set the attribute */
        NULL, /* optional doc string */
        NULL /* optional additional data for getter and setter */
    },
    { NULL, NULL, NULL, NULL, NULL }
};


static int
_wrap_PyBurnBurn_toc_entry__tp_init__0(PyBurnBurn_toc_entry *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    PyBurnBurn_toc_entry *arg02;
    const char *keywords[] = {"arg0", NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyBurnBurn_toc_entry_Type, &arg02)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_toc_entry(*((PyBurnBurn_toc_entry *) arg02)->obj);
    return 0;
}

static int
_wrap_PyBurnBurn_toc_entry__tp_init__1(PyBurnBurn_toc_entry *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
{
    const char *keywords[] = {NULL};
    
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "", (char **) keywords)) {
        {
            PyObject *exc_type, *traceback;
            PyErr_Fetch(&exc_type, return_exception, &traceback);
            Py_XDECREF(exc_type);
            Py_XDECREF(traceback);
        }
        return -1;
    }
    self->obj = new burn::burn_toc_entry();
    return 0;
}

int _wrap_PyBurnBurn_toc_entry__tp_init(PyBurnBurn_toc_entry *self, PyObject *args, PyObject *kwargs)
{
    int retval;
    PyObject *error_list;
    PyObject *exceptions[2] = {0,};
    retval = _wrap_PyBurnBurn_toc_entry__tp_init__0(self, args, kwargs, &exceptions[0]);
    if (!exceptions[0]) {
        return retval;
    }
    retval = _wrap_PyBurnBurn_toc_entry__tp_init__1(self, args, kwargs, &exceptions[1]);
    if (!exceptions[1]) {
        Py_DECREF(exceptions[0]);
        return retval;
    }
    error_list = PyList_New(2);
    PyList_SET_ITEM(error_list, 0, PyObject_Str(exceptions[0]));
    Py_DECREF(exceptions[0]);
    PyList_SET_ITEM(error_list, 1, PyObject_Str(exceptions[1]));
    Py_DECREF(exceptions[1]);
    PyErr_SetObject(PyExc_TypeError, error_list);
    Py_DECREF(error_list);
    return -1;
}


static PyObject*
_wrap_PyBurnBurn_toc_entry__copy__(PyBurnBurn_toc_entry *self)
{

    PyBurnBurn_toc_entry *py_copy;
    py_copy = PyObject_New(PyBurnBurn_toc_entry, &PyBurnBurn_toc_entry_Type);
    py_copy->obj = new burn::burn_toc_entry(*self->obj);
    return (PyObject*) py_copy;
}

static PyMethodDef PyBurnBurn_toc_entry_methods[] = {
    {(char *) "__copy__", (PyCFunction) _wrap_PyBurnBurn_toc_entry__copy__, METH_NOARGS, NULL},
    {NULL, NULL, 0, NULL}
};

static void
_wrap_PyBurnBurn_toc_entry__tp_dealloc(PyBurnBurn_toc_entry *self)
{
        burn::burn_toc_entry *tmp = self->obj;
        self->obj = NULL;
        delete tmp;
    self->ob_type->tp_free((PyObject*)self);
}

static PyObject*
_wrap_PyBurnBurn_toc_entry__tp_richcompare (PyBurnBurn_toc_entry *self, PyBurnBurn_toc_entry *other, int opid)
{
    
    if (!PyObject_IsInstance((PyObject*) other, (PyObject*) &PyBurnBurn_toc_entry_Type)) {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }
    switch (opid)
    {
    case Py_LT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_LE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_EQ:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_NE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GE:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    case Py_GT:
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    } /* closes switch (opid) */
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

PyTypeObject PyBurnBurn_toc_entry_Type = {
    PyObject_HEAD_INIT(NULL)
    0,                                 /* ob_size */
    (char *) "burn.burn.Burn_toc_entry",            /* tp_name */
    sizeof(PyBurnBurn_toc_entry),                  /* tp_basicsize */
    0,                                 /* tp_itemsize */
    /* methods */
    (destructor)_wrap_PyBurnBurn_toc_entry__tp_dealloc,        /* tp_dealloc */
    (printfunc)0,                      /* tp_print */
    (getattrfunc)NULL,       /* tp_getattr */
    (setattrfunc)NULL,       /* tp_setattr */
    (cmpfunc)NULL,           /* tp_compare */
    (reprfunc)NULL,             /* tp_repr */
    (PyNumberMethods*)NULL,     /* tp_as_number */
    (PySequenceMethods*)NULL, /* tp_as_sequence */
    (PyMappingMethods*)NULL,   /* tp_as_mapping */
    (hashfunc)NULL,             /* tp_hash */
    (ternaryfunc)NULL,          /* tp_call */
    (reprfunc)NULL,              /* tp_str */
    (getattrofunc)NULL,     /* tp_getattro */
    (setattrofunc)NULL,     /* tp_setattro */
    (PyBufferProcs*)NULL,  /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT,                      /* tp_flags */
    NULL,                        /* Documentation string */
    (traverseproc)NULL,     /* tp_traverse */
    (inquiry)NULL,             /* tp_clear */
    (richcmpfunc)_wrap_PyBurnBurn_toc_entry__tp_richcompare,   /* tp_richcompare */
    0,             /* tp_weaklistoffset */
    (getiterfunc)NULL,          /* tp_iter */
    (iternextfunc)NULL,     /* tp_iternext */
    (struct PyMethodDef*)PyBurnBurn_toc_entry_methods, /* tp_methods */
    (struct PyMemberDef*)0,              /* tp_members */
    PyBurnBurn_toc_entry__getsets,                     /* tp_getset */
    NULL,                              /* tp_base */
    NULL,                              /* tp_dict */
    (descrgetfunc)NULL,    /* tp_descr_get */
    (descrsetfunc)NULL,    /* tp_descr_set */
    0,                 /* tp_dictoffset */
    (initproc)_wrap_PyBurnBurn_toc_entry__tp_init,             /* tp_init */
    (allocfunc)PyType_GenericAlloc,           /* tp_alloc */
    (newfunc)PyType_GenericNew,               /* tp_new */
    (freefunc)0,             /* tp_free */
    (inquiry)NULL,             /* tp_is_gc */
    NULL,                              /* tp_bases */
    NULL,                              /* tp_mro */
    NULL,                              /* tp_cache */
    NULL,                              /* tp_subclasses */
    NULL,                              /* tp_weaklist */
    (destructor) NULL                  /* tp_del */
};


/* --- enumerations --- */












static PyObject *
initpyburn_burn(void)
{
    PyObject *m;
    m = Py_InitModule3((char *) "pyburn.burn", burn_burn_functions, NULL);
    if (m == NULL) {
        return NULL;
    }
    /* Register the 'burn::burn_drive_info' class */
    if (PyType_Ready(&PyBurnBurn_drive_info_Type)) {
        return NULL;
    }
    PyModule_AddObject(m, (char *) "burn_drive_info", (PyObject *) &PyBurnBurn_drive_info_Type);
    /* Register the 'burn::burn_multi_caps' class */
    if (PyType_Ready(&PyBurnBurn_multi_caps_Type)) {
        return NULL;
    }
    PyModule_AddObject(m, (char *) "burn_multi_caps", (PyObject *) &PyBurnBurn_multi_caps_Type);
    /* Register the 'burn::burn_progress' class */
    if (PyType_Ready(&PyBurnBurn_progress_Type)) {
        return NULL;
    }
    PyModule_AddObject(m, (char *) "burn_progress", (PyObject *) &PyBurnBurn_progress_Type);
    /* Register the 'burn::burn_source' class */
    if (PyType_Ready(&PyBurnBurn_source_Type)) {
        return NULL;
    }
    PyModule_AddObject(m, (char *) "burn_source", (PyObject *) &PyBurnBurn_source_Type);
    /* Register the 'burn::burn_speed_descriptor' class */
    if (PyType_Ready(&PyBurnBurn_speed_descriptor_Type)) {
        return NULL;
    }
    PyModule_AddObject(m, (char *) "burn_speed_descriptor", (PyObject *) &PyBurnBurn_speed_descriptor_Type);
    /* Register the 'burn::burn_toc_entry' class */
    if (PyType_Ready(&PyBurnBurn_toc_entry_Type)) {
        return NULL;
    }
    PyModule_AddObject(m, (char *) "burn_toc_entry", (PyObject *) &PyBurnBurn_toc_entry_Type);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_RAW0", burn::BURN_BLOCK_RAW0);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_RAW16", burn::BURN_BLOCK_RAW16);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_RAW96P", burn::BURN_BLOCK_RAW96P);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_RAW96R", burn::BURN_BLOCK_RAW96R);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE1", burn::BURN_BLOCK_MODE1);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE2R", burn::BURN_BLOCK_MODE2R);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE2_PATHETIC", burn::BURN_BLOCK_MODE2_PATHETIC);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE2_LAME", burn::BURN_BLOCK_MODE2_LAME);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE2_OBSCURE", burn::BURN_BLOCK_MODE2_OBSCURE);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_MODE2_OK", burn::BURN_BLOCK_MODE2_OK);
    PyModule_AddIntConstant(m, (char *) "BURN_BLOCK_SAO", burn::BURN_BLOCK_SAO);
    PyModule_AddIntConstant(m, (char *) "BURN_DISC_UNREADY", burn::BURN_DISC_UNREADY);
    PyModule_AddIntConstant(m, (char *) "BURN_DISC_BLANK", burn::BURN_DISC_BLANK);
    PyModule_AddIntConstant(m, (char *) "BURN_DISC_EMPTY", burn::BURN_DISC_EMPTY);
    PyModule_AddIntConstant(m, (char *) "BURN_DISC_APPENDABLE", burn::BURN_DISC_APPENDABLE);
    PyModule_AddIntConstant(m, (char *) "BURN_DISC_FULL", burn::BURN_DISC_FULL);
    PyModule_AddIntConstant(m, (char *) "BURN_DISC_UNGRABBED", burn::BURN_DISC_UNGRABBED);
    PyModule_AddIntConstant(m, (char *) "BURN_DISC_UNSUITABLE", burn::BURN_DISC_UNSUITABLE);
    PyModule_AddIntConstant(m, (char *) "BURN_SOURCE_OK", burn::BURN_SOURCE_OK);
    PyModule_AddIntConstant(m, (char *) "BURN_SOURCE_EOF", burn::BURN_SOURCE_EOF);
    PyModule_AddIntConstant(m, (char *) "BURN_SOURCE_FAILED", burn::BURN_SOURCE_FAILED);
    PyModule_AddIntConstant(m, (char *) "BURN_WRITE_PACKET", burn::BURN_WRITE_PACKET);
    PyModule_AddIntConstant(m, (char *) "BURN_WRITE_TAO", burn::BURN_WRITE_TAO);
    PyModule_AddIntConstant(m, (char *) "BURN_WRITE_SAO", burn::BURN_WRITE_SAO);
    PyModule_AddIntConstant(m, (char *) "BURN_WRITE_RAW", burn::BURN_WRITE_RAW);
    PyModule_AddIntConstant(m, (char *) "BURN_WRITE_NONE", burn::BURN_WRITE_NONE);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_IDLE", burn::BURN_DRIVE_IDLE);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_SPAWNING", burn::BURN_DRIVE_SPAWNING);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_READING", burn::BURN_DRIVE_READING);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_WRITING", burn::BURN_DRIVE_WRITING);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_WRITING_LEADIN", burn::BURN_DRIVE_WRITING_LEADIN);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_WRITING_LEADOUT", burn::BURN_DRIVE_WRITING_LEADOUT);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_ERASING", burn::BURN_DRIVE_ERASING);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_GRABBING", burn::BURN_DRIVE_GRABBING);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_WRITING_PREGAP", burn::BURN_DRIVE_WRITING_PREGAP);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_CLOSING_TRACK", burn::BURN_DRIVE_CLOSING_TRACK);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_CLOSING_SESSION", burn::BURN_DRIVE_CLOSING_SESSION);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_FORMATTING", burn::BURN_DRIVE_FORMATTING);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_READING_SYNC", burn::BURN_DRIVE_READING_SYNC);
    PyModule_AddIntConstant(m, (char *) "BURN_DRIVE_WRITING_SYNC", burn::BURN_DRIVE_WRITING_SYNC);
    return m;
}
static PyMethodDef burn_std_functions[] = {
    {NULL, NULL, 0, NULL}
};

static PyObject *
initburn_std(void)
{
    PyObject *m;
    m = Py_InitModule3((char *) "pyburn.std", burn_std_functions, NULL);
    if (m == NULL) {
        return NULL;
    }
    return m;
}

static PyMethodDef burn_functions[] = {
    {NULL, NULL, 0, NULL}
};

PyMODINIT_FUNC
initpyburn(void)
{
    PyObject *m;
    PyObject *submodule;
    m = Py_InitModule3((char *) "pyburn", burn_functions, NULL);
    if (m == NULL) {
        return;
    }
    submodule = initpyburn_burn();
    if (submodule == NULL) {
        return;
    }
    Py_INCREF(submodule);
    PyModule_AddObject(m, (char *) "burn", submodule);
    submodule = initburn_std();
    if (submodule == NULL) {
        return;
    }
    Py_INCREF(submodule);
    PyModule_AddObject(m, (char *) "std", submodule);
}